@trusty-squire/mcp 0.6.15-rc.9 → 0.7.0

package/dist/bot/browser.js

@@ -610,33 +610,34 @@ export class BrowserController {
         }
         // Humanized typing:
         //   - Click into the field first (moves mouse, generates focus event)
-        //   - pressSequentially with per-character delay 40-110ms baseline
-        //   - Inject occasional "thinking" pauses 200-600ms every ~5-12 chars
+        //   - pressSequentially focuses ONCE and types each char with a
+        //     per-key delay. Page-driven focus changes between characters
+        //     (multi-input OTP forms, auto-advance fields) are honoured —
+        //     the next char goes to whatever has focus when it fires.
         //
         // page.fill() bypasses keydown/keypress/input events entirely — it
         // sets value via JS. That's a giant red flag to behavior scoring.
         // pressSequentially emits real key events so the page sees a normal
         // typing pattern.
+        //
+        // rc.29 — the prior implementation looped `locator.pressSequentially(
+        // ch)` per character, which RE-FOCUSED the locator on every call.
+        // For multi-input OTP forms (Porter, Koyeb / WorkOS: 8 inputs each
+        // maxlength=1), every character landed in the FIRST input and got
+        // discarded after char 1. Switching to a single pressSequentially
+        // call lets the browser's auto-advance handler move focus naturally.
         await this.humanClick(selector);
-        // Clear any prefilled value (browser autofill, etc.) before typing.
         const locator = this.page.locator(selector);
-        await locator.fill("");
-        let typedSinceLastPause = 0;
-        let nextPauseAt = rand(5, 12);
-        for (const ch of text) {
-            // Per-char delay. Real typing is bursty; we use a slightly
-            // skewed distribution that occasionally lands a fast char and
-            // occasionally a slow one.
-            await locator.pressSequentially(ch, { delay: rand(40, 110) });
-            typedSinceLastPause += 1;
-            if (typedSinceLastPause >= nextPauseAt) {
-                // Brief "thinking" pause — looking at the keyboard, reading
-                // the label, etc.
-                await this.sleep(rand(180, 600));
-                typedSinceLastPause = 0;
-                nextPauseAt = rand(5, 12);
-            }
-        }
+        // Clear any prefilled value before typing. Only meaningful for
+        // single-input fields; multi-input OTP forms ignore this since
+        // each box is its own input.
+        await locator.fill("").catch(() => { });
+        // Per-key delay matches the prior bursty distribution. The
+        // periodic "thinking pause" the prior loop applied is folded into
+        // the delay variability — pressSequentially has no built-in pause
+        // hook, and over-engineering it added zero observable behavior-
+        // score improvement.
+        await locator.pressSequentially(text, { delay: rand(40, 110) });
     }
     async click(selector) {
         if (!this.page)
@@ -1031,16 +1032,28 @@ export class BrowserController {
     //
     // Tries option-selector patterns in priority order — each tier
     // targets one combobox-library convention. The text-based final
-    // tier catches libraries that ship NO ARIA roles at all (Sentry's
-    // permissions picker is the canonical case: it uses `<div>`s with
-    // plain text for options and pure JS click handlers).
+    // tier catches libraries that ship NO ARIA roles at all.
     //
     //   1. [role=option]            — Radix, Headless UI, React Aria, cmdk
     //   2. [role=menuitem]          — ARIA menu pattern (libs that model
     //                                 a dropdown as a menu)
-    //   3. [role=listbox] li        — listbox container without role
+    //   3. [role=menuitemradio]     — react-select's per-row permission
+    //                                 picker shape (rc.15 — Sentry's
+    //                                 token-create grid). Identical shape
+    //                                 to menuitem for selection purposes,
+    //                                 distinct role string. Without this
+    //                                 tier Sentry's "Team permission =
+    //                                 Admin" never resolves and the loop
+    //                                 burns the post-verify budget.
+    //   4. [id^="react-select-"]    — defense-in-depth for any react-
+    //                                 select instance that drops the
+    //                                 role attribute. The id prefix is
+    //                                 baked into the library and is the
+    //                                 most stable signal short of the
+    //                                 role.
+    //   5. [role=listbox] li        — listbox container without role
     //                                 attribute on its children
-    //   4. text-based (matcher only) — after the trigger click, any newly-
+    //   6. text-based (matcher only) — after the trigger click, any newly-
     //                                 visible element whose text matches
     //                                 the planner-supplied label is
     //                                 almost certainly the option. Only
@@ -1055,6 +1068,8 @@ export class BrowserController {
         const patternSelectors = [
             '[role="option"]:visible',
             '[role="menuitem"]:visible',
+            '[role="menuitemradio"]:visible',
+            '[id^="react-select-"][role*="menu"]:visible',
             '[role="listbox"]:visible li:visible',
         ];
         const triedDescriptors = [];
@@ -1142,10 +1157,25 @@ export class BrowserController {
         // 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.
+        //
+        // rc.16 — when the poll times out we now THROW instead of silently
+        // proceeding to a no-op click. PostHog's "Create key" submit stays
+        // aria-disabled until both an org/project access option AND a
+        // scopes preset are set; humanClick previously fired a mouse
+        // click at the disabled button (which does nothing), the page
+        // didn't change, and the post-verify no-progress detector
+        // re-planned generically. The planner kept retrying click on the
+        // same button because nothing in its hint named the specific
+        // root cause ("button is disabled — find what precondition is
+        // missing"). Throwing surfaces the disabled state explicitly to
+        // the planner via the executor's existing catch handler, so the
+        // next round's reason includes "click failed: target is
+        // aria-disabled" and the planner pivots to checking other fields.
         {
             const deadline = Date.now() + 6000;
+            let isDisabled = false;
             while (Date.now() < deadline) {
-                const isDisabled = await locator
+                isDisabled = await locator
                     .first()
                     .evaluate((el) => {
                     if (el instanceof HTMLButtonElement || el instanceof HTMLInputElement) {
@@ -1160,6 +1190,13 @@ export class BrowserController {
                     break;
                 await this.sleep(150);
             }
+            if (isDisabled) {
+                throw new Error("target is disabled (HTML disabled or aria-disabled=true) after 6s — " +
+                    "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 " +
+                    "different action that fills the missing field first.");
+            }
         }
         // Scroll the element into the viewport BEFORE measuring it. A
         // humanized click is a raw page.mouse.click(x, y) at viewport
@@ -1539,6 +1576,105 @@ export class BrowserController {
             return { variant: "unknown", challengeRendered: false };
         }
     }
+    // Tier 3 captcha-solver support — extract the reCAPTCHA sitekey
+    // from the page so a third-party solver can submit it. Returns
+    // null when no v2 widget is present (Tier 3 only handles v2;
+    // Turnstile + reCAPTCHA v3 are scoring-based and solvers don't
+    // help). Reads from the standard places sites declare it:
+    //   1. <div class="g-recaptcha" data-sitekey="...">
+    //   2. <iframe src="...?k=SITEKEY&...">  (api2/anchor frame)
+    //   3. <script>...sitekey: '...'...</script> via window globals
+    async extractRecaptchaSitekey() {
+        if (!this.page)
+            throw new Error("Browser not started");
+        try {
+            const sitekey = await this.page.evaluate(() => {
+                // 1. div[data-sitekey] — the standard reCAPTCHA v2 anchor.
+                const div = document.querySelector("[data-sitekey], div.g-recaptcha[data-sitekey]");
+                if (div !== null) {
+                    const k = div.getAttribute("data-sitekey");
+                    if (k !== null && k.length > 10)
+                        return k;
+                }
+                // 2. The api2 iframe src carries ?k=SITEKEY.
+                const iframes = Array.from(document.querySelectorAll('iframe[src*="recaptcha/api2"], iframe[src*="recaptcha/enterprise"]'));
+                for (const ifr of iframes) {
+                    const url = new URL(ifr.src);
+                    const k = url.searchParams.get("k");
+                    if (k !== null && k.length > 10)
+                        return k;
+                }
+                return null;
+            });
+            return sitekey;
+        }
+        catch {
+            return null;
+        }
+    }
+    // Inject a 2Captcha-resolved token into the page's hidden
+    // g-recaptcha-response textarea AND fire any onSuccess callback
+    // the widget registered with grecaptcha.render(). Without firing
+    // the callback the page often doesn't "see" the token even though
+    // the DOM input is populated.
+    //
+    // Returns true on success, false if no recaptcha widget present.
+    async injectRecaptchaToken(token) {
+        if (!this.page)
+            throw new Error("Browser not started");
+        try {
+            const injected = await this.page.evaluate((tok) => {
+                // 1. Populate every g-recaptcha-response textarea on the page
+                //    (some pages render multiple widgets).
+                const inputs = Array.from(document.querySelectorAll('textarea[name="g-recaptcha-response"], textarea[id^="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 }));
+                }
+                // 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
+                //    so a defensive walk is the only reliable way.
+                try {
+                    const cfg = window.___grecaptcha_cfg;
+                    if (cfg !== undefined && cfg.clients !== undefined) {
+                        const fire = (obj) => {
+                            if (obj === null || typeof obj !== "object")
+                                return;
+                            for (const [, v] of Object.entries(obj)) {
+                                if (v === null || typeof v !== "object")
+                                    continue;
+                                if ("callback" in v && typeof v.callback === "function") {
+                                    try {
+                                        v.callback(tok);
+                                    }
+                                    catch {
+                                        // best-effort — at worst we miss the callback,
+                                        // but the DOM input is populated which most
+                                        // sites' server-side validation reads.
+                                    }
+                                }
+                                fire(v);
+                            }
+                        };
+                        fire(cfg.clients);
+                    }
+                }
+                catch {
+                    // grecaptcha not on window — page may use a wrapper
+                    // (Stytch, Clerk). DOM injection is still in place.
+                }
+                return true;
+            }, token);
+            return injected;
+        }
+        catch {
+            return false;
+        }
+    }
     // Small mouse wiggle near the current position. Used during prewarm
     // so the page sees pointer events before we navigate away.
     async jitterMouse() {
@@ -1711,6 +1847,359 @@ export class BrowserController {
             return out;
         });
     }
+    // DOM-proximity labeled credential candidates. Walks every visible
+    // input/code/text element looking for credential-shape strings,
+    // pairs each one with its nearest credential-label text in the DOM
+    // tree, and returns the labeled tuples for the multi-cred extractor
+    // to fold into the credentials Record.
+    //
+    // Complements the Phase E planner-quoted extractor — when the
+    // planner's prose doesn't explicitly label values (multi-cred page
+    // where the planner missed one), this DOM-grounded pass picks them
+    // up via the visible labels the page itself renders.
+    //
+    // Returns shape:
+    //   { value: "<credential-shape string>",
+    //     label: "<the closest matching label text>" | null,
+    //     isMasked: true if the value looks like a redacted display
+    //               (••••, ****, contains "•" or runs of "*") }
+    //
+    // The caller (agent.ts extractAllLabeledCandidates path) maps label
+    // text to canonical credential keys using the same vocabulary the
+    // Phase E parser uses.
+    async extractLabeledCredentialCandidates() {
+        if (!this.page)
+            throw new Error("Browser not started");
+        return await this.page.evaluate(() => {
+            const LABEL_PHRASES = [
+                // Generic
+                "api key", "api token", "api secret", "secret key", "access key",
+                "access token", "auth token", "bearer token", "personal access token",
+                "client id", "client secret", "client key",
+                // Cloudinary
+                "cloud name", "cloudname",
+                // Algolia
+                "application id", "app id", "admin api key", "search api key",
+                "monitoring api key", "search-only api key",
+                // Twilio
+                "account sid", "auth token",
+                // Stripe
+                "publishable key", "secret key",
+                // AWS
+                "access key id", "secret access key",
+                // OAuth1
+                "consumer key", "consumer secret", "access token secret",
+                // Misc
+                "project api key", "personal api key", "organization id", "org id",
+                "app key", "app secret",
+            ];
+            const isVisible = (el) => {
+                const r = el.getBoundingClientRect();
+                return r.width > 2 && r.height > 2;
+            };
+            const isCredentialShape = (s) => {
+                // Reasonable credential length range
+                if (s.length < 6 || s.length > 256)
+                    return false;
+                // Reject pure prose (spaces inside)
+                if (/\s/.test(s))
+                    return false;
+                // Must include some entropy markers: digit + letter combo OR
+                // a credential prefix like sk_/pk_/api_/ etc.
+                const hasDigit = /\d/.test(s);
+                const hasLetter = /[A-Za-z]/.test(s);
+                if (!hasDigit && !hasLetter)
+                    return false;
+                // Reject pure URL fragments
+                if (/^https?:\/\//i.test(s))
+                    return false;
+                // Reject simple words / capitalized phrases
+                if (/^[A-Za-z]+$/.test(s) && s.length < 12)
+                    return false;
+                return true;
+            };
+            const isMaskedShape = (s) => {
+                // Common mask glyphs: bullet, asterisk, em-dash spam
+                if (/[•●⬤]{3,}/.test(s))
+                    return true;
+                if (/\*{4,}/.test(s))
+                    return true;
+                if (/^[•*]+$/.test(s))
+                    return true;
+                return false;
+            };
+            // Compute element-center coords for proximity matching.
+            const centerOf = (el) => {
+                const r = el.getBoundingClientRect();
+                return { x: r.left + r.width / 2, y: r.top + r.height / 2 };
+            };
+            const labelHits = [];
+            document.querySelectorAll("body *").forEach((el) => {
+                if (el.tagName === "SCRIPT" || el.tagName === "STYLE")
+                    return;
+                if (!isVisible(el))
+                    return;
+                // Only consider DIRECT text content — child element text gets
+                // claimed by THOSE elements' own label scans.
+                let direct = "";
+                el.childNodes.forEach((n) => {
+                    if (n.nodeType === Node.TEXT_NODE)
+                        direct += n.textContent ?? "";
+                });
+                direct = direct.trim().toLowerCase();
+                if (direct.length === 0 || direct.length > 100)
+                    return;
+                for (const phrase of LABEL_PHRASES) {
+                    if (direct.includes(phrase)) {
+                        const c = centerOf(el);
+                        labelHits.push({ phrase, x: c.x, y: c.y, el });
+                        break; // one label per element is enough
+                    }
+                }
+            });
+            // Detect reveal buttons (eye / show / unmask icons) — any visible
+            // button or [role=button] / svg whose aria-label / title / text
+            // matches the reveal vocabulary. We only check WHETHER one exists
+            // near a candidate; the clicker (revealMaskedCredentials below)
+            // does the actual click pass.
+            const REVEAL_PATTERN = /\b(?:reveal|show|unmask|view|toggle|copy)\b/i;
+            const revealButtons = [];
+            document
+                .querySelectorAll('button, [role="button"], a, [aria-label], [title]')
+                .forEach((el) => {
+                if (!isVisible(el))
+                    return;
+                const hay = `${el.textContent ?? ""} ${el.getAttribute("aria-label") ?? ""} ${el.getAttribute("title") ?? ""}`;
+                if (!REVEAL_PATTERN.test(hay))
+                    return;
+                const c = centerOf(el);
+                revealButtons.push({ x: c.x, y: c.y, el });
+            });
+            // For each candidate, find nearest label by Euclidean distance.
+            const findNearestLabel = (x, y) => {
+                let best = null;
+                for (const lh of labelHits) {
+                    const dx = lh.x - x;
+                    const dy = lh.y - y;
+                    const d = Math.sqrt(dx * dx + dy * dy);
+                    // Conservative cap — labels more than 400px away from the
+                    // value aren't visually grouped with it. Roughly: a typical
+                    // table-row width.
+                    if (d > 400)
+                        continue;
+                    if (best === null || d < best.d)
+                        best = { phrase: lh.phrase, d };
+                }
+                return best?.phrase ?? null;
+            };
+            const hasNearbyReveal = (x, y) => {
+                for (const rb of revealButtons) {
+                    const dx = rb.x - x;
+                    const dy = rb.y - y;
+                    // Reveal/copy buttons are usually right next to the value —
+                    // 200px is generous.
+                    if (Math.sqrt(dx * dx + dy * dy) < 200)
+                        return true;
+                }
+                return false;
+            };
+            const seen = new Set();
+            const out = [];
+            const pushCandidate = (value, el) => {
+                const trimmed = value.trim();
+                if (trimmed.length === 0)
+                    return;
+                const masked = isMaskedShape(trimmed);
+                if (!masked && !isCredentialShape(trimmed))
+                    return;
+                if (seen.has(trimmed))
+                    return;
+                seen.add(trimmed);
+                const c = centerOf(el);
+                const label = findNearestLabel(c.x, c.y);
+                const hasReveal = masked ? hasNearbyReveal(c.x, c.y) : false;
+                out.push({
+                    value: trimmed,
+                    label,
+                    isMasked: masked,
+                    hasRevealButton: hasReveal,
+                });
+            };
+            // 1. <input> / <textarea> values (visible only).
+            document.querySelectorAll("input, textarea").forEach((el) => {
+                if (el instanceof HTMLInputElement &&
+                    (el.type === "hidden" || el.type === "password"))
+                    return;
+                if (!isVisible(el))
+                    return;
+                const value = el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement
+                    ? el.value
+                    : "";
+                if (value.length > 0)
+                    pushCandidate(value, el);
+            });
+            // 2. Direct text content in visible leaf elements.
+            document.querySelectorAll("body *").forEach((el) => {
+                if (el.tagName === "SCRIPT" || el.tagName === "STYLE")
+                    return;
+                if (!isVisible(el))
+                    return;
+                let direct = "";
+                el.childNodes.forEach((n) => {
+                    if (n.nodeType === Node.TEXT_NODE)
+                        direct += n.textContent ?? "";
+                });
+                direct = direct.trim();
+                if (direct.length === 0 || direct.length > 256)
+                    return;
+                pushCandidate(direct, el);
+            });
+            // 3. Structural containers (code/pre/kbd) where the credential
+            //    is interpolated through nested spans.
+            document
+                .querySelectorAll('code, pre, kbd, samp, [role="textbox"]')
+                .forEach((el) => {
+                if (!isVisible(el))
+                    return;
+                const full = (el.textContent ?? "").trim();
+                if (full.length === 0 || full.length > 256)
+                    return;
+                pushCandidate(full, el);
+            });
+            return out;
+        });
+    }
+    // Click every visible "Reveal" / "Show" / "Eye" / "Copy" button on
+    // the page that sits next to a masked credential display. Used as a
+    // pre-extract pass for services like Cloudinary that hide the
+    // api_secret behind a click-to-reveal icon. Best-effort: failures
+    // don't throw; subsequent extract pass tries whatever surfaced.
+    // Returns the number of buttons successfully clicked.
+    async revealMaskedCredentials() {
+        if (this.page === null)
+            throw new Error("Browser not started");
+        const page = this.page;
+        const probe = await page.evaluate(() => {
+            const isVisible = (el) => {
+                const r = el.getBoundingClientRect();
+                return r.width > 2 && r.height > 2;
+            };
+            // Walk up to the nearest "row-like" ancestor — a <tr>, a <li>,
+            // or any container ≤ 800px wide with limited height. Cloudinary,
+            // Algolia, Twilio all use table rows; clicking the reveal in
+            // ROW X must populate the value in ROW X, not some neighbor row.
+            const rowAncestor = (el) => {
+                let cur = el;
+                for (let i = 0; i < 8 && cur !== null; i++) {
+                    if (cur.tagName === "TR" || cur.tagName === "LI")
+                        return cur;
+                    const r = cur.getBoundingClientRect();
+                    if (r.width > 200 && r.width < 900 && r.height < 200)
+                        return cur;
+                    cur = cur.parentElement;
+                }
+                return el.parentElement;
+            };
+            const masked = [];
+            document.querySelectorAll("body *").forEach((el) => {
+                if (el.tagName === "SCRIPT" || el.tagName === "STYLE")
+                    return;
+                if (!isVisible(el))
+                    return;
+                let direct = "";
+                el.childNodes.forEach((n) => {
+                    if (n.nodeType === Node.TEXT_NODE)
+                        direct += n.textContent ?? "";
+                });
+                const t = direct.trim();
+                if (t.length < 3 || t.length > 100)
+                    return;
+                if (!/[•●⬤*]{3,}/.test(t) && !/^[•*]+$/.test(t))
+                    return;
+                masked.push({ el, row: rowAncestor(el) });
+            });
+            document
+                .querySelectorAll('input[type="password"]')
+                .forEach((el) => {
+                if (!isVisible(el))
+                    return;
+                masked.push({ el, row: rowAncestor(el) });
+            });
+            if (masked.length === 0) {
+                return { selectors: [], diagnostic: ["no_masked_displays"] };
+            }
+            // 2. Classify candidate buttons. Prefer SHOW/REVEAL/EYE; fall
+            //    back to COPY only when no show button exists in the row.
+            //    (Copy generally puts value in clipboard, not in DOM —
+            //    which our extractor can't read in headless.)
+            const SHOW_PATTERN = /\b(?:reveal|show|unmask|view|toggle|eye)\b/i;
+            const COPY_PATTERN = /\bcopy\b/i;
+            const collectButtonsInRow = (row) => {
+                const showBtns = [];
+                const copyBtns = [];
+                if (row === null)
+                    return { showBtns, copyBtns };
+                row
+                    .querySelectorAll('button, [role="button"], a[role="button"], [aria-label], [title]')
+                    .forEach((el) => {
+                    if (!isVisible(el))
+                        return;
+                    const hay = `${el.textContent ?? ""} ${el.getAttribute("aria-label") ?? ""} ${el.getAttribute("title") ?? ""} ${el.className ?? ""}`;
+                    if (SHOW_PATTERN.test(hay))
+                        showBtns.push(el);
+                    else if (COPY_PATTERN.test(hay))
+                        copyBtns.push(el);
+                });
+                return { showBtns, copyBtns };
+            };
+            const selectorFor = (el) => {
+                const tag = el.tagName.toLowerCase();
+                const all = Array.from(document.querySelectorAll(tag));
+                const idx = all.indexOf(el);
+                return `${tag}:nth-of-type(${idx + 1})`;
+            };
+            const selectors = [];
+            const diagnostic = [];
+            const usedRows = new Set();
+            for (const m of masked) {
+                if (m.row === null)
+                    continue;
+                if (usedRows.has(m.row))
+                    continue;
+                usedRows.add(m.row);
+                const { showBtns, copyBtns } = collectButtonsInRow(m.row);
+                if (showBtns.length > 0) {
+                    const btn = showBtns[0];
+                    const sel = selectorFor(btn);
+                    selectors.push(sel);
+                    const label = (btn.textContent ?? btn.getAttribute("aria-label") ?? btn.getAttribute("title") ?? "").trim().slice(0, 40);
+                    diagnostic.push(`row→show:"${label}"→${sel}`);
+                }
+                else if (copyBtns.length > 0) {
+                    diagnostic.push(`row→copy_only_no_show_button (copy='${copyBtns.length} found' — skipped, would only populate clipboard not DOM)`);
+                }
+                else {
+                    diagnostic.push("row→no_buttons_found");
+                }
+            }
+            return { selectors, diagnostic };
+        });
+        let clicked = 0;
+        for (const sel of probe.selectors) {
+            try {
+                await page.locator(sel).first().click({ timeout: 1500 });
+                clicked += 1;
+                // Reveal click often triggers a fetch (Cloudinary returns the
+                // secret over an XHR before populating the DOM). Wait longer
+                // than the previous 150ms.
+                await this.sleep(800);
+            }
+            catch {
+                // Click failed — best-effort.
+            }
+        }
+        return { clicked, diagnostic: probe.diagnostic };
+    }
     async extractCredentialCandidates() {
         if (!this.page)
             throw new Error("Browser not started");
@@ -1799,17 +2288,58 @@ export class BrowserController {
         // redirect to the real page. Without this, the bot snapshots a
         // 2-element interstitial inventory and bails.
         await this.waitForAntiBotInterstitialToClear(timeoutMs);
+        // rc.33 — extended the element-wait selector to match the broader
+        // inventory walk added in rc.26 (menuitem/option/combobox plus
+        // anchors). Porter and Koyeb's API-tokens pages are nested SPAs
+        // that initially render with NO <input>/<button> — just <a> and
+        // role=button divs. The old selector timed out at 15s on those
+        // pages, the planner saw an empty inventory, and the post-verify
+        // loop burned rounds clicking nothing.
         try {
-            await this.page.waitForSelector("input, button", {
-                state: "visible",
-                timeout: timeoutMs,
-            });
+            await this.page.waitForSelector('input, button, textarea, select, a[href], [role="button"], [role="menuitem"]', { state: "visible", timeout: timeoutMs });
         }
         catch {
             // No interactive element appeared in time — let the planner run
             // anyway; it fails cleanly rather than hanging.
         }
     }
+    // rc.33 — wait for the DOM to grow past a minimum interactive-
+    // element count, polling every 500ms up to timeoutMs. The
+    // single-element wait in waitForFormReady is fast-path; this is
+    // for SPAs where DOMContentLoaded fires almost immediately but the
+    // React/Vue/Svelte tree takes 5-15s more to actually render. Used
+    // after navigate() in the post-verify loop so the planner doesn't
+    // see a 0-button page that's still rendering. Best-effort —
+    // returns whenever the count is reached OR the timeout elapses.
+    async waitForInteractiveDom(minElements = 5, timeoutMs = 20_000) {
+        if (!this.page)
+            return;
+        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);
+                if (count >= minElements)
+                    return;
+            }
+            catch {
+                // Page may be mid-navigation — try again on the next tick.
+            }
+            await this.sleep(500);
+        }
+    }
     // Find and click an "Accept"-class button to dismiss any visible
     // cookie/consent banner. Returns the clicked button's text when a
     // dismiss fired, or null when no banner / no clickable affordance
@@ -1961,7 +2491,19 @@ export class BrowserController {
         if (!this.page)
             throw new Error("Browser not started");
         const raw = await this.page.evaluate(() => {
-            const SELECTOR = 'input,textarea,select,button,a,[role="button"],[role="checkbox"],[contenteditable=""],[contenteditable="true"]';
+            const SELECTOR = 
+            // rc.26 — added Radix/Headless-UI menu + option items so
+            // dropdown contents (Fireworks "Create API Key" → API Key /
+            // Service Account menu, Sentry's per-row permissions) end up
+            // in the planner's inventory.
+            // rc.35 — added [role="link"] (Google account-chooser cards
+            // are <div role="link" data-identifier="…">), and <label>
+            // (Koyeb's onboarding renders each radio choice as a styled
+            // <label> wrapping a sr-only <input type=radio>; the visible
+            // click target is the label, but the bot's inventory selector
+            // didn't catch labels so the planner had no clickable target
+            // matching the visible button text).
+            'input,textarea,select,button,a,label,[role="button"],[role="link"],[role="checkbox"],[role="menuitem"],[role="menuitemradio"],[role="menuitemcheckbox"],[role="option"],[role="combobox"],[contenteditable=""],[contenteditable="true"]';
             // Collect candidates across the document and every open shadow
             // root. Closed shadow roots are unreachable — accepted.
             const collected = [];