style: rustfmt the issue #7 regression tests (CI format gate)

- fix(stealth): bind iframe contentWindow proxy methods to the real window
  (--launch "Illegal invocation" on srcdoc-iframe pages)
- fix(tabs): re-pin active target when the pinned page is removed (issue #7)
- feat(cli): coordinate click (click <x> <y> / --coords), tabs/get-text
  aliases, clearer find error (issue #8.4)
- fix(observability): screenshot/network stamp @ <url>; network --clear
  enables capture immediately (issues #8.1/#8.3)
- fix(ab-connect 0.4.2): stale sessionId fails loudly instead of routing to a
  random tab (issue #8.1) — needs a Chrome Web Store republish
- restart notice now flags in-memory context reset (issue #8.2)

README.md

@@ -225,7 +225,7 @@ When connected to your real Chrome, we inject **zero** JavaScript patches. Your
 
 `0% stealth` on CreepJS is the key number: because the connect path patches **nothing**, there is no override for a lie-detector to catch. (Dashboards that read `navigator.languages` order or IP geolocation may show a soft "navigator"/"location" flag — that tracks *your real Chrome's* language list and network, not an automation tell.)
 
-When using `--launch` mode (standalone browser), a full suite of stealth patches is applied instead, and it still passes the suite above.
+When using `--launch` mode (standalone browser), a full suite of stealth patches is applied instead, and it passes the suite above — with one caveat: CreepJS reports **~20% stealth** because the srcdoc-iframe `contentWindow` patch trips its `hasIframeProxy` probe (the proxy that hides automation is itself a tell). Everything else is clean (`0% headless`, sannysoft/browserscan green, Cloudflare passed). Set **`AGENT_BROWSER_DISABLE_IFRAME_PROXY=1`** to drop that patch for a clean **0% stealth** (trades the niche srcdoc-iframe masking). The **extension-connect path** (your real Chrome) injects zero JS and is unaffected — it's the genuine 0% path.
 
 ### Human-like input (behavioural stealth)
 

cli/Cargo.lock

@@ -45,7 +45,7 @@ dependencies = [
 
 [[package]]
 name = "agent-browser-stealth"
-version = "0.27.0-fork.42"
+version = "0.27.0-fork.51"
 dependencies = [
  "aes-gcm",
  "async-trait",

cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "agent-browser-stealth"
-version = "0.27.0-fork.42"
+version = "0.27.0-fork.51"
 edition = "2021"
 description = "Fast browser automation CLI for AI agents"
 license = "Apache-2.0"

cli/src/commands.rs

@@ -375,12 +375,25 @@ fn parse_command_inner(args: &[String], flags: &Flags) -> Result<Value, ParseErr
         // === Core Actions ===
         "click" => {
             let new_tab = rest.contains(&"--new-tab");
+            // Coordinate click as a first-class form (issue #8.4): when the only
+            // handle is a pixel position, no element/selector is needed.
+            //   click <x> <y>          e.g. click 449 320
+            //   click <x>,<y>          e.g. click 449,320
+            //   click --coords <x>,<y> | --coords <x> <y>
+            let coord_args: Vec<&str> = rest
+                .iter()
+                .copied()
+                .filter(|a| *a != "--new-tab" && *a != "--coords")
+                .collect();
+            if let Some((x, y)) = parse_coords(&coord_args) {
+                return Ok(json!({ "id": id, "action": "click", "x": x, "y": y }));
+            }
             let sel = rest
                 .iter()
                 .find(|arg| **arg != "--new-tab")
                 .ok_or_else(|| ParseError::MissingArguments {
                     context: "click".to_string(),
-                    usage: "click <selector> [--new-tab]",
+                    usage: "click <selector> | click <x> <y> | click --coords <x>,<y> [--new-tab]",
                 })?;
             if new_tab {
                 Ok(json!({ "id": id, "action": "click", "selector": sel, "newTab": true }))
@@ -403,12 +416,48 @@ fn parse_command_inner(args: &[String], flags: &Flags) -> Result<Value, ParseErr
             Ok(json!({ "id": id, "action": "fill", "selector": sel, "value": rest[1..].join(" ") }))
         }
         "type" => {
+            // `type --focused <text>` types into whatever element currently has
+            // focus (no selector) — for custom widgets that move focus to a hidden
+            // input after you open them.
+            if rest.first() == Some(&"--focused") {
+                return Ok(json!({
+                    "id": id, "action": "type", "focused": true,
+                    "text": rest[1..].join(" "),
+                }));
+            }
             let sel = rest.first().ok_or_else(|| ParseError::MissingArguments {
                 context: "type".to_string(),
-                usage: "type <selector> <text>",
+                usage: "type <selector> <text>   (or: type --focused <text>)",
             })?;
             Ok(json!({ "id": id, "action": "type", "selector": sel, "text": rest[1..].join(" ") }))
         }
+        "pick" => {
+            // pick <selector|@ref> --option "<text>"  — atomic combobox select:
+            // open the control, wait for options (incl. portal menus), match by
+            // text, fire the right event sequence, verify. Covers native <select>,
+            // ARIA combobox/listbox, and react-select.
+            let sel = rest.first().ok_or_else(|| ParseError::MissingArguments {
+                context: "pick".to_string(),
+                usage: "pick <selector> --option \"<text>\"",
+            })?;
+            let opt_pos = rest.iter().position(|a| *a == "--option" || *a == "-o");
+            let option = match opt_pos {
+                Some(p) => rest[p + 1..].join(" "),
+                None => {
+                    return Err(ParseError::MissingArguments {
+                        context: "pick".to_string(),
+                        usage: "pick <selector> --option \"<text>\"",
+                    })
+                }
+            };
+            if option.is_empty() {
+                return Err(ParseError::MissingArguments {
+                    context: "pick".to_string(),
+                    usage: "pick <selector> --option \"<text>\"",
+                });
+            }
+            Ok(json!({ "id": id, "action": "pick", "selector": sel, "option": option }))
+        }
         "hover" => {
             let sel = rest.first().ok_or_else(|| ParseError::MissingArguments {
                 context: "hover".to_string(),
@@ -841,17 +890,31 @@ fn parse_command_inner(args: &[String], flags: &Flags) -> Result<Value, ParseErr
 
         // === Eval ===
         "eval" => {
-            // Check for flags: -b/--base64 or --stdin
-            let (is_base64, is_stdin, script_parts): (bool, bool, &[&str]) =
+            // Check for flags: -b/--base64, --stdin, or --file <path>
+            let (is_base64, is_stdin, is_file, script_parts): (bool, bool, bool, &[&str]) =
                 if rest.first() == Some(&"-b") || rest.first() == Some(&"--base64") {
-                    (true, false, &rest[1..])
+                    (true, false, false, &rest[1..])
                 } else if rest.first() == Some(&"--stdin") {
-                    (false, true, &rest[1..])
+                    (false, true, false, &rest[1..])
+                } else if rest.first() == Some(&"--file") {
+                    (false, false, true, &rest[1..])
                 } else {
-                    (false, false, rest.as_slice())
+                    (false, false, false, rest.as_slice())
                 };
 
-            let script = if is_stdin {
+            let script = if is_file {
+                // Read the script from a file. Avoids shell-mangling of inline JS
+                // (non-ASCII identifiers/strings, quotes, large scripts) — the file
+                // is read as UTF-8 and sent verbatim.
+                let path = script_parts.first().ok_or(ParseError::InvalidValue {
+                    message: "eval --file requires a path".to_string(),
+                    usage: "eval --file <path>",
+                })?;
+                std::fs::read_to_string(path).map_err(|e| ParseError::InvalidValue {
+                    message: format!("eval --file: cannot read {path}: {e}"),
+                    usage: "eval --file <path>",
+                })?
+            } else if is_stdin {
                 // Read script from stdin
                 let stdin = io::stdin();
                 let lines: Vec<String> = stdin
@@ -881,6 +944,15 @@ fn parse_command_inner(args: &[String], flags: &Flags) -> Result<Value, ParseErr
             Ok(json!({ "id": id, "action": "evaluate", "script": script }))
         }
 
+        // === Stealth self-check ===
+        "stealth" => {
+            // `stealth [status]` — local stealth self-check: mode, live probes
+            // (navigator.webdriver, window.chrome, plugins, UA), and the list of
+            // active overrides. --json for a stable machine-readable shape.
+            // (Distinct from `doctor`, which checks install/env/Chrome health.)
+            Ok(json!({ "id": id, "action": "stealth_status" }))
+        }
+
         // === Close ===
         "close" | "quit" | "exit" => Ok(json!({ "id": id, "action": "close" })),
 
@@ -1149,6 +1221,15 @@ fn parse_command_inner(args: &[String], flags: &Flags) -> Result<Value, ParseErr
             parse_get(&get_args, &id)
         }
 
+        // Hyphen/underscore aliases for `get text <selector>` — agents naturally
+        // guess `get-text` / `get_text` (issue #8.4).
+        "get-text" | "get_text" => {
+            let mut get_args: Vec<&str> = Vec::with_capacity(rest.len() + 1);
+            get_args.push("text");
+            get_args.extend_from_slice(&rest);
+            parse_get(&get_args, &id)
+        }
+
         // === Is (state checks) ===
         "is" => parse_is(&rest, &id),
 
@@ -1330,7 +1411,9 @@ fn parse_command_inner(args: &[String], flags: &Flags) -> Result<Value, ParseErr
         }
 
         // === Tabs ===
-        "tab" => {
+        // `tabs` (plural) is a natural guess for the `tab` subcommand tree —
+        // alias it so `tabs` / `tabs list` / `tabs new` all work (issue #8.4).
+        "tab" | "tabs" => {
             match rest.first().copied() {
                 Some("new") => {
                     // Accepted forms:
@@ -2254,19 +2337,6 @@ fn parse_is(rest: &[&str], id: &str) -> Result<Value, ParseError> {
 }
 
 fn parse_find(rest: &[&str], id: &str) -> Result<Value, ParseError> {
-    const VALID: &[&str] = &[
-        "role",
-        "text",
-        "label",
-        "placeholder",
-        "alt",
-        "title",
-        "testid",
-        "first",
-        "last",
-        "nth",
-    ];
-
     let locator = rest.first().ok_or_else(|| ParseError::MissingArguments {
         context: "find".to_string(),
         usage: "find <locator> <value> [action] [text]",
@@ -2436,13 +2506,37 @@ fn parse_find(rest: &[&str], id: &str) -> Result<Value, ParseError> {
             }
             Ok(cmd)
         }
-        _ => Err(ParseError::UnknownSubcommand {
-            subcommand: locator.to_string(),
-            valid_options: VALID,
+        _ => Err(ParseError::InvalidValue {
+            // The user passed a value where a locator keyword was expected — the
+            // classic `find "I'm not a robot" click` mistake (issue #8.4). Lead
+            // with the corrected command using their own value, then the menu.
+            message: format!(
+                "`{loc}` is not a find locator. To match by visible text, name the locator:\n  \
+                 agent-browser find text \"{loc}\" click\n\n\
+                 Locators: role, text, label, placeholder, alt, title, testid, first, last, nth\n\
+                 Examples:\n  \
+                 agent-browser find text \"Sign in\" click\n  \
+                 agent-browser find role button --name \"Submit\" click\n  \
+                 agent-browser find label \"Email\" fill you@example.com",
+                loc = locator,
+            ),
+            usage: "find <locator> <value> [action] [text]",
         }),
     }
 }
 
+/// Parse a coordinate pair from `["449","320"]`, `["449,320"]`, or `["449, 320"]`.
+/// Returns None if the args aren't a clean numeric pair (so callers fall back to
+/// treating the argument as a selector). Used by first-class coordinate `click`.
+fn parse_coords(args: &[&str]) -> Option<(f64, f64)> {
+    let (a, b) = match args {
+        [one] => one.split_once(',')?,
+        [a, b] => (*a, *b),
+        _ => return None,
+    };
+    Some((a.trim().parse().ok()?, b.trim().parse().ok()?))
+}
+
 fn parse_mouse(rest: &[&str], id: &str) -> Result<Value, ParseError> {
     const VALID: &[&str] = &["move", "down", "up", "wheel"];
 
@@ -3491,6 +3585,79 @@ mod tests {
         assert_eq!(cmd["action"], "reload");
     }
 
+    // === issue #8.4: CLI ergonomics ===
+
+    #[test]
+    fn test_click_coords_two_args() {
+        let cmd = parse_command(&args("click 449 320"), &default_flags()).unwrap();
+        assert_eq!(cmd["action"], "click");
+        assert_eq!(cmd["x"], 449.0);
+        assert_eq!(cmd["y"], 320.0);
+        assert!(cmd.get("selector").is_none());
+    }
+
+    #[test]
+    fn test_click_coords_comma() {
+        let cmd = parse_command(&args("click 449,320"), &default_flags()).unwrap();
+        assert_eq!(cmd["x"], 449.0);
+        assert_eq!(cmd["y"], 320.0);
+    }
+
+    #[test]
+    fn test_click_coords_flag() {
+        let cmd = parse_command(&args("click --coords 449,320"), &default_flags()).unwrap();
+        assert_eq!(cmd["x"], 449.0);
+        assert_eq!(cmd["y"], 320.0);
+    }
+
+    #[test]
+    fn test_click_selector_not_coords() {
+        let cmd = parse_command(&args("click button.submit"), &default_flags()).unwrap();
+        assert_eq!(cmd["action"], "click");
+        assert_eq!(cmd["selector"], "button.submit");
+        assert!(cmd.get("x").is_none());
+    }
+
+    #[test]
+    fn test_tabs_alias_lists() {
+        assert_eq!(
+            parse_command(&args("tabs"), &default_flags()).unwrap()["action"],
+            "tab_list"
+        );
+        assert_eq!(
+            parse_command(&args("tabs list"), &default_flags()).unwrap()["action"],
+            "tab_list"
+        );
+        assert_eq!(
+            parse_command(&args("tabs new"), &default_flags()).unwrap()["action"],
+            "tab_new"
+        );
+    }
+
+    #[test]
+    fn test_get_text_hyphen_and_underscore_aliases() {
+        for verb in ["get-text", "get_text"] {
+            let cmd = parse_command(&args(&format!("{verb} .price")), &default_flags()).unwrap();
+            assert_eq!(cmd["action"], "gettext", "{verb}");
+            assert_eq!(cmd["selector"], ".price", "{verb}");
+        }
+    }
+
+    #[test]
+    fn test_find_bare_value_suggests_text_locator() {
+        // `find "I'm not a robot" click` — value where a locator keyword was
+        // expected. Error must steer to the corrected `find text ...` form.
+        let input: Vec<String> = vec![
+            "find".to_string(),
+            "I'm not a robot".to_string(),
+            "click".to_string(),
+        ];
+        let err = parse_command(&input, &default_flags()).unwrap_err();
+        let msg = err.format();
+        assert!(msg.contains("find text"), "got: {msg}");
+        assert!(msg.contains("I'm not a robot"), "got: {msg}");
+    }
+
     // === Core Actions ===
 
     #[test]

cli/src/connection.rs

@@ -625,7 +625,10 @@ pub fn ensure_daemon(session: &str, opts: &DaemonOptions) -> Result<DaemonResult
             // version (e.g. after an upgrade), kill it and start a fresh one.
             if !daemon_version_matches(session) {
                 eprintln!(
-                    "{} Daemon version mismatch detected, restarting...",
+                    "{} Daemon version mismatch detected, restarting... \
+                     In-memory context (active tab, refs, captured requests) is reset. \
+                     If the next read looks blank or lands on the wrong page, re-open \
+                     your target URL before retrying (issue #8.2).",
                     crate::color::warning_indicator()
                 );
                 // Best-effort: ask the old daemon for its current URL so the
@@ -821,7 +824,33 @@ fn connect(session: &str) -> Result<Connection, String> {
     }
 }
 
-pub fn send_command(cmd: Value, session: &str) -> Result<Response, String> {
+pub fn send_command(mut cmd: Value, session: &str) -> Result<Response, String> {
+    // Forward per-invocation env to the daemon. The daemon's environment is
+    // frozen at spawn, so settings like AGENT_BROWSER_CLICK_MODE /
+    // AGENT_BROWSER_HUMANIZE (incl. the --humanize flag, which sets the latter)
+    // are otherwise silently ignored on an already-running daemon. Carry them in
+    // the envelope so they apply to THIS command.
+    if let Some(obj) = cmd.as_object_mut() {
+        if let Ok(m) = std::env::var("AGENT_BROWSER_CLICK_MODE") {
+            obj.insert("_clickMode".to_string(), Value::String(m));
+        }
+        if let Ok(h) = std::env::var("AGENT_BROWSER_HUMANIZE") {
+            // Only forward a recognized level; warn once (like the --humanize flag
+            // does) when the env var is set to garbage, instead of silently
+            // ignoring it.
+            if crate::native::humanize::HumanizeLevel::parse(&h).is_some() {
+                obj.insert("_humanize".to_string(), Value::String(h));
+            } else {
+                static WARNED: std::sync::Once = std::sync::Once::new();
+                WARNED.call_once(|| {
+                    eprintln!(
+                        "warning: AGENT_BROWSER_HUMANIZE must be off|fast|human, got {h:?} (ignored)"
+                    );
+                });
+            }
+        }
+    }
+
     // Retry logic for transient errors (EAGAIN/EWOULDBLOCK/connection issues)
     const MAX_RETRIES: u32 = 5;
     const RETRY_DELAY_MS: u64 = 200;

cli/src/native/actions.rs

@@ -1160,6 +1160,23 @@ impl Drop for DaemonState {
 
 pub async fn execute_command(cmd: &Value, state: &mut DaemonState) -> Value {
     let action = cmd.get("action").and_then(|v| v.as_str()).unwrap_or("");
+
+    // Apply per-invocation overrides the client forwarded (the daemon's own env
+    // is frozen at spawn). CLICK_MODE is read fresh from the process env by
+    // interaction::click, so mirror it here — set when this command provided it,
+    // clear otherwise, so a value from an earlier command never leaks forward.
+    match cmd.get("_clickMode").and_then(|v| v.as_str()) {
+        Some(m) if !m.is_empty() => std::env::set_var("AGENT_BROWSER_CLICK_MODE", m),
+        _ => std::env::remove_var("AGENT_BROWSER_CLICK_MODE"),
+    }
+    // Humanize: set the session level from the client's --humanize / env. Only
+    // set when provided (don't clear — the adaptive per-navigation detector also
+    // owns this level between explicit overrides).
+    if let Some(h) = cmd.get("_humanize").and_then(|v| v.as_str()) {
+        if let Some(level) = super::humanize::HumanizeLevel::parse(h) {
+            super::humanize::set_detected_level(level);
+        }
+    }
     let id = cmd
         .get("id")
         .and_then(|v| v.as_str())
@@ -1299,6 +1316,7 @@ pub async fn execute_command(cmd: &Value, state: &mut DaemonState) -> Value {
         "content" => handle_content(state).await,
         "evaluate" => handle_evaluate(cmd, state).await,
         "close" => handle_close(state).await,
+        "stealth_status" => handle_stealth_status(state).await,
         "snapshot" => handle_snapshot(cmd, state).await,
         "screenshot" => handle_screenshot(cmd, state).await,
         "click" => handle_click(cmd, state).await,
@@ -1306,6 +1324,7 @@ pub async fn execute_command(cmd: &Value, state: &mut DaemonState) -> Value {
         "fill" => handle_fill(cmd, state).await,
         "type" => handle_type(cmd, state).await,
         "press" => handle_press(cmd, state).await,
+        "pick" => handle_pick(cmd, state).await,
         "hover" => handle_hover(cmd, state).await,
         "scroll" => handle_scroll(cmd, state).await,
         "select" => handle_select(cmd, state).await,
@@ -2662,6 +2681,89 @@ async fn handle_evaluate(cmd: &Value, state: &DaemonState) -> Result<Value, Stri
     Ok(json!({ "result": result, "origin": url }))
 }
 
+/// Local stealth self-check: reports the active mode, live fingerprint probes,
+/// and the list of applied overrides — so an agent (or human) can confirm
+/// stealth is working without driving an external detector, and audit exactly
+/// what's patched on this path (issue #5).
+async fn handle_stealth_status(state: &DaemonState) -> Result<Value, String> {
+    let mgr = state.browser.as_ref().ok_or("Browser not launched")?;
+    let connect = mgr.is_cdp_connection();
+
+    let probe_js = r#"(() => {
+        const ua = navigator.userAgent || '';
+        return {
+            webdriver: navigator.webdriver === true,
+            hasWindowChrome: typeof window.chrome === 'object' && window.chrome !== null,
+            plugins: navigator.plugins ? navigator.plugins.length : 0,
+            languages: navigator.languages || [],
+            platform: navigator.platform || '',
+            headlessUA: /Headless/i.test(ua),
+        };
+    })()"#;
+    let p = mgr.evaluate(probe_js, None).await.unwrap_or(Value::Null);
+    let webdriver = p.get("webdriver").and_then(|v| v.as_bool()).unwrap_or(true);
+    let has_chrome = p
+        .get("hasWindowChrome")
+        .and_then(|v| v.as_bool())
+        .unwrap_or(false);
+    let plugins = p.get("plugins").and_then(|v| v.as_u64()).unwrap_or(0);
+    let headless_ua = p
+        .get("headlessUA")
+        .and_then(|v| v.as_bool())
+        .unwrap_or(false);
+
+    let checks = json!([
+        { "name": "navigator.webdriver is false", "pass": !webdriver },
+        { "name": "window.chrome present", "pass": has_chrome },
+        { "name": "navigator.plugins non-empty", "pass": plugins > 0, "value": plugins },
+        { "name": "userAgent has no 'Headless'", "pass": !headless_ua },
+    ]);
+    let ok = !webdriver && has_chrome && plugins > 0 && !headless_ua;
+
+    let overrides = if connect {
+        json!([
+            "navigator.webdriver=false via Emulation.setAutomationOverride (native CDP — no JS lie)",
+            "Runtime.enable OFF unless console/error capture is opted in (no rebrowser runtime leak)",
+            "zero JS patches injected — the browser's real fingerprint is used as-is",
+        ])
+    } else {
+        let iframe_proxy =
+            std::env::var("AGENT_BROWSER_DISABLE_IFRAME_PROXY").as_deref() != Ok("1");
+        json!([
+            "navigator.webdriver removed; navigator.languages/locale normalized",
+            "window.chrome / chrome.runtime shimmed; navigator.platform fixed",
+            "WebGL vendor/renderer, plugins, permissions normalized",
+            format!(
+                "srcdoc-iframe contentWindow proxy: {} (CreepJS hasIframeProxy)",
+                if iframe_proxy {
+                    "ON — set AGENT_BROWSER_DISABLE_IFRAME_PROXY=1 for clean 0%"
+                } else {
+                    "off"
+                }
+            ),
+            format!(
+                "canvas/audio noise: {} (AGENT_BROWSER_HIDE_CANVAS)",
+                if std::env::var("AGENT_BROWSER_HIDE_CANVAS").as_deref() == Ok("1") {
+                    "on"
+                } else {
+                    "off (opt-in)"
+                }
+            ),
+            "Chrome flags: --disable-blink-features=AutomationControlled, ANGLE GL",
+        ])
+    };
+
+    Ok(json!({
+        "stealthStatus": {
+            "mode": if connect { "connect (your real Chrome — strongest)" } else { "launch (standalone)" },
+            "ok": ok,
+            "checks": checks,
+            "overrides": overrides,
+            "probe": p,
+        }
+    }))
+}
+
 async fn handle_close(state: &mut DaemonState) -> Result<Value, String> {
     if let Some(ref mgr) = state.browser {
         if let Some(ref session_name) = state.session_name {
@@ -2879,11 +2981,32 @@ async fn handle_screenshot(cmd: &Value, state: &mut DaemonState) -> Result<Value
         response["annotations"] = serde_json::to_value(&result.annotations)
             .map_err(|e| format!("Failed to serialize annotations: {}", e))?;
     }
+    // Stamp which page was captured so a screenshot of the wrong tab is obvious
+    // (issue #8.1: relay sessions can drift to whatever tab the user activated).
+    if let Ok(url) = mgr.get_url().await {
+        if !url.is_empty() {
+            response["origin"] = json!(url);
+        }
+    }
 
     Ok(response)
 }
 
 async fn handle_click(cmd: &Value, state: &mut DaemonState) -> Result<Value, String> {
+    // First-class coordinate click (issue #8.4): click a raw viewport point with
+    // no element resolution. Parsed from `click <x> <y>` / `click --coords x,y`.
+    if let (Some(x), Some(y)) = (
+        cmd.get("x").and_then(|v| v.as_f64()),
+        cmd.get("y").and_then(|v| v.as_f64()),
+    ) {
+        let mgr = state.browser.as_ref().ok_or("Browser not launched")?;
+        let session_id = mgr.active_session_id()?.to_string();
+        let button = cmd.get("button").and_then(|v| v.as_str()).unwrap_or("left");
+        let click_count = cmd.get("clickCount").and_then(|v| v.as_i64()).unwrap_or(1) as i32;
+        interaction::click_at_point(&mgr.client, &session_id, x, y, button, click_count).await?;
+        return Ok(json!({ "clicked": { "x": x, "y": y } }));
+    }
+
     let selector = cmd
         .get("selector")
         .and_then(|v| v.as_str())
@@ -3014,6 +3137,22 @@ async fn handle_fill(cmd: &Value, state: &mut DaemonState) -> Result<Value, Stri
 async fn handle_type(cmd: &Value, state: &mut DaemonState) -> Result<Value, String> {
     let mgr = state.browser.as_ref().ok_or("Browser not launched")?;
     let session_id = mgr.active_session_id()?.to_string();
+
+    // `type --focused <text>`: type into the currently-focused element without a
+    // selector (custom widgets that move focus to a hidden input on open).
+    if cmd
+        .get("focused")
+        .and_then(|v| v.as_bool())
+        .unwrap_or(false)
+    {
+        let text = cmd
+            .get("text")
+            .and_then(|v| v.as_str())
+            .ok_or("Missing 'text' parameter")?;
+        interaction::type_text_into_active_context(&mgr.client, &session_id, text, None).await?;
+        return Ok(json!({ "typed": text, "focused": true }));
+    }
+
     let selector = cmd
         .get("selector")
         .and_then(|v| v.as_str())
@@ -3039,6 +3178,103 @@ async fn handle_type(cmd: &Value, state: &mut DaemonState) -> Result<Value, Stri
     Ok(json!({ "typed": text }))
 }
 
+/// Atomic combobox select: `pick <selector> --option "<text>"`. Opens the control
+/// (so a portal-rendered menu mounts), polls for the option by visible text, then
+/// fires the full pointer/mouse event sequence on it — covering native `<select>`,
+/// ARIA combobox/listbox, and react-select, which a bare `click`+`press Enter`
+/// can't do reliably. Runs as one in-page async routine so the open→render→pick
+/// dance happens without round-trips that let the menu collapse between commands.
+async fn handle_pick(cmd: &Value, state: &mut DaemonState) -> Result<Value, String> {
+    let mgr = state.browser.as_ref().ok_or("Browser not launched")?;
+    let session_id = mgr.active_session_id()?.to_string();
+    let selector = cmd
+        .get("selector")
+        .and_then(|v| v.as_str())
+        .ok_or("Missing 'selector' parameter")?;
+    let option = cmd
+        .get("option")
+        .and_then(|v| v.as_str())
+        .ok_or("Missing 'option' parameter")?;
+
+    let (object_id, effective_session_id) = super::element::resolve_element_object_id(
+        &mgr.client,
+        &session_id,
+        &state.ref_map,
+        selector,
+        &state.iframe_sessions,
+    )
+    .await?;
+
+    let func = format!(
+        r#"async function() {{
+            const want = {opt};
+            const norm = s => (s || '').replace(/\s+/g, ' ').trim();
+            const matches = el => norm(el.textContent).toLowerCase().includes(want.toLowerCase());
+            const el = this;
+            const fire = (n, t) => n.dispatchEvent(new MouseEvent(t, {{ bubbles: true, cancelable: true, view: window }}));
+
+            // Native <select>: set the matching option and dispatch input/change.
+            if (el.tagName === 'SELECT') {{
+                const opt = [...el.options].find(matches);
+                if (!opt) return {{ ok: false, error: 'no <option> matched ' + JSON.stringify(want) }};
+                el.value = opt.value;
+                el.dispatchEvent(new Event('input', {{ bubbles: true }}));
+                el.dispatchEvent(new Event('change', {{ bubbles: true }}));
+                return {{ ok: true, picked: norm(opt.textContent), value: el.value, kind: 'select' }};
+            }}
+
+            // Custom widget: open it.
+            (el.focus && el.focus());
+            ['pointerdown', 'mousedown', 'mouseup', 'click'].forEach(t => fire(el, t));
+
+            // Poll for the option to render anywhere in the document (portals
+            // mount the menu outside the trigger), then click it.
+            const sel = '[role=option], [role=listbox] [role=option], li[role=option], [class*=option], [class*=item]';
+            const find = () => [...document.querySelectorAll(sel)].find(o => o.offsetParent !== null && matches(o));
+            const deadline = Date.now() + 2500;
+            let opt = find();
+            while (!opt && Date.now() < deadline) {{
+                await new Promise(r => setTimeout(r, 80));
+                opt = find();
+            }}
+            if (!opt) return {{ ok: false, error: 'option ' + JSON.stringify(want) + ' did not appear after opening the control' }};
+            (opt.scrollIntoView && opt.scrollIntoView({{ block: 'center' }}));
+            ['pointermove', 'pointerover', 'mouseover', 'pointerdown', 'mousedown', 'mouseup', 'click'].forEach(t => fire(opt, t));
+            return {{ ok: true, picked: norm(opt.textContent), kind: 'custom' }};
+        }}"#,
+        opt = serde_json::to_string(option).unwrap_or_default(),
+    );
+
+    let result: super::cdp::types::EvaluateResult = mgr
+        .client
+        .send_command_typed(
+            "Runtime.callFunctionOn",
+            &super::cdp::types::CallFunctionOnParams {
+                function_declaration: func,
+                object_id: Some(object_id),
+                arguments: None,
+                return_by_value: Some(true),
+                await_promise: Some(true),
+            },
+            Some(&effective_session_id),
+        )
+        .await?;
+
+    if let Some(ref ex) = result.exception_details {
+        return Err(format!("pick failed: {}", ex.text));
+    }
+    let val = result.result.value.unwrap_or(Value::Null);
+    if val.get("ok").and_then(|v| v.as_bool()).unwrap_or(false) {
+        Ok(json!({ "picked": val.get("picked"), "selector": selector }))
+    } else {
+        Err(val
+            .get("error")
+            .and_then(|v| v.as_str())
+            .unwrap_or("pick failed")
+            .to_string())
+    }
+}
+
 async fn handle_press(cmd: &Value, state: &mut DaemonState) -> Result<Value, String> {
     let mgr = state.browser.as_ref().ok_or("Browser not launched")?;
     let session_id = mgr.active_session_id()?.to_string();
@@ -7685,23 +7921,40 @@ pub fn matches_status_filter(status: Option<i64>, filter: &str) -> bool {
     false
 }
 
+async fn enable_request_tracking(state: &mut DaemonState) {
+    if state.request_tracking {
+        return;
+    }
+    state.request_tracking = true;
+    if let Some(ref mgr) = state.browser {
+        if let Ok(session_id) = mgr.active_session_id() {
+            let _ = mgr
+                .client
+                .send_command_no_params("Network.enable", Some(session_id))
+                .await;
+        }
+    }
+}
+
 async fn handle_requests(cmd: &Value, state: &mut DaemonState) -> Result<Value, String> {
     if cmd.get("clear").and_then(|v| v.as_bool()).unwrap_or(false) {
         state.tracked_requests.clear();
+        // Enable Network capture NOW, on `--clear`, not lazily on the next read.
+        // `--clear` is the canonical "start capturing fresh" call, so requests
+        // fired between it and the following `requests` read must be tracked.
+        // Lazy-enabling only on read missed exactly those → intermittent
+        // "No requests captured" on the first try, fine on retry (issue #8.3).
+        enable_request_tracking(state).await;
         return Ok(json!({ "cleared": true }));
     }
 
-    if !state.request_tracking {
-        state.request_tracking = true;
-        if let Some(ref mgr) = state.browser {
-            if let Ok(session_id) = mgr.active_session_id() {
-                let _ = mgr
-                    .client
-                    .send_command_no_params("Network.enable", Some(session_id))
-                    .await;
-            }
-        }
-    }
+    enable_request_tracking(state).await;
+    // Current page URL, so a `requests` read on a drifted/wrong tab is obvious
+    // and "0 captured" can't be confused with "wrong page" (issues #8.1/#8.3).
+    let origin = match state.browser.as_ref() {
+        Some(mgr) => mgr.get_url().await.ok().filter(|u| !u.is_empty()),
+        None => None,
+    };
 
     let filter = cmd.get("filter").and_then(|v| v.as_str());
     let type_filter = cmd.get("type").and_then(|v| v.as_str());
@@ -7738,7 +7991,14 @@ async fn handle_requests(cmd: &Value, state: &mut DaemonState) -> Result<Value,
         })
         .collect();
 
-    Ok(json!({ "requests": requests }))
+    // NB: do NOT add a top-level `count` field here — the human formatter treats
+    // any `{count}` as a `get count` result and prints just the number, which
+    // would swallow the request list. The list length is self-evident.
+    let mut response = json!({ "requests": requests });
+    if let Some(o) = origin {
+        response["origin"] = json!(o);
+    }
+    Ok(response)
 }
 
 async fn handle_request_detail(cmd: &Value, state: &mut DaemonState) -> Result<Value, String> {

cli/src/native/browser.rs

@@ -315,6 +315,13 @@ pub struct BrowserManager {
     /// browser after it ends. Only ever holds tabs we created — never the user's
     /// existing tabs or other sessions' tabs — so closing them is always safe.
     created_targets: HashSet<String>,
+    /// The session's *intended* active tab, pinned by stable target_id rather
+    /// than the fragile `active_page_index`. Set on every explicit open / tab new
+    /// / tab switch. `active_session_id` resolves through this so a foreign tab
+    /// opening (passive discovery), a tab closing, or list reordering can't drift
+    /// the session's commands onto the wrong page — the wrong-origin-fetch hazard
+    /// in the dogfood reports. Falls back to the index if the pinned tab is gone.
+    active_target_id: Option<String>,
     next_tab_id: u32,
     /// Whether to enable the CDP `Runtime` domain (console / error / exception capture).
     /// OFF by default for stealth: a live `Runtime.enable` is a detectable CDP signal
@@ -440,6 +447,7 @@ impl BrowserManager {
                 ignore_https_errors,
                 visited_origins: HashSet::new(),
                 created_targets: HashSet::new(),
+                active_target_id: None,
                 next_tab_id: 1,
                 capture_console: console_capture_enabled(),
             };
@@ -531,6 +539,7 @@ impl BrowserManager {
             ignore_https_errors: false,
             visited_origins: HashSet::new(),
             created_targets: HashSet::new(),
+            active_target_id: None,
             next_tab_id: 1,
             capture_console: console_capture_enabled(),
         };
@@ -547,6 +556,7 @@ impl BrowserManager {
                 target_type: "page".to_string(),
             });
             manager.active_page_index = 0;
+            manager.pin_active_target();
             manager.enable_domains_direct().await?;
         } else {
             manager.discover_and_attach_targets().await?;
@@ -621,6 +631,7 @@ impl BrowserManager {
                 target_type: "page".to_string(),
             });
             self.active_page_index = 0;
+            self.pin_active_target();
             self.enable_domains(&attach_result.session_id).await?;
         } else {
             for target in &page_targets {
@@ -650,6 +661,7 @@ impl BrowserManager {
             }
 
             self.active_page_index = 0;
+            self.pin_active_target();
             let session_id = self.pages[0].session_id.clone();
             self.enable_domains(&session_id).await?;
         }
@@ -736,9 +748,31 @@ impl BrowserManager {
         Ok(())
     }
 
+    /// Index of the session's active page, resolved through the pinned
+    /// `active_target_id` (stable across reorder/removal/passive discovery) and
+    /// falling back to `active_page_index` when nothing is pinned or the pin is
+    /// gone. This is what keeps commands on the tab the agent actually opened.
+    fn resolved_active_index(&self) -> usize {
+        if let Some(tid) = &self.active_target_id {
+            if let Some(i) = self.pages.iter().position(|p| &p.target_id == tid) {
+                return i;
+            }
+        }
+        self.active_page_index
+    }
+
+    /// Pin the current active page by target_id so later commands stick to it.
+    /// Call after any explicit open / tab new / tab switch.
+    fn pin_active_target(&mut self) {
+        self.active_target_id = self
+            .pages
+            .get(self.active_page_index)
+            .map(|p| p.target_id.clone());
+    }
+
     pub fn active_session_id(&self) -> Result<&str, String> {
         self.pages
-            .get(self.active_page_index)
+            .get(self.resolved_active_index())
             .map(|p| p.session_id.as_str())
             .ok_or_else(|| "No active page".to_string())
     }
@@ -991,7 +1025,7 @@ impl BrowserManager {
 
     pub fn active_target_id(&self) -> Result<&str, String> {
         self.pages
-            .get(self.active_page_index)
+            .get(self.resolved_active_index())
             .map(|p| p.target_id.as_str())
             .ok_or_else(|| "No active page".to_string())
     }
@@ -1219,6 +1253,7 @@ impl BrowserManager {
             target_type: "page".to_string(),
         });
         self.active_page_index = index;
+        self.pin_active_target();
 
         Ok(json!({
             "tabId": format_tab_id(tab_id),
@@ -1238,6 +1273,7 @@ impl BrowserManager {
         }
 
         self.active_page_index = index;
+        self.pin_active_target();
         let session_id = self.pages[index].session_id.clone();
         self.enable_domains(&session_id).await?;
 
@@ -1581,6 +1617,7 @@ impl BrowserManager {
         let index = self.pages.len();
         self.pages.push(page);
         self.active_page_index = index;
+        self.pin_active_target();
     }
 
     /// Add a passively-discovered page WITHOUT changing the active tab.
@@ -1604,8 +1641,18 @@ impl BrowserManager {
 
     pub fn remove_page_by_target_id(&mut self, target_id: &str) {
         if let Some(pos) = self.pages.iter().position(|p| p.target_id == target_id) {
+            let removed_was_pinned = self.active_target_id.as_deref() == Some(target_id);
             self.pages.remove(pos);
             self.update_active_page_after_removal(pos);
+            // If we just removed the pinned active target, the pin now dangles and
+            // `resolved_active_index` silently falls back to `active_page_index`.
+            // After a passive about:blank discovery that index can point at a blank
+            // tab, so `wait` → eval/snapshot lands on about:blank (issue #7). Re-pin
+            // to the surviving active page so the pin is never left pointing at a
+            // target that no longer exists.
+            if removed_was_pinned {
+                self.pin_active_target();
+            }
         }
     }
 
@@ -1783,6 +1830,7 @@ async fn initialize_lightpanda_manager(
             ignore_https_errors: false,
             visited_origins: HashSet::new(),
             created_targets: HashSet::new(),
+            active_target_id: None,
             next_tab_id: 1,
             capture_console: console_capture_enabled(),
         };
@@ -2067,6 +2115,72 @@ mod tests {
         assert_eq!(active_page_index_after_removal(0, 0, 0), 0);
     }
 
+    // issue #7: removing the pinned active target must re-anchor the pin to a
+    // surviving page. Models `remove_page_by_target_id`'s index + re-pin steps
+    // purely (BrowserManager needs a live CDP client, so the method itself can't
+    // be unit-constructed). The invariant: after removal the pin never dangles
+    // and never silently resolves to a passively-discovered about:blank tab.
+    fn simulate_remove(
+        target_ids: &[&str],
+        active_index: usize,
+        pinned: &str,
+        remove_id: &str,
+    ) -> (Vec<String>, usize, Option<String>) {
+        let pos = target_ids.iter().position(|t| *t == remove_id).unwrap();
+        let removed_was_pinned = pinned == remove_id;
+        let mut pages: Vec<String> = target_ids.iter().map(|s| s.to_string()).collect();
+        pages.remove(pos);
+        let new_active = active_page_index_after_removal(active_index, pos, pages.len());
+        let new_pin = if removed_was_pinned {
+            pages.get(new_active).cloned()
+        } else {
+            Some(pinned.to_string())
+        };
+        (pages, new_active, new_pin)
+    }
+
+    fn resolve_active<'a>(
+        pages: &'a [String],
+        active_index: usize,
+        pin: &Option<String>,
+    ) -> &'a str {
+        if let Some(tid) = pin {
+            if let Some(p) = pages.iter().find(|p| *p == tid) {
+                return p;
+            }
+        }
+        pages.get(active_index).map(|s| s.as_str()).unwrap_or("")
+    }
+
+    #[test]
+    fn test_removing_unpinned_blank_keeps_pin_on_real_page() {
+        // pages = [creepjs(pinned, active), about:blank]; a passive blank closes.
+        let (pages, active, pin) = simulate_remove(&["creepjs", "blank"], 0, "creepjs", "blank");
+        assert_eq!(resolve_active(&pages, active, &pin), "creepjs");
+    }
+
+    #[test]
+    fn test_removing_pinned_page_repins_to_survivor_not_dangling() {
+        // pages = [blank, creepjs(pinned, active)]; the pinned page itself closes.
+        let (pages, active, pin) = simulate_remove(&["blank", "creepjs"], 1, "creepjs", "creepjs");
+        // pin must point at a page that still exists (no dangling fallback).
+        let resolved = resolve_active(&pages, active, &pin);
+        assert!(
+            pages.iter().any(|p| p == resolved),
+            "resolved a dangling target"
+        );
+        assert_eq!(resolved, "blank");
+    }
+
+    #[test]
+    fn test_resolve_falls_back_cleanly_when_pin_dangles() {
+        // A stale pin (target already gone) must resolve to a real surviving page,
+        // never panic or return the missing id.
+        let pages = vec!["creepjs".to_string(), "blank".to_string()];
+        let pin = Some("gone".to_string());
+        assert_eq!(resolve_active(&pages, 0, &pin), "creepjs");
+    }
+
     #[test]
     fn test_validate_launch_options_extensions_and_cdp() {
         let ext = vec!["/path/to/ext".to_string()];

cli/src/native/element.rs

@@ -556,8 +556,12 @@ async fn verify_ref_identity(
     Err(format!(
         "Ref {} no longer matches its snapshot. Was [{} \"{}\"], now [{} \"{}\"].\n\
          The DOM mutated between snapshot and interaction (typical with React/Vue \
-         reusing nodes during re-render). Take a fresh snapshot, then re-target.\n\
-         To bypass this guard set AGENT_BROWSER_VERIFY_REF=0.",
+         reusing nodes during re-render). Fix: take a fresh `snapshot` and re-target \
+         with the new ref. For SPAs where refs churn every interaction, drive the \
+         element directly with `eval` (e.g. `eval \"document.querySelector(...).click()\"`), \
+         which doesn't depend on refs.\n\
+         (Last resort: AGENT_BROWSER_VERIFY_REF=0 disables this safety check — only \
+         if you accept clicks may land on a re-rendered/wrong node.)",
         ref_id, expected_role, expected_name, actual_role, actual_name,
     ))
 }

cli/src/native/interaction.rs

@@ -4,7 +4,7 @@ use serde_json::Value;
 
 use super::cdp::client::CdpClient;
 use super::cdp::types::*;
-use super::element::{resolve_element_center, resolve_element_object_id, RefMap};
+use super::element::{parse_ref, resolve_element_center, resolve_element_object_id, RefMap};
 use super::humanize;
 
 pub async fn click(
@@ -56,6 +56,33 @@ pub async fn click(
 
     match resolved {
         Ok((cx, cy, w, h, effective_session_id)) => {
+            // Occlusion guard for the CSS-selector path. `@ref` clicks are already
+            // occlusion-checked in resolve_element_center, but a plain selector
+            // resolves to coordinates without that check — so an overlay (modal
+            // backdrop, sticky banner, the getByText located node sitting under a
+            // full-screen layer) would make the coordinate click land on the
+            // overlay and still report success. If the click point doesn't hit the
+            // target, dispatch through the DOM instead (targets the element
+            // directly). Skipped for strict `coord` mode and non-left/multi-clicks.
+            if mode != "coord"
+                && button == "left"
+                && click_count == 1
+                && parse_ref(selector_or_ref).is_none()
+                && point_misses_element(client, &effective_session_id, selector_or_ref).await
+            {
+                eprintln!(
+                    "[click] target occluded at its click point; dispatching through \
+                     the DOM (set AGENT_BROWSER_CLICK_MODE=coord to disable)"
+                );
+                return dom_click(
+                    client,
+                    session_id,
+                    ref_map,
+                    selector_or_ref,
+                    iframe_sessions,
+                )
+                .await;
+            }
             // Land on a jittered point inside the element rather than its exact
             // centre (Fast/Human). Zero size or Off → exact centre.
             let (tx, ty) = humanize::landing_point(
@@ -92,6 +119,42 @@ pub async fn click(
     }
 }
 
+/// True if a coordinate click at the selector's centre would land on something
+/// OTHER than the element (an overlay on top), i.e. the element is occluded.
+/// `false` when not occluded, the element is missing, or the probe fails (so we
+/// never block a click on a flaky probe — the normal coordinate path runs).
+async fn point_misses_element(client: &CdpClient, session_id: &str, selector: &str) -> bool {
+    let js = format!(
+        r#"(() => {{
+            const el = document.querySelector({sel});
+            if (!el) return false;
+            const r = el.getBoundingClientRect();
+            if (r.width === 0 || r.height === 0) return false;
+            const hit = document.elementFromPoint(r.left + r.width / 2, r.top + r.height / 2);
+            if (!hit) return false;
+            // Not occluded if the hit is the element, a descendant, or an ancestor
+            // wrapper (clicking those still reaches the element's handlers).
+            return !(hit === el || el.contains(hit) || hit.contains(el));
+        }})()"#,
+        sel = serde_json::to_string(selector).unwrap_or_default()
+    );
+    match client
+        .send_command_typed::<_, EvaluateResult>(
+            "Runtime.evaluate",
+            &EvaluateParams {
+                expression: js,
+                return_by_value: Some(true),
+                await_promise: Some(false),
+            },
+            Some(session_id),
+        )
+        .await
+    {
+        Ok(r) => r.result.value.and_then(|v| v.as_bool()).unwrap_or(false),
+        Err(_) => false,
+    }
+}
+
 /// Best-effort scroll-into-view before a coordinate click. Uses Chrome's
 /// `scrollIntoViewIfNeeded` (only scrolls when not already fully visible),
 /// falling back to centered `scrollIntoView`. Resolution failures are ignored —
@@ -1080,6 +1143,20 @@ async fn wait_for_paint_settled(client: &CdpClient, session_id: &str) {
     .await;
 }
 
+/// Click at a raw viewport coordinate, bypassing element/selector resolution
+/// (issue #8.4 first-class coordinate click). Honors the humanize trajectory and
+/// press dwell exactly like a selector click — it shares `dispatch_click`.
+pub async fn click_at_point(
+    client: &CdpClient,
+    session_id: &str,
+    x: f64,
+    y: f64,
+    button: &str,
+    click_count: i32,
+) -> Result<(), String> {
+    dispatch_click(client, session_id, x, y, button, click_count).await
+}
+
 async fn dispatch_click(
     client: &CdpClient,
     session_id: &str,

cli/src/native/snapshot.rs

@@ -1305,6 +1305,39 @@ fn render_tree(
     }
 }
 
+/// True if a snapshot line names an interactive ARIA role. Compaction keeps
+/// these even without a `ref=`/`": "` marker, so a clickable control never gets
+/// dropped from `-c` output (the dogfood reports saw a button present in the full
+/// snapshot vanish from compact, leaving the agent clicking an empty ref).
+fn is_interactive_line(line: &str) -> bool {
+    const ROLES: &[&str] = &[
+        "button",
+        "link",
+        "textbox",
+        "checkbox",
+        "radio",
+        "combobox",
+        "listbox",
+        "menuitem",
+        "menuitemcheckbox",
+        "menuitemradio",
+        "option",
+        "switch",
+        "slider",
+        "spinbutton",
+        "searchbox",
+        "tab ",
+        "clickable",
+        "focusable",
+        "editable",
+    ];
+    let t = line.trim_start();
+    // Lines look like `- button "Label" [ref=e1]`; match the role token after the
+    // leading "- " marker.
+    let t = t.strip_prefix("- ").unwrap_or(t);
+    ROLES.iter().any(|r| t.starts_with(r))
+}
+
 fn compact_tree(tree: &str, interactive: bool) -> String {
     let lines: Vec<&str> = tree.lines().collect();
     if lines.is_empty() {
@@ -1314,7 +1347,7 @@ fn compact_tree(tree: &str, interactive: bool) -> String {
     let mut keep = vec![false; lines.len()];
 
     for (i, line) in lines.iter().enumerate() {
-        if line.contains("ref=") || line.contains(": ") {
+        if line.contains("ref=") || line.contains(": ") || is_interactive_line(line) {
             keep[i] = true;
             // Mark ancestors
             let my_indent = count_indent(line);

cli/src/native/stealth.rs

@@ -51,18 +51,19 @@ pub fn build_stealth_script(mode: StealthMode, locale: Option<&str>) -> String {
         vec![locale, base_lang]
     };
     let config_line = format!(
-        r#"const __abStealth = {{ locale: "{}", languages: {}, allowWebGLContextFallback: false, hideCanvas: {}, canvasSeed: {} }};"#,
+        r#"const __abStealth = {{ locale: "{}", languages: {}, allowWebGLContextFallback: false, hideCanvas: {}, canvasSeed: {}, disableIframeProxy: {} }};"#,
         locale,
         serde_json::to_string(&languages).unwrap_or_else(|_| r#"["en-US","en"]"#.to_string()),
         hide_canvas_enabled(),
         canvas_noise_seed(),
+        disable_iframe_proxy_enabled(),
     );
 
     // NB: this prefix MUST match the first line of stealth_scripts.js verbatim,
     // otherwise the fallback below prepends a SECOND `const __abStealth`
     // declaration and the whole script dies with a redeclaration SyntaxError.
     if let Some(rest) = STEALTH_SCRIPTS_RAW.strip_prefix(
-        r#"const __abStealth = { locale: "en-US", languages: ["en-US", "en"], allowWebGLContextFallback: false, hideCanvas: false, canvasSeed: 0 };"#,
+        r#"const __abStealth = { locale: "en-US", languages: ["en-US", "en"], allowWebGLContextFallback: false, hideCanvas: false, canvasSeed: 0, disableIframeProxy: false };"#,
     ) {
         format!("{}{}", config_line, rest)
     } else {
@@ -81,6 +82,18 @@ fn hide_canvas_enabled() -> bool {
         .unwrap_or(false)
 }
 
+/// Whether to DROP the srcdoc-iframe `contentWindow` Proxy patch (FullLaunch).
+/// That patch masks automation in srcdoc iframes, but the JS `Proxy` is itself a
+/// fingerprintable tell (CreepJS `hasIframeProxy` → ~20% stealth). Off by default
+/// (keep the patch); `AGENT_BROWSER_DISABLE_IFRAME_PROXY=1` drops it for a clean
+/// 0% CreepJS at the cost of that niche srcdoc-iframe masking.
+fn disable_iframe_proxy_enabled() -> bool {
+    std::env::var("AGENT_BROWSER_DISABLE_IFRAME_PROXY")
+        .ok()
+        .map(|v| v == "1" || v.eq_ignore_ascii_case("true"))
+        .unwrap_or(false)
+}
+
 /// A per-process seed so canvas/audio noise is STABLE within a session (a real
 /// device returns the same hash on repeated reads) but differs from the
 /// headless-stable default. 0 is avoided so the JS can treat it as "unset".

cli/src/native/stealth_scripts.js

@@ -1,4 +1,4 @@
-const __abStealth = { locale: "en-US", languages: ["en-US", "en"], allowWebGLContextFallback: false, hideCanvas: false, canvasSeed: 0 };
+const __abStealth = { locale: "en-US", languages: ["en-US", "en"], allowWebGLContextFallback: false, hideCanvas: false, canvasSeed: 0, disableIframeProxy: false };
 // Redefine a navigator property on its PROTOTYPE (Navigator / WorkerNavigator),
 // the way real Chrome exposes these — as prototype getters, NOT instance own
 // properties. Adding an own property to the `navigator` instance is itself a
@@ -289,6 +289,10 @@ const __abRedefineNavProto = (name, getterImpl) => {
 })();
 (function(){
   if (typeof document === 'undefined' || typeof document.createElement !== 'function') return;
+  // The srcdoc-iframe contentWindow Proxy below is itself a fingerprintable tell
+  // (CreepJS `hasIframeProxy`). Honor the opt-out so callers can trade the niche
+  // srcdoc masking for a clean 0% CreepJS fingerprint.
+  if (typeof __abStealth !== 'undefined' && __abStealth.disableIframeProxy) return;
   const nativeCreateElement = document.createElement.bind(document);
   const nativeSrcdocDescriptor =
     typeof HTMLIFrameElement !== 'undefined'
@@ -304,12 +308,39 @@ const __abRedefineNavProto = (name, getterImpl) => {
     try {
       if (iframe.contentWindow) return;
     } catch {}
+    // Native window methods are bound to the real Window via an internal slot;
+    // calling them with the Proxy as `this` throws "Illegal invocation". Wrap
+    // each function in an apply/construct trap that swaps the Proxy receiver for
+    // the real window, while passing `.prototype`/`.name`/`.toString`/identity
+    // straight through (a plain `.bind()` would drop `.prototype` and break
+    // `instanceof`). Cached so repeated reads return the same function.
+    const fnProxyCache = new WeakMap();
+    const bindToRealWindow = (fn) => {
+      let wrapped = fnProxyCache.get(fn);
+      if (wrapped) return wrapped;
+      try {
+        wrapped = new Proxy(fn, {
+          apply(target, thisArg, args) {
+            return Reflect.apply(target, thisArg === proxy ? window : thisArg, args);
+          },
+          construct(target, args, newTarget) {
+            return Reflect.construct(target, args, newTarget);
+          },
+        });
+      } catch {
+        wrapped = fn;
+      }
+      fnProxyCache.set(fn, wrapped);
+      return wrapped;
+    };
     const proxy = new Proxy(window, {
       get(target, key) {
         if (key === 'self') return proxy;
         if (key === 'frameElement') return iframe;
         if (key === '0') return undefined;
-        return Reflect.get(target, key, target);
+        const value = Reflect.get(target, key, target);
+        if (typeof value === 'function') return bindToRealWindow(value);
+        return value;
       },
     });
     iframeProxyMap.set(iframe, proxy);

cli/src/output.rs

@@ -130,6 +130,20 @@ fn format_stream_status_text(action: Option<&str>, data: &serde_json::Value) ->
     }
 }
 
+/// Shorten an over-long string by keeping its head and tail and eliding the
+/// middle, with a char count. Used so multi-KB URLs (JWT/OTP login links) don't
+/// flood `tab list`.
+fn truncate_middle(s: &str, max: usize) -> String {
+    let n = s.chars().count();
+    if n <= max {
+        return s.to_string();
+    }
+    let keep = max.saturating_sub(1) / 2;
+    let head: String = s.chars().take(keep).collect();
+    let tail: String = s.chars().skip(n - keep).collect();
+    format!("{head}…{tail} [{n} chars]")
+}
+
 pub fn print_response_with_opts(resp: &Response, action: Option<&str>, opts: &OutputOptions) {
     if opts.json {
         if opts.content_boundaries {
@@ -338,12 +352,55 @@ pub fn print_response_with_opts(resp: &Response, action: Option<&str>, opts: &Ou
             println!("{}", enabled);
             return;
         }
+        // Stealth self-check (`stealth status` / `doctor`)
+        if let Some(s) = data.get("stealthStatus") {
+            let ok = s.get("ok").and_then(|v| v.as_bool()).unwrap_or(false);
+            let mode = s.get("mode").and_then(|v| v.as_str()).unwrap_or("?");
+            println!(
+                "{} stealth: {}  ·  mode: {}",
+                if ok {
+                    color::success_indicator().to_string()
+                } else {
+                    color::cyan("•")
+                },
+                if ok {
+                    "all checks pass"
+                } else {
+                    "some checks need attention"
+                },
+                mode
+            );
+            if let Some(checks) = s.get("checks").and_then(|v| v.as_array()) {
+                for c in checks {
+                    let pass = c.get("pass").and_then(|v| v.as_bool()).unwrap_or(false);
+                    let name = c.get("name").and_then(|v| v.as_str()).unwrap_or("");
+                    println!("  {} {}", if pass { "✓" } else { "✗" }, name);
+                }
+            }
+            if let Some(ovs) = s.get("overrides").and_then(|v| v.as_array()) {
+                println!("  applied overrides:");
+                for o in ovs.iter().filter_map(|v| v.as_str()) {
+                    println!("    {}", color::dim(&format!("· {o}")));
+                }
+            }
+            return;
+        }
         if let Some(checked) = data.get("checked").and_then(|v| v.as_bool()) {
             println!("{}", checked);
             return;
         }
         // Eval result
         if let Some(result) = data.get("result") {
+            // Surface which page the eval actually ran on — to stderr, so it
+            // never corrupts the parsed value on stdout. Lets an agent catch tab
+            // drift (commands landing on the wrong tab) before trusting a result,
+            // e.g. a logged-in `fetch` that hit the wrong origin. (In
+            // content-boundaries mode the origin is already in the banner.)
+            if !opts.content_boundaries {
+                if let Some(o) = origin.filter(|o| !o.is_empty()) {
+                    eprintln!("eval @ {o}");
+                }
+            }
             let formatted = serde_json::to_string_pretty(result).unwrap_or_default();
             print_with_boundaries(&formatted, origin, opts);
             return;
@@ -421,7 +478,15 @@ pub fn print_response_with_opts(resp: &Response, action: Option<&str>, opts: &Ou
                     .get("title")
                     .and_then(|v| v.as_str())
                     .unwrap_or("Untitled");
+                // A page can set its title to a multi-KB string (e.g. equal to a
+                // giant JWT/OTP URL); truncate it like the URL so the row stays
+                // readable.
+                let title = truncate_middle(title, 120);
+                let title = title.as_str();
                 let url = tab.get("url").and_then(|v| v.as_str()).unwrap_or("");
+                // Truncate very long URLs (e.g. multi-KB JWT/OTP login links) so
+                // the list stays readable instead of flooding the terminal.
+                let url = truncate_middle(url, 120);
                 let active = tab.get("active").and_then(|v| v.as_bool()).unwrap_or(false);
                 let marker = if active {
                     color::cyan("→")
@@ -530,6 +595,15 @@ pub fn print_response_with_opts(resp: &Response, action: Option<&str>, opts: &Ou
         }
         // Network requests
         if let Some(requests) = data.get("requests").and_then(|v| v.as_array()) {
+            // Stamp the page these requests were read from, mirroring `eval @ url`,
+            // so a read against a drifted/wrong tab is obvious (issue #8.1).
+            if let Some(o) = data
+                .get("origin")
+                .and_then(|v| v.as_str())
+                .filter(|o| !o.is_empty())
+            {
+                eprintln!("network @ {o}");
+            }
             if requests.is_empty() {
                 println!("No requests captured");
             } else {
@@ -733,8 +807,22 @@ pub fn print_response_with_opts(resp: &Response, action: Option<&str>, opts: &Ou
                         color::success_indicator(),
                         color::green(path)
                     );
+                    // Stamp which page was captured (mirrors `eval @ url`) so a
+                    // screenshot of the wrong/drifted tab is obvious (issue #8.1).
+                    if let Some(o) = data
+                        .get("origin")
+                        .and_then(|v| v.as_str())
+                        .filter(|o| !o.is_empty())
+                    {
+                        eprintln!("screenshot @ {o}");
+                    }
                     if let Some(annotations) = data.get("annotations").and_then(|v| v.as_array()) {
-                        for ann in annotations {
+                        // Cap the printed legend on dense pages (it can be
+                        // hundreds of lines and flood the terminal). The image
+                        // still shows every marker; --json returns the full list.
+                        const LEGEND_CAP: usize = 40;
+                        let total = annotations.len();
+                        for ann in annotations.iter().take(LEGEND_CAP) {
                             let num = ann.get("number").and_then(|n| n.as_u64()).unwrap_or(0);
                             let ref_id = ann.get("ref").and_then(|r| r.as_str()).unwrap_or("");
                             let role = ann.get("role").and_then(|r| r.as_str()).unwrap_or("");
@@ -756,6 +844,15 @@ pub fn print_response_with_opts(resp: &Response, action: Option<&str>, opts: &Ou
                                 );
                             }
                         }
+                        if total > LEGEND_CAP {
+                            println!(
+                                "   {}",
+                                color::dim(&format!(
+                                    "… and {} more markers (shown in the image; --json for the full list)",
+                                    total - LEGEND_CAP
+                                ))
+                            );
+                        }
                     }
                 }
                 "pdf" => println!(

extensions/ab-connect/background.js

@@ -199,10 +199,31 @@ async function handleForwardCdpCommand(msg) {
   }
 
   // Everything else → chrome.debugger on the resolved tab.
-  const tabId =
-    (sessionId ? tabForSession(sessionId) : null) ??
-    (typeof params?.targetId === 'string' ? tabForTarget(params.targetId) : null) ??
-    anyConnectedTab()
+  //
+  // A daemon-supplied sessionId/targetId MUST resolve to a real attached tab.
+  // The old code fell through to anyConnectedTab() when it didn't, which
+  // silently ran the command (eval/screenshot/network) on an arbitrary tab —
+  // exactly the "ran on the wrong page with no warning" failure in issue #8.1,
+  // and the blank-screenshot symptom after a service-worker restart (#8.2).
+  // Fail loudly instead so the agent sees an actionable error, not bad data.
+  let tabId
+  if (sessionId) {
+    tabId = tabForSession(sessionId)
+    if (!tabId) {
+      throw new Error(
+        `stale sessionId ${sessionId} for ${method}: its tab is gone (closed, ` +
+          `navigated across processes, or lost after an extension restart). ` +
+          `Re-attach by re-opening your target URL before retrying.`,
+      )
+    }
+  } else if (typeof params?.targetId === 'string') {
+    tabId = tabForTarget(params.targetId)
+    if (!tabId) throw new Error(`no attached tab for targetId ${params.targetId} (${method})`)
+  } else {
+    // No session/target specified — a browser-level command that legitimately
+    // applies to any attached tab.
+    tabId = anyConnectedTab()
+  }
   if (!tabId) throw new Error(`no attached tab for ${method}`)
   const dbg = { tabId }
 

extensions/ab-connect/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "agent-browser-stealth",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "Let agent-browser drive your logged-in Chrome \u2014 install once, no token, no per-use confirmation.",
   "key": "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA6vQIyscGIPYPZdSpPwPL0+0gxUROyRgCpmvCSDoc8XUm4qm97VbKnD9Ijc1lV22lNWZtE78gaRjt6BeSfuMgnBymnhLKjN1gU6AI5QUU0mrJyeHdWKvrKQR5FmsM2A7Xr1ykE2SiiS8zNUS3Y/6O5l+Nva7wrVy6E4a2dkBVQkOsu+DV+nEZvhIyuDY5D5SPXqNwUTWTaglwj5mjvHz36xSwCWlPmrtJ+ED0AUyrb2z4GIOmvk4kqtBVrh/UD058klLo4CkYOnIybB5aV6WYuwarfPY4bF/dLggPem+ewLNTUNBuwrxj/A4nUv0LJTuRO8rR7f8WR9qnRCY0Ic5saQIDAQAB",
   "icons": {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-browser-stealth",
-  "version": "0.27.0-fork.42",
+  "version": "0.27.0-fork.51",
   "description": "Browser automation CLI for AI agents — stealth fork with anti-detection",
   "type": "module",
   "packageManager": "pnpm@11.1.3",

skill-data/core/SKILL.md

@@ -182,14 +182,17 @@ Snapshot output looks like:
 Page: Example - Log in
 URL: https://example.com/login
 
-@e1 [heading] "Log in"
-@e2 [form]
-  @e3 [input type="email"] placeholder="Email"
-  @e4 [input type="password"] placeholder="Password"
-  @e5 [button type="submit"] "Continue"
-  @e6 [link] "Forgot password?"
+- heading "Log in" [level=1, ref=e1]
+- textbox "Email" [ref=e2]
+- textbox "Password" [ref=e3]
+- button "Continue" [ref=e4]
+- link "Forgot password?" [ref=e5]
 ```
 
+Each line is `- <role> "<accessible name>" [<attrs>, ref=eN]`, indented by nesting
+depth. You pass the ref to commands as `@eN` (e.g. `click @e4`). Refs are
+assigned fresh on every snapshot.
+
 For unstructured reading (no refs needed):
 
 ```bash
@@ -216,8 +219,16 @@ agent-browser press Enter                 # press a key at current focus
 agent-browser press Control+a             # key combination
 agent-browser check @e3                   # check checkbox
 agent-browser uncheck @e3                 # uncheck
-agent-browser select @e4 "option-value"   # select dropdown option
+agent-browser select @e4 "option-value"   # native <select> only
 agent-browser select @e4 "a" "b"          # select multiple
+agent-browser pick @e4 --option "Europe"  # ANY combobox (react-select / ARIA /
+                                          # native): opens it, waits for the menu
+                                          # (incl. portal-rendered), matches by
+                                          # visible text, fires the right events,
+                                          # and ERRORS if the option never shows
+                                          # (no silent no-op). Use this for custom
+                                          # dropdowns where `select` returns ✓ but
+                                          # changes nothing.
 agent-browser upload @e5 file1.pdf        # upload file(s)
 agent-browser scroll down 500             # scroll page (up/down/left/right)
 agent-browser scrollintoview @e1          # scroll element into view
@@ -386,9 +397,23 @@ Array.from(rows).map(r => ({
 EOF
 ```
 
-Prefer `eval --stdin` (heredoc) or `eval -b <base64>` for any JS with
-quotes or special characters. Inline `agent-browser eval "..."` works
-only for simple expressions.
+Prefer `eval --stdin` (heredoc), `eval --file <path>`, or `eval -b <base64>`
+for any JS with quotes, **non-ASCII identifiers/strings (e.g. Chinese)**, or
+large scripts — inline `agent-browser eval "..."` is shell-mangled and works
+only for simple ASCII expressions.
+
+**`eval` runs in the page's MAIN world and state persists across calls**, so a
+top-level `const x`/`let x`/`var x` in one call collides with the next
+(`SyntaxError: Identifier 'x' has already been declared`). Either use unique
+names, assign to `window.x`, or wrap the body in an IIFE
+(`(() => { const x = …; return x; })()`).
+
+**For array/object results, use `eval --json`** — the plain renderer
+pretty-prints across multiple lines, which `tail`/`head`/pipes mangle; `--json`
+emits one parseable line. Also note **`type`/`fill` insert text without firing
+`keydown`/`keyup`** (CDP insertText) — the value lands, but a page that gates on
+key events (some search-as-you-type widgets) won't react; use `keyboard type` (or
+`press` per key) when real keystrokes are required.
 
 ### Screenshot
 
@@ -433,6 +458,19 @@ agent-browser --session b fill @e1 "bob@test.com"
 `AGENT_BROWSER_SESSION=myapp` sets the default session for the current
 shell.
 
+**Concurrent agents MUST each use a distinct `--session <name>`.** Within one
+session, commands are pinned to the tab you opened (by target_id, so a foreign
+tab can't drift your `eval`/`screenshot`). Two agents sharing the *same* session
+(e.g. both on the bare default) share one daemon and one active tab and will
+clobber each other.
+
+True multi-agent isolation requires the **extension-connect path**: each
+`--session` gets its own colored Chrome tab group, so sessions never touch each
+other's tabs. **Raw `--cdp <port>` does NOT isolate** — every session attaches to
+the same browser's existing targets, so a second session's first `open` can
+navigate a sibling's tab. For concurrent agents on one real Chrome, use the
+extension (each with a distinct `--session`), not raw `--cdp`.
+
 ### Mock network requests
 
 ```bash
@@ -502,6 +540,10 @@ agent-browser doctor                     # full diagnosis (env, Chrome, daemons,
 agent-browser doctor --offline --quick   # fast, local-only
 agent-browser doctor --fix               # also run destructive repairs (reinstall Chrome, purge old state, ...)
 agent-browser doctor --json              # structured output for programmatic consumption
+agent-browser stealth status             # stealth self-check: mode + live probes
+agent-browser stealth status --json      #   (webdriver/chrome/plugins/UA) + applied
+                                         #   overrides. Gate a sensitive flow on this
+                                         #   instead of driving an external detector.
 ```
 
 `doctor` auto-cleans stale socket/pid/version sidecar files on every run.