@trusty-squire/mcp 0.9.17-rc.3 → 0.9.17

package/dist/bot/browser.js

@@ -24,10 +24,10 @@
 import { chromium as baseChromium } from "playwright";
 import { createRequire } from "node:module";
 import { Socket, createServer } from "node:net";
-import { existsSync } from "node:fs";
-import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, rmSync, statSync } from "node:fs";
+import { execFileSync, spawn } from "node:child_process";
 import { detectAsn } from "./asn.js";
-import { CHROME_PROFILE_DIR, launchWithProfileGate, ProfileBusyError, reapLeakedProfileHolder, waitForProfileFree } from "./profile.js";
+import { CHROME_PROFILE_DIR, clearStaleSingletonLock, launchWithProfileGate, ProfileBusyError, reapLeakedProfileHolder, waitForProfileFree, } from "./profile.js";
 import { startXvfb, xvfbAvailable } from "./xvfb.js";
 // Lazy registration: installing the plugin mutates the chromium singleton
 // from playwright-extra so we only do it once per process. We require()
@@ -109,6 +109,69 @@ function getChromium() {
     }
     return cachedChromium;
 }
+const HCAPTCHA_UUID_RE = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+export function extractHcaptchaSitekeyFromHtml(html) {
+    if (!/hcaptcha\.com|h-captcha|hcaptcha/i.test(html))
+        return null;
+    const normalized = html
+        .replace(/"/g, '"')
+        .replace(/"/g, '"')
+        .replace(/&/g, "&");
+    for (const src of normalized.matchAll(/<iframe[^>]+src=["']([^"']*hcaptcha[^"']*)["']/gi)) {
+        const raw = src[1];
+        if (raw === undefined)
+            continue;
+        try {
+            const url = new URL(raw, "https://example.invalid");
+            const direct = url.searchParams.get("sitekey");
+            if (direct !== null && direct.length > 10)
+                return direct;
+            const hash = url.hash.startsWith("#") ? url.hash.slice(1) : url.hash;
+            const fromHash = new URLSearchParams(hash).get("sitekey");
+            if (fromHash !== null && fromHash.length > 10)
+                return fromHash;
+        }
+        catch {
+            const match = raw.match(new RegExp(`[?#&]sitekey=(${HCAPTCHA_UUID_RE})`, "i"));
+            if (match?.[1] !== undefined)
+                return match[1];
+        }
+    }
+    const patterns = [
+        // Standard hCaptcha/SDK naming.
+        new RegExp(`(?:sitekey|site_key|site-key|hcaptcha_key|captchaApiKey|data-(?:hcaptcha-)?sitekey)["'\\s]*[:=]\\s*["'](${HCAPTCHA_UUID_RE})["']`, "i"),
+        // Stripe and similar app config JSON often names keys
+        // `express_hcaptcha_site_key` or `hcaptcha_login_main_site_key`.
+        new RegExp(`(?:hcaptcha[^"'<>]{0,80}site[_-]?key|express_hcaptcha_site_key)["'\\s]*[:=]\\s*["'](${HCAPTCHA_UUID_RE})["']`, "i"),
+    ];
+    for (const pattern of patterns) {
+        const match = normalized.match(pattern);
+        if (match?.[1] !== undefined)
+            return match[1];
+    }
+    return null;
+}
+export function extractHcaptchaResponseKeyFromToken(token) {
+    const parts = token.split(".");
+    if (parts.length < 2)
+        return null;
+    const payload = parts[1];
+    if (payload === undefined || payload.length === 0)
+        return null;
+    try {
+        const json = Buffer.from(payload.replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf8");
+        const parsed = JSON.parse(json);
+        for (const key of ["ekey", "eKey", "respKey", "responseKey", "key", "kr"]) {
+            const value = parsed[key];
+            if (typeof value === "string" && value.trim().length > 0)
+                return value;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
 // Map a cookie jar to the OAuth providers that have a LIVE logged-in session.
 // The auth cookies that mean "signed in": GitHub → `user_session`; Google →
 // any of the *SID session cookies (NID / CONSENT / 1P_JAR are set even when
@@ -141,6 +204,17 @@ function isCaptchaVariant(v) {
         v === "hcaptcha" ||
         v === "unknown");
 }
+function pngDimensions(buf) {
+    if (buf.length < 24)
+        return null;
+    if (buf[0] !== 0x89 ||
+        buf[1] !== 0x50 ||
+        buf[2] !== 0x4e ||
+        buf[3] !== 0x47) {
+        return null;
+    }
+    return { width: buf.readUInt32BE(16), height: buf.readUInt32BE(20) };
+}
 // Real-Chromium-family browser channels we'll prefer over the bundled
 // Chromium binary when available. Chromium ships without Widevine,
 // without proprietary codecs, with an empty navigator.plugins array,
@@ -309,6 +383,123 @@ async function waitForDevtools(port, deadlineMs) {
     }
     throw new Error(`Chrome DevTools endpoint never came up on ${base} (${lastErr})`);
 }
+async function withChromeStartupLock(fn) {
+    const lockDir = "/tmp/trusty-squire-chrome-start.lock";
+    const deadline = Date.now() + 60_000;
+    for (;;) {
+        try {
+            mkdirSync(lockDir);
+            break;
+        }
+        catch (err) {
+            try {
+                const ageMs = Date.now() - statSync(lockDir).mtimeMs;
+                if (ageMs > 120_000) {
+                    rmSync(lockDir, { recursive: true, force: true });
+                    continue;
+                }
+            }
+            catch {
+                rmSync(lockDir, { recursive: true, force: true });
+                continue;
+            }
+            if (Date.now() >= deadline) {
+                throw new Error(`Timed out waiting for Chrome startup lock at ${lockDir}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        rmSync(lockDir, { recursive: true, force: true });
+    }
+}
+const selfManagedChromePids = new Set();
+let selfManagedCleanupInstalled = false;
+let orphanVerifyReapRan = false;
+function killPid(pid, signal) {
+    try {
+        process.kill(pid, signal);
+    }
+    catch {
+        // already gone / not ours
+    }
+}
+function cleanupSelfManagedChromes() {
+    for (const pid of selfManagedChromePids)
+        killPid(pid, "SIGKILL");
+    selfManagedChromePids.clear();
+}
+function installSelfManagedChromeCleanup() {
+    if (selfManagedCleanupInstalled)
+        return;
+    selfManagedCleanupInstalled = true;
+    process.once("exit", cleanupSelfManagedChromes);
+    const exitForSignal = (code) => {
+        cleanupSelfManagedChromes();
+        process.exit(128 + code);
+    };
+    process.once("SIGINT", () => exitForSignal(2));
+    process.once("SIGTERM", () => exitForSignal(15));
+    process.once("SIGHUP", () => exitForSignal(1));
+}
+function registerSelfManagedChrome(child) {
+    installSelfManagedChromeCleanup();
+    if (child.pid !== undefined)
+        selfManagedChromePids.add(child.pid);
+    child.once("exit", () => {
+        if (child.pid !== undefined)
+            selfManagedChromePids.delete(child.pid);
+    });
+}
+// Stale verifier browsers are the expensive leak mode: if the MCP process dies
+// mid-verify, self-launched Chrome survives as PPID=1 with a
+// ~/.trusty-squire/profiles/verify-* user-data-dir. It keeps the profile lock,
+// burns memory, and may leave defunct helper children. A live verifier should
+// never be parented to init, so these are safe to reap at the next browser
+// startup. Best-effort and Linux-only; failure must not block signups.
+function reapOrphanedVerifyBrowsersOnce() {
+    if (orphanVerifyReapRan)
+        return;
+    orphanVerifyReapRan = true;
+    if (process.platform !== "linux")
+        return;
+    let rows = "";
+    try {
+        rows = execFileSync("ps", ["-eo", "pid=,ppid=,args="], {
+            stdio: ["ignore", "pipe", "ignore"],
+        }).toString("utf8");
+    }
+    catch {
+        return;
+    }
+    const pids = [];
+    for (const line of rows.split("\n")) {
+        const match = line.trim().match(/^(\d+)\s+(\d+)\s+(.+)$/);
+        if (match === null)
+            continue;
+        const pid = Number(match[1]);
+        const ppid = Number(match[2]);
+        const args = match[3] ?? "";
+        if (Number.isFinite(pid) &&
+            ppid === 1 &&
+            /(?:chrome|chromium)/i.test(args) &&
+            /--user-data-dir=.*\.trusty-squire\/profiles\/verify-[^/\s]+/.test(args)) {
+            pids.push(pid);
+        }
+    }
+    if (pids.length === 0)
+        return;
+    console.error(`[universal-bot] reaping ${pids.length} orphaned verify Chrome process(es)`);
+    for (const pid of pids)
+        killPid(pid, "SIGTERM");
+    setTimeout(() => {
+        for (const pid of pids)
+            killPid(pid, "SIGKILL");
+    }, 2_000).unref();
+}
 // Classify an anti-bot interstitial page from its (title + body) text.
 // `onInterstitial` matches the static Cloudflare/Turnstile challenge copy.
 // `verificationPassed` is the signal the challenge SUCCEEDED — but
@@ -462,38 +653,82 @@ export class BrowserController {
     //                 an emulated viewport on the connected context)
     //   • locale/geo/permissions → applied post-connect by start()
     async launchSelfManagedContext(params) {
-        const port = await findFreePort();
-        const argv = [
-            `--remote-debugging-port=${port}`,
-            "--remote-debugging-address=127.0.0.1",
-            `--user-data-dir=${this.profileDir}`,
-            "--no-first-run",
-            "--no-default-browser-check",
-            "--password-store=basic",
-            "--window-position=0,0",
-            `--window-size=${params.window.width},${params.window.height}`,
-            "--lang=en-US",
-            ...params.args,
-            ...(params.proxy !== null ? [`--proxy-server=${params.proxy.server}`] : []),
-            ...(params.headless ? ["--headless=new"] : []),
-            "about:blank",
-        ];
-        const child = spawn(params.binary, argv, { env: params.env, stdio: "ignore" });
-        this.childChrome = child;
-        let endpoint;
-        try {
-            endpoint = await waitForDevtools(port, 30_000);
-        }
-        catch (err) {
+        // Remote-CDP attach: BOT_CDP_ENDPOINT points at a Chrome already running on
+        // another host (e.g. a real-GPU Mac), reachable over Tailscale. We do NOT
+        // spawn or own the binary — the remote host launched it with its own
+        // profile, real GPU, and (residential) egress. Just attach over CDP. This
+        // is the real-GPU path: software-WebGL output (llvmpipe) is what
+        // hCaptcha-Enterprise-class anti-bot scores, and only real hardware fixes
+        // the rendered-pixel fingerprint that JS spoofing can't.
+        const remoteEndpoint = (process.env.BOT_CDP_ENDPOINT ?? "").trim();
+        if (remoteEndpoint.length > 0) {
+            const launcher = getChromium();
+            const browser = await launcher.connectOverCDP(remoteEndpoint);
+            this.cdpBrowser = browser;
+            this.launchedMode = "remote";
+            const ctx = browser.contexts()[0];
+            if (ctx === undefined) {
+                throw new Error(`remote Chrome (BOT_CDP_ENDPOINT=${remoteEndpoint}) exposed no default browser context`);
+            }
+            return ctx;
+        }
+        const endpoint = await withChromeStartupLock(async () => {
+            const port = await findFreePort();
+            clearStaleSingletonLock(this.profileDir);
+            const argv = [
+                `--remote-debugging-port=${port}`,
+                "--remote-debugging-address=127.0.0.1",
+                `--user-data-dir=${this.profileDir}`,
+                "--no-first-run",
+                "--no-default-browser-check",
+                "--password-store=basic",
+                "--window-position=0,0",
+                `--window-size=${params.window.width},${params.window.height}`,
+                "--lang=en-US",
+                ...params.args,
+                ...(params.proxy !== null ? [`--proxy-server=${params.proxy.server}`] : []),
+                ...(params.headless ? ["--headless=new"] : []),
+                "about:blank",
+            ];
+            const child = spawn(params.binary, argv, { env: params.env, stdio: ["ignore", "ignore", "pipe"] });
+            this.childChrome = child;
+            registerSelfManagedChrome(child);
+            let chromeStderr = "";
+            let chromeExit = "";
+            child.stderr?.on("data", (chunk) => {
+                chromeStderr = (chromeStderr + chunk.toString("utf8")).slice(-4_000);
+            });
+            child.on("exit", (code, signal) => {
+                chromeExit = ` exit=${code ?? "null"} signal=${signal ?? "none"}`;
+            });
             try {
-                child.kill("SIGKILL");
+                return await waitForDevtools(port, 30_000);
             }
-            catch {
-                /* already gone */
+            catch (err) {
+                const alive = child.pid !== undefined
+                    ? (() => {
+                        try {
+                            process.kill(child.pid, 0);
+                            return true;
+                        }
+                        catch {
+                            return false;
+                        }
+                    })()
+                    : false;
+                try {
+                    child.kill("SIGKILL");
+                }
+                catch {
+                    /* already gone */
+                }
+                reapLeakedProfileHolder(this.profileDir);
+                this.childChrome = null;
+                const detail = chromeStderr.trim();
+                throw new Error(`${err instanceof Error ? err.message : String(err)}; Chrome pid=${child.pid ?? "unknown"} alive=${alive ? 1 : 0}` +
+                    `${chromeExit}${detail.length > 0 ? `; Chrome stderr: ${detail}` : ""}`);
             }
-            this.childChrome = null;
-            throw err;
-        }
+        });
         // Use the patchright launcher's connectOverCDP — it's the exact path the
         // falsification experiment validated (its connect avoids Runtime.enable,
         // which a plain attach would emit). The anti-detection that matters here
@@ -562,6 +797,7 @@ export class BrowserController {
         console.error("[universal-bot] resource blocking ON (image/media/font + analytics aborted; captcha/CSS/JS allowed)");
     }
     async start() {
+        reapOrphanedVerifyBrowsersOnce();
         const channel = await detectChromiumChannel();
         this.launchedChannel = channel;
         const proxy = await this.resolveProxy();
@@ -570,12 +806,27 @@ export class BrowserController {
         // module's existing logging convention).
         console.error(`[universal-bot] launching browser channel=${channel ?? "bundled-chromium"} ` +
             `proxy=${proxy?.server ?? "direct"}`);
+        // Remote-CDP mode (BOT_CDP_ENDPOINT): the browser runs on a REMOTE host
+        // (e.g. a Mac with a real GPU + residential egress) and we attach over CDP
+        // across Tailscale. The remote machine IS a real device, so we spoof
+        // NOTHING — no WebGL/device fingerprint patch (a fake-Intel string over a
+        // real Apple-GPU output would be its own mismatch tell), no local Xvfb, no
+        // egress-geo override (the remote host's real timezone + residential IP are
+        // authentic). software-WebGL output is exactly what the toughest anti-bot
+        // (hCaptcha Enterprise) scores; only real hardware fixes the pixel
+        // fingerprint, which is the whole point of this path.
+        const remoteMode = (process.env.BOT_CDP_ENDPOINT ?? "").trim().length > 0;
+        if (remoteMode) {
+            console.error(`[universal-bot] REMOTE-CDP mode — attaching to ${(process.env.BOT_CDP_ENDPOINT ?? "").trim()} ` +
+                `(real-host GPU + egress; local fingerprint spoof + Xvfb DISABLED)`);
+        }
         // T3.1: probe where this run's traffic actually exits so the
         // browser's declared timezone matches its egress IP (a US-timezone
         // browser on a foreign proxy IP is itself an anti-bot signal).
         // Done before the real launch: launchPersistentContext bakes the
-        // timezone in at creation, with no way to set it afterward.
-        const geo = await this.probeEgressGeo(channel, proxy);
+        // timezone in at creation, with no way to set it afterward. Skipped in
+        // remote mode — the remote host's own clock/IP are the authentic truth.
+        const geo = remoteMode ? null : await this.probeEgressGeo(channel, proxy);
         if (geo !== null) {
             console.error(`[universal-bot] egress geo: timezone=${geo.timezoneId}` +
                 (geo.geolocation !== undefined
@@ -666,11 +917,22 @@ export class BrowserController {
             // have released within the 120s wait — so by here, reaping the LOCAL
             // holder (SIGKILL + clear singletons; no-ops on a remote-host holder)
             // and retrying once is safe and recovers the run instead of failing it.
-            const reaped = reapLeakedProfileHolder(this.profileDir);
+            //
+            // That assumption is false for verifier/discovery concurrency: a live
+            // holder can be another legitimate slot still closing the same robot
+            // profile. In concurrent mode, never SIGKILL the holder; surface
+            // ProfileBusyError so the orchestrator can retry later without corrupting
+            // another run.
+            const concurrency = Number.parseInt(process.env.HOUSEKEEPER_CONCURRENCY ?? "1", 10) || 1;
+            const allowLiveReap = concurrency <= 1;
+            const reaped = allowLiveReap ? reapLeakedProfileHolder(this.profileDir) : false;
             if (reaped) {
                 console.error("[universal-bot] reaped a leaked Chrome holding the profile (orphan from an externally-killed run) — retrying");
                 free = await waitForProfileFree(this.profileDir, { deadlineMs: 10_000 });
             }
+            else if (!allowLiveReap) {
+                console.error("[universal-bot] profile still held after wait; not reaping because HOUSEKEEPER_CONCURRENCY>1");
+            }
             if (!free) {
                 throw new ProfileBusyError("bot Chrome profile is held by another run (a login or signup); retry shortly");
             }
@@ -777,6 +1039,15 @@ export class BrowserController {
         this.launchedContext = true;
         // Speed: optionally abort heavy/irrelevant requests before any navigation.
         await this.installResourceBlocking();
+        // Dev-runtime guard: when the bot is run through `tsx`, esbuild may inject
+        // calls to its `__name(fn, "name")` helper into functions passed to
+        // page.evaluate/addInitScript. Those functions execute in the browser page,
+        // where Node's helper does not exist, causing an immediate
+        // `ReferenceError: __name is not defined` before the real signup even
+        // starts. Define the same no-op helper in every document. Built `dist`
+        // should not emit these calls, but the helper is harmless there too.
+        const evaluateNameShimScript = 'Object.defineProperty(globalThis, "__name", { value: (fn) => fn, configurable: true });';
+        await context.addInitScript({ content: evaluateNameShimScript });
         // Patch navigator.webdriver — BASELINE ONLY. Measured against the
         // rebrowser bot-detector, this manual `defineProperty` is
         // COUNTERPRODUCTIVE under patchright: it re-adds `webdriver` as an own
@@ -803,103 +1074,168 @@ export class BrowserController {
         //     at 1.0. Idempotent via a marker so the per-nav re-apply is cheap, and
         //     getParameter.toString() is masked to the original native source so
         //     the patch itself isn't a tell. Only strings change, not rendering.
-        const installWebglSpoof = () => {
-            const VENDOR_WEBGL = 0x9245; // UNMASKED_VENDOR_WEBGL
-            const RENDERER_WEBGL = 0x9246; // UNMASKED_RENDERER_WEBGL
-            const spoof = (proto) => {
-                // The marker lives on the prototype so re-application is a no-op; the
-                // cast is the one typed-alternative-exhausted spot (adding an ad-hoc
-                // brand to a DOM prototype).
-                const marked = proto;
-                if (marked.__tsWebglPatched === true)
-                    return;
-                const orig = proto.getParameter;
-                const native = orig.toString();
-                proto.getParameter = function (p) {
-                    if (p === VENDOR_WEBGL)
-                        return "Google Inc. (Intel)";
-                    if (p === RENDERER_WEBGL) {
-                        return "ANGLE (Intel, Mesa Intel(R) UHD Graphics 620 (KBL GT2), OpenGL 4.6)";
-                    }
-                    return orig.call(this, p);
-                };
-                Object.defineProperty(proto.getParameter, "toString", {
-                    value: () => native,
-                    configurable: true,
-                    writable: true,
-                });
-                marked.__tsWebglPatched = true;
-            };
-            if (typeof WebGLRenderingContext !== "undefined") {
-                spoof(WebGLRenderingContext.prototype);
-            }
-            if (typeof WebGL2RenderingContext !== "undefined") {
-                spoof(WebGL2RenderingContext.prototype);
-            }
-            // Device-tell normalization. The headless harvester box reports 20
-            // logical cores (navigator.hardwareConcurrency) — a consumer residential
-            // device is 4-16. A 20-core Linux machine behind a "residential" IP is
-            // an internal inconsistency Cloudflare Turnstile scores against
-            // (MEASURED 2026-06-11: exa/cartesia Turnstile won't issue a token on a
-            // clean-fingerprint click; hwConcurrency=20 + Linux is the standout
-            // anomaly). Normalize to a common consumer profile. Same per-nav main-
-            // world application as the WebGL spoof — patchright denies init-world
-            // reach, and Turnstile reads these after the challenge script loads
-            // (seconds in), so the framenavigated re-apply wins the race. Defined on
-            // Navigator.prototype (where the native getters live) so there's no own-
-            // property tell on the instance.
-            const navProto = Navigator.prototype;
-            if (navProto.__tsDevicePatched !== true) {
-                try {
-                    Object.defineProperty(Navigator.prototype, "hardwareConcurrency", {
-                        get: () => 8,
-                        configurable: true,
-                    });
-                    Object.defineProperty(Navigator.prototype, "deviceMemory", {
-                        get: () => 8,
-                        configurable: true,
-                    });
-                    // Screen availHeight tell: a headless Xvfb screen reports
-                    // availHeight == height (no OS taskbar), whereas a real Windows
-                    // desktop reserves ~40px for the taskbar (availHeight = height-40,
-                    // availWidth = width). Reinstate that gap so the screen reads like
-                    // an ordinary desktop, not a bare framebuffer. Guarded so it only
-                    // applies when the two are currently equal (i.e. headless).
-                    try {
-                        if (screen.availHeight === screen.height) {
-                            Object.defineProperty(Screen.prototype, "availHeight", {
-                                get: () => screen.height - 40,
-                                configurable: true,
-                            });
-                        }
-                    }
-                    catch {
-                        // leave it
-                    }
-                    navProto.__tsDevicePatched = true;
-                }
-                catch {
-                    // descriptor already locked by something else — leave it.
-                }
-            }
+        const installWebglSpoofScript = String.raw `(() => {
+      const VENDOR_WEBGL = 0x9245; // UNMASKED_VENDOR_WEBGL
+      const RENDERER_WEBGL = 0x9246; // UNMASKED_RENDERER_WEBGL
+      const spoof = (proto) => {
+        // The marker lives on the prototype so re-application is a no-op; the
+        // cast is the one typed-alternative-exhausted spot (adding an ad-hoc
+        // brand to a DOM prototype).
+        if (proto.__tsWebglPatched === true) return;
+        const orig = proto.getParameter;
+        const native = orig.toString();
+        proto.getParameter = function (p) {
+          if (p === VENDOR_WEBGL) return "Google Inc. (Intel)";
+          if (p === RENDERER_WEBGL) {
+            return "ANGLE (Intel, Mesa Intel(R) UHD Graphics 620 (KBL GT2), OpenGL 4.6)";
+          }
+          return orig.call(this, p);
         };
-        await context.addInitScript(installWebglSpoof);
+        Object.defineProperty(proto.getParameter, "toString", {
+          value: () => native,
+          configurable: true,
+          writable: true,
+        });
+        proto.__tsWebglPatched = true;
+      };
+      if (typeof WebGLRenderingContext !== "undefined") {
+        spoof(WebGLRenderingContext.prototype);
+      }
+      if (typeof WebGL2RenderingContext !== "undefined") {
+        spoof(WebGL2RenderingContext.prototype);
+      }
+      // Device-tell normalization. The headless harvester box reports 20
+      // logical cores (navigator.hardwareConcurrency) — a consumer residential
+      // device is 4-16. A 20-core Linux machine behind a "residential" IP is
+      // an internal inconsistency Cloudflare Turnstile scores against
+      // (MEASURED 2026-06-11: exa/cartesia Turnstile won't issue a token on a
+      // clean-fingerprint click; hwConcurrency=20 + Linux is the standout
+      // anomaly). Normalize to a common consumer profile. Same per-nav main-
+      // world application as the WebGL spoof — patchright denies init-world
+      // reach, and Turnstile reads these after the challenge script loads
+      // (seconds in), so the framenavigated re-apply wins the race. Defined on
+      // Navigator.prototype (where the native getters live) so there's no own-
+      // property tell on the instance.
+      const navProto = Navigator.prototype;
+      if (navProto.__tsDevicePatched !== true) {
+        try {
+          Object.defineProperty(Navigator.prototype, "hardwareConcurrency", {
+            get: () => 8,
+            configurable: true,
+          });
+          Object.defineProperty(Navigator.prototype, "deviceMemory", {
+            get: () => 8,
+            configurable: true,
+          });
+          // Screen availHeight tell: a headless Xvfb screen reports
+          // availHeight == height (no OS taskbar), whereas a real Windows
+          // desktop reserves ~40px for the taskbar (availHeight = height-40,
+          // availWidth = width). Reinstate that gap so the screen reads like
+          // an ordinary desktop, not a bare framebuffer. Guarded so it only
+          // applies when the two are currently equal (i.e. headless).
+          try {
+            if (screen.availHeight === screen.height) {
+              Object.defineProperty(Screen.prototype, "availHeight", {
+                get: () => screen.height - 40,
+                configurable: true,
+              });
+            }
+          } catch {
+            // leave it
+          }
+          navProto.__tsDevicePatched = true;
+        } catch {
+          // descriptor already locked by something else — leave it.
+        }
+      }
+    })();`;
+        if (!remoteMode)
+            await context.addInitScript({ content: installWebglSpoofScript });
         this.page = context.pages()[0] ?? (await context.newPage());
+        // addInitScript covers document-start page JS, but Playwright's
+        // page.evaluate utility execution can run in a separate realm. Install the
+        // same no-op helper there with a STRING evaluate (tsx cannot wrap strings
+        // with __name). This prevents dev-runtime source runs from crashing before
+        // replay reaches the service page.
+        await this.page.evaluate(evaluateNameShimScript).catch(() => undefined);
         // Re-apply on every navigation — the main-world reach patchright's isolated
         // init world denies us. framenavigated fires at navigation-commit (before
         // most page JS), so a late WebGL query (reCAPTCHA scores seconds in) sees
         // the spoofed strings; a document-start fingerprinter could still race it.
         const reapplyWebglSpoof = () => {
+            if (remoteMode)
+                return; // real-GPU remote host: spoof nothing
             const pg = this.page;
             if (pg === null)
                 return;
-            void pg.evaluate(installWebglSpoof).catch(() => {
-                // mid-navigation / closed page — the next navigation re-applies.
-            });
+            void (async () => {
+                await pg.evaluate(evaluateNameShimScript).catch(() => undefined);
+                await pg.evaluate(installWebglSpoofScript).catch(() => {
+                    // mid-navigation / closed page — the next navigation re-applies.
+                });
+            })();
         };
+        // A CROSS-ORIGIN captcha iframe (hCaptcha / Turnstile / reCAPTCHA) is its own
+        // realm: the main-frame page.evaluate above never reaches it, so the captcha's
+        // OWN fingerprint read sees the real software-WebGL renderer (llvmpipe /
+        // SwiftShader) + 20-core / high-memory / no-taskbar Linux profile — a
+        // headless/VM tell. MEASURED 2026-06-23: Stripe's invisible hCaptcha
+        // Enterprise flags the session before any token, identically on a datacenter
+        // AND a residential exit IP (IP falsified) — the discriminator is this
+        // unspoofed in-iframe fingerprint. Patch the iframe's own main world too.
+        // frame.evaluate reaches a cross-origin frame's main world at the driver
+        // level (same path that wins the main-frame race), re-applied at
+        // navigation-commit before the captcha's scoring JS queries WebGL.
+        const CAPTCHA_FRAME_RE = /(hcaptcha\.com|challenges\.cloudflare\.com|google\.com\/recaptcha|recaptcha\.net|arkoselabs\.com|funcaptcha\.com)/i;
+        // String probe (no compiled-fn __name shim needed): the UNMASKED renderer
+        // a captcha would read. Logged only under CAPTCHA_TRACE to prove the fix.
+        const RENDERER_PROBE = String.raw `(() => { try { const c = document.createElement("canvas"); const gl = c.getContext("webgl") || c.getContext("webgl2"); if (!gl) return "no-gl"; const e = gl.getExtension("WEBGL_debug_renderer_info"); return e ? String(gl.getParameter(e.UNMASKED_RENDERER_WEBGL)) : "no-ext"; } catch (err) { return "err:" + (err && err.message); } })()`;
+        const trace = process.env.UNIVERSAL_BOT_CAPTCHA_TRACE === "1";
         this.page.on("framenavigated", (frame) => {
-            if (this.page !== null && frame === this.page.mainFrame())
+            if (remoteMode)
+                return; // real-GPU remote host: no in-iframe spoof
+            if (this.page === null)
+                return;
+            if (frame === this.page.mainFrame()) {
                 reapplyWebglSpoof();
+                return;
+            }
+            if (!CAPTCHA_FRAME_RE.test(frame.url()))
+                return;
+            const cfHost = (() => {
+                try {
+                    return new URL(frame.url()).host;
+                }
+                catch {
+                    return "captcha-frame";
+                }
+            })();
+            void (async () => {
+                if (trace) {
+                    const before = await frame.evaluate(RENDERER_PROBE).catch(() => "eval-fail");
+                    // eslint-disable-next-line no-console
+                    console.error(`[captcha-fp] ${cfHost} renderer BEFORE spoof: ${before}`);
+                }
+                // Retry until the spoof STICKS. The first framenavigated commonly
+                // eval-fails (frame mid-commit, or a throwaway about:blank hCaptcha
+                // replaces), and hCaptcha reads the fingerprint during its widget
+                // lifecycle — a single best-effort apply loses the race. Re-apply on a
+                // ~3s budget until the iframe's renderer reads Intel, so the spoof is in
+                // place before the scoring read.
+                let landed = false;
+                for (let i = 0; i < 20 && !landed; i++) {
+                    await frame.evaluate(installWebglSpoofScript).catch(() => undefined);
+                    const r = await frame.evaluate(RENDERER_PROBE).catch(() => "eval-fail");
+                    if (typeof r === "string" && r.includes("Intel"))
+                        landed = true;
+                    else
+                        await new Promise((res) => setTimeout(res, 150));
+                }
+                if (trace) {
+                    // eslint-disable-next-line no-console
+                    console.error(`[captcha-fp] ${cfHost} renderer AFTER spoof:  ${landed ? "Intel (landed)" : "FAILED to land in budget"}`);
+                }
+            })();
         });
         this.page.on("load", reapplyWebglSpoof);
         // rc.33 — captcha tracing. When UNIVERSAL_BOT_CAPTCHA_TRACE=1 is
@@ -913,13 +1249,14 @@ export class BrowserController {
         if (process.env.UNIVERSAL_BOT_CAPTCHA_TRACE === "1") {
             this.page.on("response", async (resp) => {
                 const url = resp.url();
-                if (!/challenges\.cloudflare\.com|google\.com\/recaptcha/.test(url)) {
+                if (!/challenges\.cloudflare\.com|google\.com\/recaptcha|hcaptcha\.com|newassets\.hcaptcha\.com/.test(url)) {
                     return;
                 }
                 const status = resp.status();
                 const ct = resp.headers()["content-type"] ?? "";
                 let bodyPreview = "";
-                if (/json|javascript|html|plain/.test(ct)) {
+                if (/json|javascript|html|plain/.test(ct) ||
+                    /api\.hcaptcha\.com\/(?:checksiteconfig|getcaptcha|checkcaptcha)/.test(url)) {
                     try {
                         const body = await resp.text();
                         bodyPreview =
@@ -945,6 +1282,19 @@ export class BrowserController {
     // same channel + proxy so it reports the real egress. Best-effort —
     // any failure returns null and start() keeps a default timezone.
     async probeEgressGeo(channel, proxy) {
+        if (proxy === null) {
+            try {
+                const resp = await fetch("https://ipinfo.io/json", { signal: AbortSignal.timeout(10_000) });
+                if (!resp.ok)
+                    throw new Error(`HTTP ${resp.status}`);
+                return parseEgressGeo(await resp.text());
+            }
+            catch (err) {
+                console.error(`[universal-bot] egress geo probe failed — using default ` +
+                    `timezone: ${err instanceof Error ? err.message : String(err)}`);
+                return null;
+            }
+        }
         let probe;
         try {
             probe = await getChromium().launch({
@@ -1058,6 +1408,28 @@ export class BrowserController {
         // settled page. Distinct from ERR_CONNECTION_ABORTED (a dropped socket).
         const TRANSIENT_NET = /ERR_SOCKS_CONNECTION_FAILED|ERR_CONNECTION_(?:RESET|CLOSED|FAILED|ABORTED)|ERR_NETWORK_CHANGED|ERR_TIMED_OUT|ERR_NAME_NOT_RESOLVED|net::ERR_EMPTY_RESPONSE|net::ERR_ABORTED/i;
         const MAX_GOTO_ATTEMPTS = 3;
+        const sameOriginPathAndSearch = (a, b) => {
+            try {
+                const left = new URL(a);
+                const right = new URL(b);
+                return left.origin === right.origin && left.pathname === right.pathname && left.search === right.search;
+            }
+            catch {
+                return false;
+            }
+        };
+        const landedAuthGateForTarget = (landedRaw, targetRaw) => {
+            try {
+                const landed = new URL(landedRaw);
+                const target = new URL(targetRaw);
+                if (landed.origin !== target.origin)
+                    return false;
+                return /\/(?:sign[_-]?in|login|log[_-]?in|auth)(?:\/|$)/i.test(landed.pathname);
+            }
+            catch {
+                return false;
+            }
+        };
         for (let attempt = 1;; attempt++) {
             try {
                 await this.page.goto(url, { waitUntil: "domcontentloaded", timeout: 60000 });
@@ -1081,6 +1453,25 @@ export class BrowserController {
             }
             catch (err) {
                 const msg = err instanceof Error ? err.message : String(err);
+                // Some client-routed apps commit the address bar to the requested SPA
+                // route but never fire the lifecycle event Playwright is waiting for.
+                // Treat that as a successful navigation: callers immediately inspect
+                // the DOM and have their own element-level waits.
+                if (/Timeout \d+ms exceeded/i.test(msg)) {
+                    await this.sleep(500);
+                    if (sameOriginPathAndSearch(this.page.url(), url))
+                        break;
+                    if (landedAuthGateForTarget(this.page.url(), url))
+                        break;
+                    await this.page
+                        .waitForURL((landed) => sameOriginPathAndSearch(landed.toString(), url), { timeout: 5000 })
+                        .then(() => undefined)
+                        .catch(() => undefined);
+                    if (sameOriginPathAndSearch(this.page.url(), url))
+                        break;
+                    if (landedAuthGateForTarget(this.page.url(), url))
+                        break;
+                }
                 if (attempt >= MAX_GOTO_ATTEMPTS || !TRANSIENT_NET.test(msg))
                     throw err;
                 // Linear backoff — give the tunnel a moment to recover a slot.
@@ -1483,6 +1874,13 @@ export class BrowserController {
         }
         await this.humanClick(selector);
     }
+    async clickNth(selector, index) {
+        if (!this.page)
+            throw new Error("Browser not started");
+        const safeIndex = Math.max(0, Math.floor(index));
+        const locator = this.page.locator(selector).nth(safeIndex);
+        await locator.click({ timeout: 8000 });
+    }
     // Click a link/button by its visible text. Used for one-off
     // dismissibles where the bot knows the literal label text and
     // doesn't need full inventory ranking (e.g. GitHub's "skip 2FA
@@ -1608,38 +2006,52 @@ export class BrowserController {
             .scrollIntoViewIfNeeded({ timeout: 5000 })
             .catch(() => { });
         if (!this.humanize) {
-            await this.page.check(selector, { force: true });
-            return;
+            await this.page.check(selector, { force: true }).catch(() => undefined);
+            if (await this.ensureChecked(selector))
+                return;
+            throw new Error(`Unable to check selector "${selector}" after label and DOM fallbacks`);
         }
         // For visible checkboxes, move the mouse to it first (a real user
         // would). For force-checked invisible ones, fall back to the
         // Playwright API so we don't try to mouse-click an offscreen element.
-        try {
-            await this.humanClick(selector);
-            // Verify it actually became checked; some checkboxes need the
-            // explicit `check()` call to flip state (e.g., styled labels
-            // that swallow the click event).
-            let isChecked = await this.page.locator(selector).isChecked();
-            if (!isChecked) {
-                await this.page.check(selector, { force: true });
-                isChecked = await this.page.locator(selector).isChecked().catch(() => false);
+        await this.humanClick(selector).catch(() => undefined);
+        await this.page.check(selector, { force: true }).catch(() => undefined);
+        if (await this.ensureChecked(selector))
+            return;
+        throw new Error(`Unable to check selector "${selector}" after click, label, and DOM fallbacks`);
+    }
+    async ensureChecked(selector) {
+        if (!this.page)
+            return false;
+        if (await this.page.locator(selector).isChecked().catch(() => false))
+            return true;
+        await this.clickAssociatedLabel(selector).catch(() => false);
+        if (await this.page.locator(selector).isChecked().catch(() => false))
+            return true;
+        const domChecked = await this.page
+            .locator(selector)
+            .first()
+            .evaluate((el) => {
+            if (!(el instanceof HTMLInputElement))
+                return false;
+            if (el.type !== "checkbox" && el.type !== "radio")
+                return false;
+            if (!el.checked) {
+                el.click();
             }
-            // Mantine / Radix styled checkboxes: the hidden <input> can read
-            // checked in the DOM while the library's React onChange never fired —
-            // so the form's controlled state stays false and the gated submit
-            // stays disabled even though isChecked() is true (MEASURED 2026-06-11:
-            // friendliai's #agreedToServiceTerms cost a wasted round because the
-            // first check didn't register the form state). Clicking the ASSOCIATED
-            // LABEL fires the real onChange the library listens for. Best-effort.
-            if (!isChecked) {
-                const labelClicked = await this.clickAssociatedLabel(selector);
-                if (!labelClicked)
-                    await this.page.check(selector, { force: true });
+            if (!el.checked) {
+                el.checked = true;
+                el.setAttribute("checked", "");
+                el.setAttribute("aria-checked", "true");
+                el.dispatchEvent(new Event("input", { bubbles: true }));
+                el.dispatchEvent(new Event("change", { bubbles: true }));
             }
-        }
-        catch {
-            await this.page.check(selector, { force: true });
-        }
+            return el.checked;
+        })
+            .catch(() => false);
+        if (!domChecked)
+            return false;
+        return await this.page.locator(selector).isChecked().catch(() => false);
     }
     // Click the <label> associated with a checkbox/radio input — either a
     // `<label for="<id>">` or the wrapping `<label>` ancestor. Mantine/Radix
@@ -1669,6 +2081,31 @@ export class BrowserController {
                 await wrapping.click({ timeout: 4000 });
                 return true;
             }
+            // Some Radix/shadcn-style controls render the hidden input as a sibling
+            // of the visible agreement label, with no `for=` and no wrapping label
+            // (Mistral's terms checkbox). At this point direct check has already
+            // failed/not toggled, so clicking the nearest agreement-shaped label in
+            // the same form is the safest remaining human-equivalent action.
+            const clickedAgreement = await this.page
+                .locator(selector)
+                .first()
+                .evaluate((el) => {
+                const agreementRe = /terms|tos\b|privacy|policy|i accept|i agree|agree to/i;
+                const form = el.closest("form");
+                const labels = [
+                    ...(form ? Array.from(form.querySelectorAll("label")) : []),
+                    ...Array.from(document.querySelectorAll("label")),
+                ];
+                const label = labels.find((candidate) => agreementRe.test(candidate.textContent ?? ""));
+                if (!(label instanceof HTMLElement))
+                    return false;
+                label.click();
+                return true;
+            })
+                .catch(() => false);
+            if (clickedAgreement) {
+                return true;
+            }
         }
         catch {
             // best-effort
@@ -1699,7 +2136,7 @@ export class BrowserController {
                 // These two regexes MUST stay byte-identical with
                 // AGREEMENT_TEXT_RE / MARKETING_TEXT_RE in this module — the
                 // page realm can't import, so they're inlined here.
-                const agreementRe = /terms|tos\b|privacy|consent|policy|i agree|agree to|acknowledge|gdpr/i;
+                const agreementRe = /terms|tos\b|privacy|consent|policy|i agree|agree to|acknowledge|gdpr|age|18\+|18 years|certif/i;
                 const marketingRe = /newsletter|updates|offers|product tips|marketing|promotional|receive emails|opt[- ]?in to|subscribe/i;
                 const checked = [];
                 const boxes = Array.from(document.querySelectorAll('input[type="checkbox"]'));
@@ -1707,7 +2144,11 @@ export class BrowserController {
                     if (box.checked || box.disabled)
                         continue;
                     const rect = box.getBoundingClientRect();
-                    if (rect.width <= 0 || rect.height <= 0)
+                    const ancestorLabel = box.closest("label");
+                    const labelRect = ancestorLabel?.getBoundingClientRect();
+                    const visible = (rect.width > 0 && rect.height > 0) ||
+                        (labelRect !== undefined && labelRect.width > 0 && labelRect.height > 0);
+                    if (!visible)
                         continue;
                     // Associated text = attributes + a label[for=id] + nearest
                     // ancestor <label> + the immediately following sibling text.
@@ -1722,7 +2163,6 @@ export class BrowserController {
                         if (forLabel)
                             parts.push(forLabel.textContent ?? "");
                     }
-                    const ancestorLabel = box.closest("label");
                     if (ancestorLabel)
                         parts.push(ancestorLabel.textContent ?? "");
                     const sibling = box.nextSibling;
@@ -1736,12 +2176,15 @@ export class BrowserController {
                         continue;
                     // React/Vue controlled inputs ignore a bare `.checked = true`:
                     // their state lives in the framework, updated only by the real
-                    // event flow. Set the property AND dispatch input/change AND a
-                    // synthetic click so the controlled binding observes the flip.
-                    box.checked = true;
+                    // event flow. Click first (while unchecked) so the framework sees the
+                    // same transition a user would make, then force-ensure checked and
+                    // dispatch input/change for styled/hidden inputs whose click target
+                    // does not toggle the underlying control.
+                    box.click();
+                    if (!box.checked)
+                        box.checked = true;
                     box.dispatchEvent(new Event("input", { bubbles: true }));
                     box.dispatchEvent(new Event("change", { bubbles: true }));
-                    box.click();
                     const label = box.getAttribute("data-testid") ||
                         box.getAttribute("name") ||
                         box.id ||
@@ -1756,6 +2199,111 @@ export class BrowserController {
             return [];
         }
     }
+    // Deterministic pre-submit guard for required signup category choices.
+    //
+    // Paddle-class forms ask a required "What do you sell?" question where one
+    // product category must be selected before account creation, but the submit
+    // button remains enabled. The planner can satisfy the agreement checkbox and
+    // still skip the category, producing a rejected submit + no verification mail.
+    //
+    // Keep this conservative: only fire when the page text explicitly says a
+    // product/category choice is required, never touch agreement/marketing boxes,
+    // and prefer low-risk SaaS/software labels over restricted categories.
+    async checkRequiredSignupChoiceBoxes() {
+        if (!this.page)
+            throw new Error("Browser not started");
+        try {
+            return await this.page.evaluate(() => {
+                const choiceGateRe = /what do you sell|categories we support|select which types? of products|choose (?:a|your) (?:category|product|business type)|product category|business category/i;
+                const safeChoiceRe = /digital products?|saas|software|developer tools?|apis?|mobile apps?|data|analytics/i;
+                const riskyChoiceRe = /gambling|financial services?|physical products?|marketplace|human services?|adult|weapons?|medical|restricted|crypto|payments?|banking/i;
+                const agreementRe = /terms|tos\b|privacy|consent|policy|i agree|agree to|acknowledge|gdpr/i;
+                const marketingRe = /newsletter|updates|offers|product tips|marketing|promotional|receive emails|opt[- ]?in to|subscribe/i;
+                const bodyText = document.body?.innerText ?? "";
+                if (!choiceGateRe.test(bodyText))
+                    return [];
+                const associatedText = (box) => {
+                    const parts = [
+                        box.getAttribute("data-testid") ?? "",
+                        box.getAttribute("name") ?? "",
+                        box.id,
+                        box.getAttribute("aria-label") ?? "",
+                    ];
+                    if (box.id) {
+                        const forLabel = document.querySelector(`label[for="${CSS.escape(box.id)}"]`);
+                        if (forLabel)
+                            parts.push(forLabel.textContent ?? "");
+                    }
+                    const ancestorLabel = box.closest("label");
+                    if (ancestorLabel)
+                        parts.push(ancestorLabel.textContent ?? "");
+                    if (box.nextElementSibling) {
+                        parts.push(box.nextElementSibling.textContent ?? "");
+                    }
+                    return parts.join(" ").replace(/\s+/g, " ").trim();
+                };
+                const boxes = Array.from(document.querySelectorAll('input[type="checkbox"], input[type="radio"]'));
+                const visibleBoxes = boxes.filter((box) => {
+                    if (box.disabled)
+                        return false;
+                    const rect = box.getBoundingClientRect();
+                    return rect.width > 0 && rect.height > 0;
+                });
+                const alreadyChoseCategory = visibleBoxes.some((box) => {
+                    if (!box.checked)
+                        return false;
+                    const text = associatedText(box);
+                    return (!agreementRe.test(text) &&
+                        !marketingRe.test(text) &&
+                        !riskyChoiceRe.test(text));
+                });
+                if (alreadyChoseCategory)
+                    return [];
+                const candidates = visibleBoxes
+                    .filter((box) => !box.checked)
+                    .map((box) => ({ box, text: associatedText(box) }))
+                    .filter(({ text }) => {
+                    if (!text)
+                        return false;
+                    if (agreementRe.test(text) || marketingRe.test(text))
+                        return false;
+                    if (riskyChoiceRe.test(text))
+                        return false;
+                    return safeChoiceRe.test(text);
+                })
+                    .sort((a, b) => {
+                    const score = (text) => {
+                        if (/digital products?|saas|software/i.test(text))
+                            return 3;
+                        if (/developer tools?|apis?|data|analytics/i.test(text))
+                            return 2;
+                        if (/mobile apps?/i.test(text))
+                            return 1;
+                        return 0;
+                    };
+                    return score(b.text) - score(a.text);
+                });
+                const choice = candidates[0];
+                if (!choice)
+                    return [];
+                choice.box.checked = true;
+                choice.box.dispatchEvent(new Event("input", { bubbles: true }));
+                choice.box.dispatchEvent(new Event("change", { bubbles: true }));
+                choice.box.click();
+                return [
+                    choice.box.getAttribute("data-testid") ||
+                        choice.box.getAttribute("name") ||
+                        choice.box.id ||
+                        choice.box.getAttribute("aria-label") ||
+                        choice.text ||
+                        "signup-choice",
+                ];
+            });
+        }
+        catch {
+            return [];
+        }
+    }
     // Scroll a Terms-of-Service style modal to the bottom so the gated
     // "Accept" button enables. Railway's signup is the canonical case:
     // a modal with a virtualized ToS list watches real `scroll` /
@@ -1979,6 +2527,39 @@ export class BrowserController {
                     tagName = "select";
                 }
             }
+            else {
+                const rowControl = await this.page
+                    .locator(activeSelector)
+                    .first()
+                    .evaluate((label) => {
+                    const root = label.closest(".n-form-group__row") ??
+                        label.closest("label")?.parentElement ??
+                        label.parentElement;
+                    const control = root?.querySelector('select,button[role="combobox"],input[role="combobox"],[role="combobox"]');
+                    if (control === null || control === undefined)
+                        return null;
+                    const id = control.getAttribute("id");
+                    if (id !== null && id.length > 0)
+                        return `#${CSS.escape(id)}`;
+                    const testId = control.getAttribute("data-qa") ??
+                        control.getAttribute("data-testid") ??
+                        control.getAttribute("data-test") ??
+                        control.getAttribute("data-cy");
+                    if (testId !== null && testId.length > 0) {
+                        return `[data-qa="${CSS.escape(testId)}"],[data-testid="${CSS.escape(testId)}"],[data-test="${CSS.escape(testId)}"],[data-cy="${CSS.escape(testId)}"]`;
+                    }
+                    return null;
+                })
+                    .catch(() => null);
+                if (rowControl !== null) {
+                    activeSelector = rowControl;
+                    tagName = await this.page
+                        .locator(activeSelector)
+                        .first()
+                        .evaluate((node) => node.tagName.toLowerCase())
+                        .catch(() => tagName);
+                }
+            }
         }
         if (tagName === "select") {
             // Native path. rc.15 — keep value="" options selectable. The
@@ -2094,6 +2675,8 @@ export class BrowserController {
             '[role="option"]:visible',
             '[role="menuitem"]:visible',
             '[role="menuitemradio"]:visible',
+            'mat-option:visible',
+            '.mat-mdc-option:visible',
             '[id^="react-select-"][role*="menu"]:visible',
             '[role="listbox"]:visible li:visible',
         ];
@@ -2392,7 +2975,7 @@ export class BrowserController {
         // misreads "URL unchanged, not on provider" as "OAuth completed"
         // and the run falls apart.
         //
-        // Poll for up to 6s for the disabled state to clear. Both the
+        // Poll for up to 15s for the disabled state to clear. Both the
         // HTML `disabled` attribute AND `aria-disabled="true"` are
         // honored — the latter covers ARIA-styled buttons (Radix, Headless
         // UI) that visually appear interactive but reject input.
@@ -2411,7 +2994,7 @@ export class BrowserController {
         // next round's reason includes "click failed: target is
         // aria-disabled" and the planner pivots to checking other fields.
         {
-            const deadline = Date.now() + 6000;
+            const deadline = Date.now() + 15_000;
             let isDisabled = false;
             while (Date.now() < deadline) {
                 isDisabled = await locator
@@ -2435,7 +3018,7 @@ export class BrowserController {
                 // (meilisearch/zilliz: planner clicked a disabled Next 4+ times because
                 // the generic hint didn't say WHICH field blocked it). Feedback only.
                 const hint = await this.unfilledRequiredHint();
-                throw new Error("target is disabled (HTML disabled or aria-disabled=true) after 6s — " +
+                throw new Error("target is disabled (HTML disabled or aria-disabled=true) after 15s — " +
                     "the click would no-op. A required precondition is unmet: an empty " +
                     "input, an unselected dropdown, an unchecked agreement checkbox, or " +
                     "a missing preset/permission choice. Do NOT retry this click — pick a " +
@@ -2677,6 +3260,11 @@ export class BrowserController {
                 return false;
             });
             if (solved) {
+                if (widget.kind === "hcaptcha") {
+                    const settled = await this.waitForCaptchaChallengeToSettle(15_000, 10_000);
+                    if (!settled)
+                        return { found: true, solved: false, kind: widget.kind };
+                }
                 return { found: true, solved: true, kind: widget.kind };
             }
         }
@@ -2968,6 +3556,14 @@ export class BrowserController {
                     input.dispatchEvent(new Event("input", { bubbles: true }));
                     input.dispatchEvent(new Event("change", { bubbles: true }));
                 }
+                for (const el of Array.from(document.querySelectorAll("[data-hcaptcha-widget-id], .h-captcha"))) {
+                    el.setAttribute("data-hcaptcha-response", tok);
+                    el.dispatchEvent(new Event("input", { bubbles: true }));
+                    el.dispatchEvent(new Event("change", { bubbles: true }));
+                }
+                const form = inputs[0]?.closest("form");
+                form?.dispatchEvent(new Event("input", { bubbles: true }));
+                form?.dispatchEvent(new Event("change", { bubbles: true }));
                 // 2. Fire the widget's onSuccess callback if registered. The
                 //    callbacks are stored on `___grecaptcha_cfg.clients`; the
                 //    exact tree is undocumented and shifts across versions
@@ -3180,7 +3776,7 @@ export class BrowserController {
         if (!this.page)
             throw new Error("Browser not started");
         try {
-            return await this.page.evaluate(() => {
+            const fromDom = await this.page.evaluate(() => {
                 const div = document.querySelector(".h-captcha[data-sitekey], [data-hcaptcha-sitekey]");
                 if (div !== null) {
                     const k = div.getAttribute("data-sitekey") ??
@@ -3190,69 +3786,361 @@ export class BrowserController {
                 }
                 const iframe = document.querySelector('iframe[src*="hcaptcha.com"]');
                 if (iframe !== null) {
-                    const k = new URL(iframe.src).searchParams.get("sitekey");
+                    const url = new URL(iframe.src);
+                    const k = url.searchParams.get("sitekey") ??
+                        new URLSearchParams(url.hash.startsWith("#") ? url.hash.slice(1) : url.hash).get("sitekey");
                     if (k !== null && k.length > 10)
                         return k;
                 }
-                // INVISIBLE hCaptcha (huggingface, 2026-06-17): no .h-captcha div, no
-                // rendered iframe — the sitekey lives in the page's JS config
-                // (`captchaApiKey:"<uuid>"`, `sitekey:"<uuid>"`). Scan the HTML for a
-                // UUID-shaped key next to a sitekey/captcha hint, but ONLY when an
-                // hCaptcha script is present (so an unrelated config UUID can't match).
-                // UUID shape excludes reCAPTCHA `6L…` and Turnstile `0x…` keys.
-                const html = document.documentElement.outerHTML;
-                if (/hcaptcha\.com|h-captcha|hcaptcha/i.test(html)) {
-                    const m = html.match(/(?:sitekey|captchaApiKey|data-(?:hcaptcha-)?sitekey)["'\s]*[:=]\s*["']([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})["']/i);
-                    if (m !== null && m[1] !== undefined)
-                        return m[1];
-                }
                 return null;
             });
+            if (fromDom !== null)
+                return fromDom;
+            // INVISIBLE hCaptcha (Hugging Face, Stripe): no .h-captcha div, no
+            // iframe `?sitekey=` param — the sitekey lives in the page's JS/JSON
+            // config (`captchaApiKey`, `express_hcaptcha_site_key`,
+            // `hcaptcha_login_main_site_key`, etc.). Scan the HTML for a UUID-shaped
+            // key next to a sitekey/captcha hint, but only when an hCaptcha marker is
+            // present so an unrelated config UUID cannot match.
+            const html = await this.page.evaluate(() => document.documentElement.outerHTML);
+            return extractHcaptchaSitekeyFromHtml(html);
+        }
+        catch {
+            return null;
+        }
+    }
+    async getBrowserUserAgent() {
+        if (!this.page)
+            throw new Error("Browser not started");
+        try {
+            return await this.page.evaluate(() => navigator.userAgent);
         }
         catch {
             return null;
         }
     }
+    async getHcaptchaSolveContext() {
+        if (!this.page)
+            throw new Error("Browser not started");
+        try {
+            return await this.page.evaluate(() => {
+                let invisible = false;
+                let rqdata = null;
+                const useRqdata = (value) => {
+                    if (rqdata === null && value !== null && value.trim().length > 0)
+                        rqdata = value;
+                };
+                for (const el of Array.from(document.querySelectorAll(".h-captcha, [data-hcaptcha-widget-id]"))) {
+                    const size = el.getAttribute("data-size") ?? el.getAttribute("size");
+                    if (size?.toLowerCase() === "invisible")
+                        invisible = true;
+                    useRqdata(el.getAttribute("data-rqdata"));
+                }
+                for (const iframe of Array.from(document.querySelectorAll('iframe[src*="hcaptcha.com"]'))) {
+                    try {
+                        const url = new URL(iframe.src);
+                        const hashParams = new URLSearchParams(url.hash.startsWith("#") ? url.hash.slice(1) : url.hash);
+                        const size = url.searchParams.get("size") ?? hashParams.get("size");
+                        const frame = url.searchParams.get("frame") ?? hashParams.get("frame");
+                        useRqdata(url.searchParams.get("rqdata") ?? hashParams.get("rqdata"));
+                        const clientOptions = url.searchParams.get("clientOptions") ?? hashParams.get("clientOptions");
+                        if (clientOptions !== null) {
+                            try {
+                                const parsed = JSON.parse(clientOptions);
+                                if (typeof parsed.rqdata === "string")
+                                    useRqdata(parsed.rqdata);
+                            }
+                            catch {
+                                // ignore non-JSON client options
+                            }
+                        }
+                        if (size?.toLowerCase() === "invisible" ||
+                            frame?.toLowerCase() === "checkbox-invisible") {
+                            invisible = true;
+                        }
+                    }
+                    catch {
+                        // ignore malformed extension/proxy iframe URLs
+                    }
+                }
+                return { invisible, userAgent: navigator.userAgent, rqdata };
+            });
+        }
+        catch {
+            return {
+                invisible: false,
+                userAgent: await this.getBrowserUserAgent().catch(() => null),
+                rqdata: null,
+            };
+        }
+    }
     // Inject a 2Captcha-resolved hCaptcha token into the page's
-    // h-captcha-response textarea(s) and fire the widget's data-callback
-    // if the page registered one. Mirrors injectRecaptchaToken; hCaptcha
-    // also mirrors the response token into a g-recaptcha-response textarea
-    // on some compat installs, so populate both names if present.
+    // h-captcha-response textarea(s), update hCaptcha runtime response
+    // accessors, and fire registered callbacks. Mirrors injectRecaptchaToken;
+    // hCaptcha also mirrors the response token into a g-recaptcha-response
+    // textarea on some compat installs, so populate both names if present.
     async injectHcaptchaToken(token) {
         if (!this.page)
             throw new Error("Browser not started");
         try {
-            return await this.page.evaluate((tok) => {
+            const responseKey = extractHcaptchaResponseKeyFromToken(token);
+            return await this.page.evaluate(({ tok, key }) => {
+                const widgetIds = new Set();
                 const inputs = Array.from(document.querySelectorAll('textarea[name="h-captcha-response"], textarea[id^="h-captcha-response"], textarea[name="g-recaptcha-response"]'));
-                if (inputs.length === 0)
-                    return false;
                 for (const input of inputs) {
                     input.value = tok;
                     input.dispatchEvent(new Event("input", { bubbles: true }));
                     input.dispatchEvent(new Event("change", { bubbles: true }));
                 }
-                // Fire the data-callback the page registered on the .h-captcha
-                // host (hCaptcha calls it by name on window). Best-effort — the
-                // populated textarea is what server-side validation reads.
+                for (const host of Array.from(document.querySelectorAll(".h-captcha, [data-hcaptcha-widget-id], [data-hcaptcha-response]"))) {
+                    host.setAttribute("data-hcaptcha-response", tok);
+                    const id = host.getAttribute("data-hcaptcha-widget-id") ??
+                        host.getAttribute("data-hcaptcha-widget-id".toLowerCase());
+                    if (id !== null && id.length > 0)
+                        widgetIds.add(id);
+                    host.dispatchEvent(new Event("input", { bubbles: true }));
+                    host.dispatchEvent(new Event("change", { bubbles: true }));
+                }
+                for (const iframe of Array.from(document.querySelectorAll('iframe[src*="hcaptcha.com"]'))) {
+                    try {
+                        const url = new URL(iframe.src);
+                        const params = new URLSearchParams(url.hash.startsWith("#") ? url.hash.slice(1) : url.hash);
+                        const id = params.get("id");
+                        if (id !== null && id.length > 0)
+                            widgetIds.add(id);
+                    }
+                    catch {
+                        // ignore malformed extension/proxy iframe URLs
+                    }
+                }
+                const win = window;
+                const hcaptcha = win.hcaptcha;
+                if (hcaptcha !== undefined) {
+                    const originalGetResponse = hcaptcha.getResponse?.bind(hcaptcha);
+                    const originalGetRespKey = hcaptcha.getRespKey?.bind(hcaptcha);
+                    hcaptcha.getResponse = (id) => {
+                        if (id === undefined || widgetIds.size === 0 || widgetIds.has(String(id)))
+                            return tok;
+                        return originalGetResponse?.(id) ?? tok;
+                    };
+                    hcaptcha.getRespKey = (id) => {
+                        if (id === undefined || widgetIds.size === 0 || widgetIds.has(String(id)))
+                            return key ?? "";
+                        return originalGetRespKey?.(id) ?? key ?? "";
+                    };
+                }
+                let callbackFired = false;
+                const fire = (fn) => {
+                    if (typeof fn !== "function")
+                        return;
+                    callbackFired = true;
+                    try {
+                        fn(tok, key ?? undefined);
+                    }
+                    catch {
+                        // A page callback can be stale after React remounts a widget.
+                    }
+                };
+                // Fire callbacks registered by markup, e.g. data-callback="onSubmit".
                 try {
-                    const host = document.querySelector(".h-captcha[data-callback]");
-                    const name = host?.getAttribute("data-callback");
-                    if (name !== null && name !== undefined) {
-                        const fn = window[name];
-                        if (typeof fn === "function")
-                            fn(tok);
+                    for (const host of Array.from(document.querySelectorAll(".h-captcha[data-callback]"))) {
+                        const name = host.getAttribute("data-callback");
+                        if (name !== null && name !== undefined)
+                            fire(win[name]);
                     }
                 }
                 catch {
-                    // no named callback — DOM injection stands.
+                    // no named callback, continue to runtime config scan.
                 }
-                return true;
-            }, token);
+                // Programmatic hCaptcha integrations pass function callbacks to
+                // hcaptcha.render(). The SDK keeps them in ___hcaptcha_cfg; crawl it
+                // generically so React/Vue wrappers are handled like plain forms.
+                const seen = new Set();
+                const scan = (value, depth) => {
+                    if (value === null || value === undefined || depth > 7 || seen.has(value))
+                        return;
+                    seen.add(value);
+                    if (typeof value === "function")
+                        return;
+                    if (typeof value !== "object")
+                        return;
+                    for (const [key, child] of Object.entries(value)) {
+                        const normalized = key.toLowerCase();
+                        if (typeof child === "function" &&
+                            (normalized === "callback" ||
+                                normalized === "success-callback" ||
+                                normalized === "verify-callback" ||
+                                normalized === "onverify" ||
+                                normalized === "onsuccess")) {
+                            fire(child);
+                            continue;
+                        }
+                        if (typeof child === "object" && child !== null)
+                            scan(child, depth + 1);
+                    }
+                };
+                scan(win.___hcaptcha_cfg, 0);
+                scan(win.hcaptcha, 0);
+                return inputs.length > 0 || widgetIds.size > 0 || callbackFired;
+            }, { tok: token, key: responseKey });
         }
         catch {
             return false;
         }
     }
+    async solveVisibleHcaptchaChallengeWithCoordinates(solve) {
+        if (!this.page)
+            throw new Error("Browser not started");
+        const challenge = await this.findVisibleHcaptchaChallengeFrame();
+        if (challenge === null) {
+            return { found: false, solved: false, reason: "no_visible_challenge" };
+        }
+        let shot;
+        try {
+            shot = await challenge.locator.screenshot({ type: "png", timeout: 8_000 });
+        }
+        catch (err) {
+            return {
+                found: true,
+                solved: false,
+                reason: `screenshot_failed:${err instanceof Error ? err.message : String(err)}`,
+                clicks: 0,
+            };
+        }
+        const dims = pngDimensions(shot);
+        if (dims === null || dims.width <= 0 || dims.height <= 0) {
+            return {
+                found: true,
+                solved: false,
+                reason: "invalid_challenge_screenshot",
+                clicks: 0,
+            };
+        }
+        const solveRes = await solve({
+            imageBase64: shot.toString("base64"),
+            comment: "hCaptcha challenge screenshot. Click all matching image targets requested by the prompt. If a Verify or Submit button is visible, click it after selecting targets.",
+            minClicks: 1,
+            maxClicks: 12,
+        });
+        if (solveRes.kind !== "ok") {
+            return {
+                found: true,
+                solved: false,
+                reason: `2captcha_${solveRes.kind}` +
+                    ("reason" in solveRes ? `:${solveRes.reason}` : ""),
+                clicks: 0,
+                ...("durationMs" in solveRes ? { durationMs: solveRes.durationMs } : {}),
+            };
+        }
+        let clicks = 0;
+        for (const point of solveRes.coordinates) {
+            const box = await challenge.locator.boundingBox({ timeout: 1_500 }).catch(() => null);
+            if (box === null || box.width <= 0 || box.height <= 0)
+                break;
+            const x = box.x + (point.x / dims.width) * box.width;
+            const y = box.y + (point.y / dims.height) * box.height;
+            await this.bezierMouseTo(x, y);
+            await this.sleep(rand(100, 260));
+            await this.page.mouse.click(x, y);
+            this.mouseX = x;
+            this.mouseY = y;
+            clicks += 1;
+        }
+        await this.sleep(650);
+        let settled = await this.waitForCaptchaChallengeToSettle(2_500).catch(() => false);
+        if (!settled && clicks > 0) {
+            const box = await challenge.locator.boundingBox({ timeout: 1_500 }).catch(() => null);
+            if (box !== null && box.width > 0 && box.height > 0) {
+                const verifyX = box.x + Math.min(box.width - 32, Math.max(32, box.width * 0.84));
+                const verifyY = box.y + Math.min(box.height - 24, Math.max(24, box.height * 0.92));
+                await this.bezierMouseTo(verifyX, verifyY);
+                await this.sleep(rand(120, 320));
+                await this.page.mouse.click(verifyX, verifyY);
+                this.mouseX = verifyX;
+                this.mouseY = verifyY;
+            }
+            settled = await this.waitForCaptchaChallengeToSettle(10_000).catch(() => false);
+        }
+        const responsePresent = await this.page
+            .evaluate(() => {
+            const ta = document.querySelector('textarea[name="h-captcha-response"], textarea[id^="h-captcha-response"]');
+            return ta !== null && ta.value.length > 0;
+        })
+            .catch(() => false);
+        const out = {
+            found: true,
+            solved: settled || responsePresent,
+            clicks,
+            durationMs: solveRes.durationMs,
+        };
+        if (!out.solved)
+            out.reason = "challenge_still_visible";
+        return out;
+    }
+    async findVisibleHcaptchaChallengeFrame() {
+        if (!this.page)
+            throw new Error("Browser not started");
+        const selectors = [
+            'iframe[src*="hcaptcha.com"][src*="frame=challenge"]',
+            'iframe[src*="newassets.hcaptcha.com"][src*="frame=challenge"]',
+            'iframe[src*="hcaptcha.com"][src*="/challenge"]',
+            'iframe[src*="newassets.hcaptcha.com"][src*="/challenge"]',
+        ];
+        const deadline = Date.now() + 5_000;
+        while (Date.now() < deadline) {
+            for (const selector of selectors) {
+                const locator = this.page.locator(selector);
+                const count = await locator.count().catch(() => 0);
+                for (let i = 0; i < count; i++) {
+                    const el = locator.nth(i);
+                    const box = await el.boundingBox({ timeout: 1_000 }).catch(() => null);
+                    if (box === null)
+                        continue;
+                    if (box.width < 180 || box.height < 160)
+                        continue;
+                    return { locator: el, box };
+                }
+            }
+            await this.sleep(250);
+        }
+        return null;
+    }
+    async waitForCaptchaChallengeToSettle(timeoutMs = 4000, stableClearMs = 2_500) {
+        if (!this.page)
+            throw new Error("Browser not started");
+        const hasVisibleChallenge = async () => await this.page.evaluate(() => {
+            const visible = (el) => {
+                const style = window.getComputedStyle(el);
+                if (style.display === "none" || style.visibility === "hidden" || style.opacity === "0") {
+                    return false;
+                }
+                const r = el.getBoundingClientRect();
+                return r.width > 8 && r.height > 8;
+            };
+            const selectors = [
+                'iframe[src*="hcaptcha.com"][src*="frame=challenge"]',
+                'iframe[src*="newassets.hcaptcha.com"][src*="frame=challenge"]',
+                'iframe[src*="recaptcha/api2/bframe"]',
+                'iframe[src*="challenges.cloudflare.com"]',
+            ];
+            return selectors.some((sel) => Array.from(document.querySelectorAll(sel)).some((el) => visible(el)));
+        });
+        const deadline = Date.now() + timeoutMs;
+        let clearSince = null;
+        while (Date.now() < deadline) {
+            const visible = await hasVisibleChallenge().catch(() => false);
+            if (!visible) {
+                clearSince ??= Date.now();
+                if (Date.now() - clearSince >= stableClearMs)
+                    return true;
+            }
+            else {
+                clearSince = null;
+            }
+            await this.sleep(250);
+        }
+        return false;
+    }
     // Small mouse wiggle near the current position. Used during prewarm
     // so the page sees pointer events before we navigate away.
     async jitterMouse() {
@@ -3286,6 +4174,7 @@ export class BrowserController {
             fullPage: false,
             type: "jpeg",
             quality: 70,
+            timeout: 8_000,
         });
         return buffer.toString("base64");
     }
@@ -3313,7 +4202,7 @@ export class BrowserController {
             url: this.page.url(),
             title: await this.page.title(),
             html: await this.page.content(),
-            screenshot: await this.screenshot(),
+            screenshot: await this.screenshot().catch(() => ""),
         };
     }
     async extractText() {
@@ -3336,6 +4225,117 @@ export class BrowserController {
             throw new Error("Browser not started");
         return await this.page.evaluate(() => document.body?.innerText ?? "");
     }
+    async extractScopedRouteCandidates(prefix) {
+        if (!this.page)
+            throw new Error("Browser not started");
+        return await this.page.evaluate(async (rawPrefix) => {
+            const prefix = String(rawPrefix ?? "").replace(/^\/+|\/+$/g, "").toLowerCase();
+            const candidates = [];
+            const seen = new Set();
+            const add = (value) => {
+                if (typeof value !== "string")
+                    return;
+                const trimmed = value.trim();
+                if (!/^[A-Za-z0-9][A-Za-z0-9_-]{1,127}$/.test(trimmed))
+                    return;
+                if (seen.has(trimmed))
+                    return;
+                seen.add(trimmed);
+                candidates.push(trimmed);
+            };
+            const pathSegments = (href) => {
+                try {
+                    return new URL(href, location.origin).pathname.split("/").filter(Boolean);
+                }
+                catch {
+                    return [];
+                }
+            };
+            for (const anchor of Array.from(document.querySelectorAll("a[href]"))) {
+                const segs = pathSegments(anchor.getAttribute("href") ?? "");
+                if ((segs[0] ?? "").toLowerCase() === prefix)
+                    add(segs[1]);
+            }
+            const walk = (value) => {
+                if (Array.isArray(value)) {
+                    for (const item of value)
+                        walk(item);
+                    return;
+                }
+                if (value === null || typeof value !== "object")
+                    return;
+                const record = value;
+                const preferredKeys = prefix === "p" || prefix.startsWith("project")
+                    ? ["slug", "projectSlug", "currentProjectSlug", "lastViewedProjectSlug", "id"]
+                    : prefix.startsWith("org") || prefix.startsWith("organization")
+                        ? ["slug", "orgSlug", "organizationSlug", "id"]
+                        : prefix.startsWith("workspace")
+                            ? ["slug", "workspaceSlug", "id"]
+                            : ["slug", "id"];
+                for (const key of preferredKeys)
+                    add(record[key]);
+                for (const item of Object.values(record))
+                    walk(item);
+            };
+            const inspectJsonText = (text) => {
+                try {
+                    walk(JSON.parse(text));
+                }
+                catch {
+                    // Ignore non-JSON storage/API payloads.
+                }
+            };
+            try {
+                for (let i = 0; i < localStorage.length; i += 1) {
+                    const key = localStorage.key(i);
+                    if (key !== null)
+                        inspectJsonText(localStorage.getItem(key) ?? "");
+                }
+                for (let i = 0; i < sessionStorage.length; i += 1) {
+                    const key = sessionStorage.key(i);
+                    if (key !== null)
+                        inspectJsonText(sessionStorage.getItem(key) ?? "");
+                }
+            }
+            catch {
+                // Storage can be blocked in hardened contexts; DOM/API probes are enough.
+            }
+            const likelyListApi = (url) => {
+                const lower = url.toLowerCase();
+                if (!lower.includes("api"))
+                    return false;
+                if (prefix === "p" || prefix.startsWith("project"))
+                    return /projects?[\w.-]*list|list[\w.-]*projects?/.test(lower);
+                if (prefix.startsWith("org") || prefix.startsWith("organization"))
+                    return /organi[sz]ations?[\w.-]*list|orgs?[\w.-]*list|list[\w.-]*(orgs?|organi[sz]ations?)/.test(lower);
+                if (prefix.startsWith("workspace"))
+                    return /workspaces?[\w.-]*list|list[\w.-]*workspaces?/.test(lower);
+                return /list/.test(lower);
+            };
+            const urls = Array.from(new Set(performance
+                .getEntriesByType("resource")
+                .map((entry) => entry.name)
+                .filter(likelyListApi))).slice(-8);
+            for (const url of urls) {
+                try {
+                    const controller = new AbortController();
+                    const timeout = window.setTimeout(() => controller.abort(), 1_500);
+                    const res = await fetch(url, {
+                        credentials: "include",
+                        signal: controller.signal,
+                    });
+                    window.clearTimeout(timeout);
+                    if (!res.ok)
+                        continue;
+                    inspectJsonText(await res.text());
+                }
+                catch {
+                    // Best-effort only; resolver falls back to text/href matching.
+                }
+            }
+            return candidates.slice(0, 20);
+        }, prefix);
+    }
     // Discrete strings an API key might occupy — for credential
     // extraction. Gathered so a key is read WHOLE and un-glued from its
     // neighbours: extractText() concatenates the whole <body>, which
@@ -3984,31 +4984,39 @@ export class BrowserController {
     async waitForAuthWidgetHydration(timeoutMs = 8_000) {
         if (!this.page)
             return;
+        const authWidgetHydrationProbe = String.raw `(() => {
+      const vis = (el) => {
+        const r = el.getBoundingClientRect();
+        return r.width > 0 && r.height > 0;
+      };
+      const anyVis = (sel) =>
+        Array.from(document.querySelectorAll(sel)).some(vis);
+      const hasAuthInput = anyVis(
+        'input[type="email"],input[type="password"],input[name="email" i],input[name="password" i]',
+      );
+      let hasAuthButton = false;
+      const re = /\b(sign\s?up|continue with|log ?in with|with google|with github|with sso|create account)\b/i;
+      for (const el of Array.from(
+        document.querySelectorAll('button,a[href],[role="button"]'),
+      )) {
+        if (!vis(el)) continue;
+        if (re.test((el.textContent ?? "").trim())) {
+          hasAuthButton = true;
+          break;
+        }
+      }
+      const spinnerVisible = anyVis(
+        '[role="progressbar"],[aria-busy="true"],[class*="spin" i],[class*="loading" i],[class*="loader" i],.ant-spin,.MuiCircularProgress-root',
+      );
+      return { hasAuth: hasAuthInput || hasAuthButton, spinnerVisible };
+    })()`;
         const deadline = Date.now() + timeoutMs;
         while (Date.now() < deadline) {
             try {
-                const state = await this.page.evaluate(() => {
-                    const vis = (el) => {
-                        const r = el.getBoundingClientRect();
-                        return r.width > 0 && r.height > 0;
-                    };
-                    const anyVis = (sel) => Array.from(document.querySelectorAll(sel)).some(vis);
-                    // Auth signal: a real form input or a recognizable provider /
-                    // signup affordance.
-                    const hasAuthInput = anyVis('input[type="email"],input[type="password"],input[name="email" i],input[name="password" i]');
-                    let hasAuthButton = false;
-                    const re = /\b(sign\s?up|continue with|log ?in with|with google|with github|with sso|create account)\b/i;
-                    for (const el of Array.from(document.querySelectorAll('button,a[href],[role="button"]'))) {
-                        if (!vis(el))
-                            continue;
-                        if (re.test((el.textContent ?? "").trim())) {
-                            hasAuthButton = true;
-                            break;
-                        }
-                    }
-                    const spinnerVisible = anyVis('[role="progressbar"],[aria-busy="true"],[class*="spin" i],[class*="loading" i],[class*="loader" i],.ant-spin,.MuiCircularProgress-root');
-                    return { hasAuth: hasAuthInput || hasAuthButton, spinnerVisible };
-                });
+                const state = (await Promise.race([
+                    this.page.evaluate(authWidgetHydrationProbe),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("auth widget probe timed out")), 1_500)),
+                ]));
                 // Done the moment an auth signal appears, or once nothing is
                 // spinning anymore (no point waiting on a page that simply has
                 // no auth widget — a true OAuth-less/blank page bails honestly).
@@ -4037,20 +5045,23 @@ export class BrowserController {
         const deadline = Date.now() + timeoutMs;
         while (Date.now() < deadline) {
             try {
-                const count = await this.page.evaluate((min) => {
-                    const sels = 'input,textarea,select,button,a[href],[role="button"],[role="menuitem"],[role="option"]';
-                    const nodes = Array.from(document.querySelectorAll(sels));
-                    let visible = 0;
-                    for (const n of nodes) {
-                        const el = n;
-                        const r = el.getBoundingClientRect();
-                        if (r.width >= 2 && r.height >= 2)
-                            visible++;
-                        if (visible >= min)
-                            return visible;
-                    }
-                    return visible;
-                }, minElements);
+                const count = await Promise.race([
+                    this.page.evaluate((min) => {
+                        const sels = 'input,textarea,select,button,a[href],[role="button"],[role="menuitem"],[role="option"]';
+                        const nodes = Array.from(document.querySelectorAll(sels));
+                        let visible = 0;
+                        for (const n of nodes) {
+                            const el = n;
+                            const r = el.getBoundingClientRect();
+                            if (r.width >= 2 && r.height >= 2)
+                                visible++;
+                            if (visible >= min)
+                                return visible;
+                        }
+                        return visible;
+                    }, minElements),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("interactive DOM probe timed out")), 1_500)),
+                ]);
                 if (count >= minElements)
                     return;
             }
@@ -4448,9 +5459,22 @@ export class BrowserController {
             const selectorFor = (el) => {
                 const tag = el.tagName.toLowerCase();
                 let base;
+                const testId = el.getAttribute("data-testid") ??
+                    el.getAttribute("data-test-id") ??
+                    el.getAttribute("data-test") ??
+                    el.getAttribute("data-cy") ??
+                    el.getAttribute("data-qa");
                 const id = el.getAttribute("id");
                 const name = el.getAttribute("name");
-                if (id !== null && /^[A-Za-z][\w-]*$/.test(id)) {
+                if (testId !== null && testId.length > 0) {
+                    const attr = el.hasAttribute("data-testid") ? "data-testid" :
+                        el.hasAttribute("data-test-id") ? "data-test-id" :
+                            el.hasAttribute("data-test") ? "data-test" :
+                                el.hasAttribute("data-cy") ? "data-cy" :
+                                    "data-qa";
+                    base = `[${attr}="${CSS.escape(testId)}"]`;
+                }
+                else if (id !== null && /^[A-Za-z][\w-]*$/.test(id)) {
                     base = `#${id}`;
                 }
                 else if (name !== null && name.length > 0) {
@@ -5210,6 +6234,53 @@ export class BrowserController {
         if (!this.page)
             throw new Error("Browser not started");
         if (provider === "github") {
+            // GitHub App install flow can include an account target chooser before
+            // the Install/Authorize screen:
+            //   /apps/<app>/installations/select_target
+            // It renders account/org cards as links/buttons, not as an approve
+            // button. Advance exactly one visible target and let the caller's
+            // consent loop re-classify the next GitHub page.
+            if (/\/apps\/[^/]+\/installations\/select_target\b/.test(new URL(this.page.url()).pathname)) {
+                const startUrl = this.page.url();
+                const clicked = await this.page
+                    .evaluate(() => {
+                    const visible = (el) => {
+                        const r = el.getBoundingClientRect();
+                        const s = window.getComputedStyle(el);
+                        return (r.width > 2 &&
+                            r.height > 2 &&
+                            s.display !== "none" &&
+                            s.visibility !== "hidden" &&
+                            parseFloat(s.opacity || "1") > 0.01);
+                    };
+                    const bad = /\b(settings|marketplace|learn more|cancel|skip|back|terms|privacy)\b/i;
+                    const candidates = Array.from(document.querySelectorAll('a[href], button, [role="button"], [role="link"]')).filter((el) => visible(el));
+                    const byHref = candidates.find((el) => {
+                        const href = el instanceof HTMLAnchorElement ? el.href : el.getAttribute("href") ?? "";
+                        return /\/installations\/(?:new|permissions)\b/.test(href);
+                    });
+                    const target = byHref ??
+                        candidates.find((el) => {
+                            const text = (el.textContent ?? "").replace(/\s+/g, " ").trim();
+                            if (text.length === 0 || text.length > 80 || bad.test(text))
+                                return false;
+                            return true;
+                        });
+                    if (target === undefined)
+                        return false;
+                    target.click();
+                    return true;
+                })
+                    .catch(() => false);
+                if (clicked) {
+                    const advanced = await this.page
+                        .waitForFunction((s) => window.location.href !== s, startUrl, { timeout: 8000 })
+                        .then(() => true)
+                        .catch(() => false);
+                    if (advanced)
+                        return true;
+                }
+            }
             // GitHub consent screen variants:
             //   Classic OAuth: "Authorize <app>"
             //   GitHub App (install + auth): "Authorize <app>", "Install",
@@ -5468,6 +6539,8 @@ export class BrowserController {
             catch {
                 /* already gone */
             }
+            if (this.childChrome.pid !== undefined)
+                selfManagedChromePids.delete(this.childChrome.pid);
             this.childChrome = null;
         }
         // …and context.close() doesn't always kill the browser: headed Chrome
@@ -5563,8 +6636,10 @@ export function pickSubmitButtonIndex(texts) {
 // `checkRequiredAgreementBoxes`. The evaluate runs in the page realm and
 // can't import, so the same two regexes are inlined there verbatim —
 // keep them BYTE-IDENTICAL with these.
-const AGREEMENT_TEXT_RE = /terms|tos\b|privacy|consent|policy|i agree|agree to|acknowledge|gdpr/i;
+const AGREEMENT_TEXT_RE = /terms|tos\b|privacy|consent|policy|i agree|agree to|acknowledge|gdpr|age|18\+|18 years|certif/i;
 const MARKETING_TEXT_RE = /newsletter|updates|offers|product tips|marketing|promotional|receive emails|opt[- ]?in to|subscribe/i;
+const SAFE_SIGNUP_CHOICE_TEXT_RE = /digital products?|saas|software|developer tools?|apis?|mobile apps?|data|analytics/i;
+const RISKY_SIGNUP_CHOICE_TEXT_RE = /gambling|financial services?|physical products?|marketplace|human services?|adult|weapons?|medical|restricted|crypto|payments?|banking/i;
 // True when a checkbox's associated text reads as a REQUIRED agreement
 // (terms/privacy/consent) and NOT as a marketing/newsletter opt-in.
 //
@@ -5578,6 +6653,15 @@ const MARKETING_TEXT_RE = /newsletter|updates|offers|product tips|marketing|prom
 export function isAgreementCheckboxText(text) {
     return AGREEMENT_TEXT_RE.test(text) && !MARKETING_TEXT_RE.test(text);
 }
+// True when a required signup-category choice is a low-risk default the bot can
+// select deterministically. Keep byte-identical with the in-page regexes in
+// `checkRequiredSignupChoiceBoxes`.
+export function isSafeSignupChoiceText(text) {
+    return (SAFE_SIGNUP_CHOICE_TEXT_RE.test(text) &&
+        !RISKY_SIGNUP_CHOICE_TEXT_RE.test(text) &&
+        !AGREEMENT_TEXT_RE.test(text) &&
+        !MARKETING_TEXT_RE.test(text));
+}
 // Parse a UNIVERSAL_BOT_PROXY_URL — e.g. "http://user:pass@host:8080" or
 // "socks5://host:1080" — into Playwright's proxy option shape. Playwright
 // wants credentials separate from `server`, so we split them out and