@trusty-squire/mcp 0.9.10 → 0.9.12

package/dist/bot/agent.js

@@ -1121,6 +1121,28 @@ function stripHtmlToText(html) {
         .replace(/\s+/g, " ")
         .toLowerCase();
 }
+// True when a page is a 404 / route-not-found shell. Used to abort the
+// hardcoded keys-URL walk early: when guessed keys paths keep 404ing, this
+// host's routing convention simply isn't in our list, and continuing the
+// ~25-path walk (each a goto + up-to-15s DOM wait) just burns the run budget.
+// MEASURED 2026-06-09: axiom/fathom/loops each hit the FULL walk with every
+// path a 404 and blew the 600s deadline. Matches the three observed shells:
+// title "Not Found" (fathom), body "404 … page you're looking for doesn't
+// exist" (loops), body "404 page not found" (axiom).
+export function looksLike404(title, bodyText) {
+    const hay = `${title} ${bodyText}`.toLowerCase().slice(0, 600);
+    const has404Token = /\b404\b/.test(hay);
+    const notFoundPhrase = /page not found|not found|could ?n[o'’]?t be found|could not be found|does ?n[o'’]?t exist|does not exist|page you[''’]?re looking for/.test(hay);
+    // A bare "404" token, or a clear not-found phrase, is enough — guessed
+    // keys URLs that hit either are dead ends.
+    return has404Token || notFoundPhrase;
+}
+// Pull the <title> text out of a raw HTML string (lowercased work is left to
+// the caller). Empty string when absent. Cheap — no DOM round-trip.
+export function titleFromHtml(html) {
+    const m = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(html);
+    return m?.[1]?.trim() ?? "";
+}
 // Classify a fetched page as a signup form, a login form, or neither.
 //
 // WHY this exists: looksLikeSignupPage() answers "does this page have a
@@ -1715,19 +1737,34 @@ export function detectFormFillIsDashboard(plan) {
         .join(" ")
         .toLowerCase();
     // Billing / payment wall — the planner sees a credit-card / billing
-    // form, which is never a signup form.
+    // form, which is never a signup form. (Checked first: a "free trial"
+    // page that ALSO demands a card is a wall, not a path to signup.)
     const BILLING_WALL = /\b(?:add (?:a )?(?:credit card|payment method)|enter (?:your )?(?:credit card|payment)|billing (?:information|details)|payment information required)\b/;
     if (BILLING_WALL.test(haystack))
         return true;
+    // Negative guard — a LOGIN / SIGN-IN page (pre-auth), or a plan that
+    // proposes navigating TO a signup/trial form, is the OPPOSITE of a
+    // logged-in dashboard. MEASURED 2026-06-09: fathom's planner correctly
+    // said "this is a login page, NOT a signup page; click 'Start a free
+    // trial' to reach the actual signup form" — pivoting to key extraction
+    // there is wrong (we're not authenticated; the key page 404s). The
+    // bot must EXECUTE the planner's click toward signup. Runs before the
+    // ambiguous "not a signup" check below so it can't be swallowed.
+    const REACH_SIGNUP = /\blog[\s-]?in page|sign[\s-]?in page|free trial|start a (?:free )?trial|create an? account|navigate to the (?:actual )?sign-?up/;
+    if (REACH_SIGNUP.test(haystack))
+        return false;
     // Product-creation form — the planner describes creating a
     // database / cluster / instance / deployment / app / project /
     // workspace / service, which is post-signup territory.
     const PRODUCT_CREATION = /\b(?:create(?:s|d)?|creating|provision(?:s|ed|ing)?)\s+(?:(?:the|a|an|new|your|this)\s+){0,3}(?:database|cluster|instance|deployment|app|service|project|workspace|index|environment|tenant)\b/;
     if (PRODUCT_CREATION.test(haystack))
         return true;
-    // Explicit "not a signup" / "logged in" / "dashboard" statements
-    // from the planner.
-    const EXPLICIT = /\b(?:not\s+(?:a\s+)?(?:sign-?up|signup)|already\s+(?:signed[\s-]?in|logged[\s-]?in|authenticated)|logged[\s-]?in (?:dashboard|user))\b/;
+    // Explicit "logged in" / "dashboard" statements from the planner. NB:
+    // bare "not a signup" is deliberately NOT here — it's ambiguous (a
+    // LOGIN page is also "not a signup") and false-pivoted fathom into key
+    // extraction. A genuine dashboard says "already signed in" / "logged-in
+    // dashboard", which the REACH_SIGNUP guard above doesn't touch.
+    const EXPLICIT = /\b(?:already\s+(?:signed[\s-]?in|logged[\s-]?in|authenticated)|logged[\s-]?in (?:dashboard|user))\b/;
     if (EXPLICIT.test(haystack))
         return true;
     return false;
@@ -2043,27 +2080,45 @@ export function detectSsoRestriction(pageText) {
 // post-login dashboard (which never carries these phrases) must NOT
 // match, or we'd wrongly abandon a working OAuth session.
 export function detectGoogleNoAccount(url, bodyText) {
-    // Inspect the decoded query string (where plunk parks its message)
-    // plus the page body — both lowercased for case-insensitive matching.
+    // Inspect the decoded query string (where plunk parks its message) and
+    // the URL path (to decide whether a BODY match is trustworthy).
     let query = "";
+    let path = "";
+    let urlParsed = false;
     try {
         const u = new URL(url);
         query = decodeURIComponent(u.search).toLowerCase();
+        path = u.pathname.toLowerCase();
+        urlParsed = true;
     }
     catch {
         query = "";
+        path = "";
     }
-    const haystack = `${query}\n${bodyText.toLowerCase()}`;
     // MEASURED 2026-06-04 (clerk): after Google OAuth, clerk bounces to its
     // sign-in showing "The External Account was not found" — Google signed
     // in but no clerk account exists for this identity (same class as plunk's
-    // "No account found"). The added "…not found" / "couldn't find an
-    // account" / "no such account" variants below catch clerk's wording.
-    // Every phrase still requires the word "account" (or "external account"),
-    // so a bare 404 "Page not found" does NOT trip this and abandon a working
-    // OAuth session.
+    // "No account found").
     const noAccountPhrase = /no account found|external account was not found|account (?:was )?not found|no (?:such )?account (?:found|exists)|account (?:doesn['’]?t|does not) exist|couldn['’]?t find (?:an|your) account|no account associated|sign up (?:first|to continue)|create an account|[?&]google-auth-error|register first/;
-    return noAccountPhrase.test(haystack);
+    // The QUERY string is an unambiguous auth-error redirect param (plunk parks
+    // its message there; some services use ?google-auth-error) — trust it
+    // anywhere.
+    if (noAccountPhrase.test(query))
+        return true;
+    // The BODY phrases ("create an account", "register first", "sign up to
+    // continue", …) ALSO appear as generic CTAs/links on a LOGGED-IN dashboard.
+    // MEASURED 2026-06-09 (together): after a successful Google sign-in the bot
+    // landed on the app root "/", whose body carried such a CTA — and the old
+    // body match abandoned the working session and dead-ended at oauth_required.
+    // A genuine "no account for this identity" message only renders on a
+    // login/sign-in/auth ROUTE, so only honor a body match there. On a dashboard
+    // or app route we keep the session and let post-OAuth navigation extract.
+    // If the URL couldn't be parsed at all, we have no route context to gate on
+    // — fall back to trusting the body (rare, and the phrases are strong).
+    const onAuthRoute = /(?:^|\/)(?:login|signin|sign-in|sign-up|signup|auth|authenticate|sso)(?:\/|$)/.test(path);
+    if (urlParsed && !onAuthRoute)
+        return false;
+    return noAccountPhrase.test(bodyText.toLowerCase());
 }
 // (d) Stuck-on-Google-OAuth-screens (Upstash class). After
 // settleAfterOAuth the URL is STILL on accounts.google.com — the
@@ -3008,6 +3063,35 @@ function isLLMPair(x) {
 // Navigates / waits / extracts are excluded — they legitimately don't
 // change the current DOM (navigate changes URL, wait pauses). Pure +
 // exported for unit tests.
+// Pick the onboarding field to overwrite with a unique value when a "name
+// taken" collision stalls the wizard. Prefer a business/org/workspace NAME
+// field (which commonly drives a derived subdomain — editing the domain
+// directly gets re-derived away), falling back to a bare subdomain/slug field.
+// Returns null when no such field is present (then the stall is a genuine
+// click-not-registering case, not a name collision). Exported for tests.
+export function pickUniqueNameField(inventory) {
+    const textInputs = inventory.filter((e) => e.tag === "input" && (e.type === null || e.type === "text"));
+    const hay = (e) => `${e.name ?? ""} ${e.id ?? ""} ${e.placeholder ?? ""} ${e.labelText ?? ""} ${e.ariaLabel ?? ""}`.toLowerCase();
+    const NAME_RE = /business[_ -]?name|company[_ -]?name|organi[sz]ation|\borg\b|workspace[_ -]?name|team[_ -]?name|account[_ -]?name|site[_ -]?name|project[_ -]?name|tenant/;
+    const byName = textInputs.find((e) => NAME_RE.test(hay(e)));
+    if (byName !== undefined)
+        return byName;
+    const DOMAIN_RE = /subdomain|\bdomain\b|\bslug\b|workspace[_ ]?url|handle/;
+    const byDomain = textInputs.find((e) => DOMAIN_RE.test(hay(e)));
+    return byDomain ?? null;
+}
+// Pick the submit/advance control for an onboarding form. Matches a
+// type=submit button or the conventional advance verbs. Returns null when no
+// obvious submit affordance is present.
+export function pickOnboardingSubmit(inventory) {
+    const buttons = inventory.filter((e) => e.tag === "button" || e.role === "button");
+    const ADVANCE_RE = /^(?:next|continue|submit|create|register|get started|finish|done|save)\b/i;
+    const byText = buttons.find((e) => ADVANCE_RE.test((e.visibleText ?? e.ariaLabel ?? "").trim()));
+    if (byText !== undefined)
+        return byText;
+    const bySubmit = buttons.find((e) => e.type === "submit");
+    return bySubmit ?? buttons[0] ?? null;
+}
 export function isStalledOnActions(effects, threshold = 3) {
     if (effects.length < threshold)
         return false;
@@ -4105,6 +4189,7 @@ export class SignupAgent {
             const page = this.browser.page;
             if (page === null || page === undefined)
                 return false;
+            const urlBefore = page.url();
             // First-choice selector: data-identifier on an interactive element.
             const candidates = [
                 '[data-identifier]:visible',
@@ -4116,12 +4201,27 @@ export class SignupAgent {
                 try {
                     await loc.waitFor({ state: "visible", timeout: 2_000 });
                     await loc.click({ timeout: 3_000 });
+                    if (process.env.BOT_DEBUG_CHOOSER) {
+                        await page.waitForTimeout(1500).catch(() => undefined);
+                        console.error(`[chooser-debug] matched sel=${JSON.stringify(sel)} urlBefore=${urlBefore} urlAfter=${page.url()}`);
+                    }
                     return true;
                 }
                 catch {
                     continue;
                 }
             }
+            if (process.env.BOT_DEBUG_CHOOSER) {
+                const dump = await page
+                    .evaluate(() => ({
+                    url: location.href,
+                    buttons: Array.from(document.querySelectorAll('[data-identifier],[role="link"],div[jsaction]'))
+                        .slice(0, 12)
+                        .map((e) => `${e.tagName}|${(e.getAttribute("data-identifier") ?? "").slice(0, 40)}|${(e.textContent ?? "").trim().slice(0, 50)}`),
+                }))
+                    .catch(() => null);
+                console.error(`[chooser-debug] NO selector matched. dump=${JSON.stringify(dump)}`);
+            }
             return false;
         }
         catch {
@@ -4525,9 +4625,18 @@ export class SignupAgent {
             }
             steps.push(`Navigating to ${signupUrl}`);
             await this.browser.goto(signupUrl);
-            // PERF: goto() awaits domcontentloaded; the subsequent
-            // waitForFormReady in planExecuteWithRetry handles SPA settle.
-            // No need for a blind 2s dwell here.
+            // Clear any anti-bot interstitial BEFORE the landing read below.
+            // goto() only awaits domcontentloaded, so a Cloudflare "Verifying you
+            // are human" / "Just a moment…" page is often still up — and the
+            // already-signed-in / classify / OAuth-affordance decisions a few lines
+            // down would then run against the interstitial's 2-element DOM and
+            // misjudge the page. MEASURED 2026-06-09: perplexity's /settings/api
+            // landed on a CF interstitial (inventory = just [Cloudflare, Privacy]),
+            // so the bot saw no OAuth button, classified "other", and bailed
+            // no_signup_link instead of reaching the real login/dashboard. The
+            // later waitForFormReady in planExecuteWithRetry was too late. Best-
+            // effort: a page with no interstitial returns fast.
+            await this.browser.waitForFormReady().catch(() => undefined);
             // After load: does the rendered page look like a signup form?
             // looksLikeSignupPage() can't tell signup from login (both have
             // email+password), so we ALSO classify the rendered HTML's copy via
@@ -4583,8 +4692,31 @@ export class SignupAgent {
             else {
                 const klass = classifySignupHtml(landed.html);
                 if (klass !== "signup" && !(await this.looksLikeSignupPage())) {
-                    needsRecovery = true;
-                    steps.push(`curated signup_url for ${task.service} rendered as "${klass}", not a signup form — attempting recovery`);
+                    // A "login"-classified page is still a valid signup ENTRY when it
+                    // offers OAuth: clicking "Continue with GitHub/Google" auto-
+                    // provisions the account on first use, and plenty of modern SPAs
+                    // (qdrant: cloud.qdrant.io/login) ship ONE unified page for both
+                    // login and signup. Only chase a separate signup page when there's
+                    // no OAuth affordance to ride — otherwise recovery falls through to
+                    // the Google-search fallback, which Google ERR_ABORTs through the
+                    // residential proxy, and the run dies on a page that would have
+                    // worked via OAuth.
+                    const oauthHere = findFirstOAuthButton(landedInventory, ["google", "github"]);
+                    if (process.env.BOT_DEBUG_CHOOSER) {
+                        console.error(`[login-entry-debug] ${task.service} klass=${klass} oauthHere=${oauthHere?.provider ?? "none"} ` +
+                            `inv(${landedInventory.length})=` +
+                            JSON.stringify(landedInventory
+                                .slice(0, 20)
+                                .map((e) => `${e.tag}|${(e.visibleText ?? e.ariaLabel ?? "").slice(0, 36)}`)));
+                    }
+                    if (oauthHere !== null) {
+                        steps.push(`curated signup_url for ${task.service} rendered as "${klass}", but it offers ` +
+                            `${oauthHere.provider} OAuth — treating the login page as the signup entry`);
+                    }
+                    else {
+                        needsRecovery = true;
+                        steps.push(`curated signup_url for ${task.service} rendered as "${klass}", not a signup form — attempting recovery`);
+                    }
                 }
             }
             if (needsRecovery) {
@@ -5024,6 +5156,26 @@ export class SignupAgent {
                                 // dashboard. Previous 3s was over-cautious.
                                 await this.browser.wait(1);
                                 await saveDebugSnapshot(this.browser, "after-verify");
+                                // Verify-link SPA bounce (MEASURED 2026-06-09: amplitude). The
+                                // emailed link is a click-tracker that redirects to
+                                // app.amplitude.com/signup?token=… — the token IS consumed
+                                // server-side, but the single-page app still renders the
+                                // "check your email" wall until the client re-fetches session
+                                // state. The post-verify loop then can't get past it. A single
+                                // reload makes the SPA re-read the now-verified session.
+                                // Bounded + guarded on the wall still showing, so a service
+                                // that verified cleanly pays nothing.
+                                try {
+                                    const afterText = await this.browser.extractText();
+                                    if (expectsVerificationEmail(afterText)) {
+                                        steps.push("Verification link landed but the page still shows the email-verify wall — reloading so the SPA re-reads the verified session.");
+                                        await this.browser.reload();
+                                        await this.browser.wait(2);
+                                    }
+                                }
+                                catch {
+                                    // best-effort — fall through to extraction regardless
+                                }
                                 // Try extracting first — many services drop the API key
                                 // straight onto the landing page after verification.
                                 credentials = await this.extractCredentials();
@@ -5184,6 +5336,39 @@ export class SignupAgent {
                         }
                     }
                 }
+                // hCaptcha Tier-3 — the OAuth-first path historically only escalated
+                // reCAPTCHA, so an hCaptcha-gated OAuth button (MEASURED 2026-06-09:
+                // supabase) timed out at Tier-2 and the bot then clicked a button
+                // still hidden behind the unsolved widget → 20s waitFor crash. The
+                // form-fill gate (runCaptchaGate) already solves hCaptcha via 2Captcha;
+                // mirror it here. Unlike Turnstile, hCaptcha is a real image challenge
+                // 2Captcha can solve, and its token is NOT IP-scored.
+                if (!solvedViaTier3 &&
+                    captcha.kind === "hcaptcha" &&
+                    this.captchaSolver?.isAvailable() === true) {
+                    const sitekey = await this.browser.extractHcaptchaSitekey();
+                    const pageUrl = (await this.browser.getState().catch(() => null))?.url;
+                    if (sitekey !== null && pageUrl !== undefined) {
+                        steps.push(`OAuth: Tier 3 — submitting hCaptcha sitekey to 2Captcha (${sitekey.slice(0, 10)}…)`);
+                        const solveRes = await this.captchaSolver.solveHcaptcha({ sitekey, pageUrl });
+                        if (solveRes.kind === "ok") {
+                            const injected = await this.browser.injectHcaptchaToken(solveRes.token);
+                            if (injected) {
+                                solvedViaTier3 = true;
+                                steps.push(`OAuth: Tier 3 solved the hCaptcha in ${Math.round(solveRes.durationMs / 1000)}s via 2Captcha — clicking the ${provider.label} affordance`);
+                            }
+                            else {
+                                steps.push(`OAuth: Tier 3 hCaptcha token arrived but page injection failed — clicking the ${provider.label} affordance anyway`);
+                            }
+                        }
+                        else {
+                            steps.push(`OAuth: Tier 3 hCaptcha ${solveRes.kind}` +
+                                ("reason" in solveRes ? `: ${solveRes.reason}` : "") +
+                                ("durationMs" in solveRes ? ` (${Math.round(solveRes.durationMs / 1000)}s)` : "") +
+                                ` — clicking the ${provider.label} affordance anyway`);
+                        }
+                    }
+                }
                 if (!solvedViaTier3) {
                     steps.push(`OAuth: visible ${captcha.kind} present but did not solve in 20s — clicking the ${provider.label} affordance anyway`);
                 }
@@ -5214,6 +5399,25 @@ export class SignupAgent {
                 (gsiHandled
                     ? ""
                     : " (FedCM dialog/popup did not complete — looking for another provider)"));
+            // Classic-redirect-misrouted-as-GSI recovery (MEASURED 2026-06-08:
+            // netlify). hasGoogleGsiAffordance() returns true whenever the GSI
+            // client *script* is loaded — but many pages load that script next to a
+            // CLASSIC redirect "Sign up with Google" button (netlify renders
+            // button[name="google"]). Routing that button through tryGoogleGsiLogin
+            // clicks it, which fires a normal same-tab redirect to
+            // accounts.google.com; GSI then reports via:"none" (no FedCM dialog, no
+            // popup) even though the OAuth redirect IS now in flight. Without this
+            // check the code below would (a) scan the GOOGLE page for a github
+            // fallback (finds none) and then (b) re-run startOAuth on
+            // button[name="google"] — a button that no longer exists on
+            // accounts.google.com → 20s waitFor timeout → the whole signup dies.
+            // If the page has actually navigated onto a Google auth host, the
+            // redirect already fired: treat it as handled and let the consent loop
+            // below drive it, exactly as it would for any classic redirect OAuth.
+            if (!gsiHandled && detectStuckOnGoogleOAuth(this.browser.currentUrl())) {
+                gsiHandled = true;
+                steps.push("OAuth: the GSI dialog never fired, but the click started a classic Google redirect — continuing the consent flow.");
+            }
         }
         // GSI/FedCM dead end. Google won't render the FedCM dialog for an
         // automated browser (measured: FedCm.enable ok, dialogShown never fires),
@@ -5222,17 +5426,37 @@ export class SignupAgent {
         // caller a TRY_NEXT_PROVIDER signal so it re-dispatches via that provider
         // instead of dead-ending on Google. meilisearch offers both.
         if (gsiAttempted && !gsiHandled) {
-            try {
-                const inv = await this.browser.extractInteractiveElements();
-                const alt = findFirstOAuthButton(inv, ["github"]);
-                if (alt !== null) {
-                    steps.push(`OAuth: Google GSI/FedCM is a dead end for the bot — falling back to ${alt.provider}.`);
-                    return { kind: "try_next_provider", selector: alt.button.selector, provider: alt.provider };
+            // The GSI click commonly leaves the page mid-SPA-transition (netlify:
+            // the button[name="google"] goes invisible, the page hasn't navigated
+            // anywhere useful), so a single inventory read here can THROW or return
+            // empty — and the old code then fell through to startOAuth(google),
+            // which re-clicked the now-hidden button and hung 20s before dying.
+            // Settle + retry the read a few times so the redirect-provider fallback
+            // (github) actually fires — github is the redirect provider whose
+            // session we keep warm.
+            let alt = null;
+            for (let attempt = 0; attempt < 3 && alt === null; attempt++) {
+                if (attempt > 0)
+                    await this.browser.wait(2);
+                try {
+                    const inv = await this.browser.extractInteractiveElements();
+                    alt = findFirstOAuthButton(inv, ["github"]);
+                }
+                catch {
+                    // page still navigating — retry after the settle
                 }
             }
-            catch {
-                // inventory read failed — fall through to the normal redirect path
+            if (alt !== null) {
+                steps.push(`OAuth: Google GSI/FedCM is a dead end for the bot — falling back to ${alt.provider}.`);
+                return { kind: "try_next_provider", selector: alt.button.selector, provider: alt.provider };
             }
+            // No redirect provider to hand off to. Re-clicking the Google affordance
+            // (startOAuth below) is pointless — it only re-raises the same dead GSI
+            // dialog, and on netlify-class pages crashes on the hidden button. Skip
+            // it: fall into the consent loop on the current page, which aborts
+            // cleanly (needs_login) instead of a misleading 20s waitFor timeout.
+            gsiHandled = true;
+            steps.push("OAuth: Google GSI/FedCM dead-ended with no redirect provider to fall back to.");
         }
         // OmniAuth POST-only recovery prep. Capture the affordance's href + the
         // page's CSRF token NOW, while we're still on the signin page — the
@@ -5468,7 +5692,7 @@ export class SignupAgent {
                 if (provider.id === "github" &&
                     task.machineToken !== undefined &&
                     task.machineToken.length > 0) {
-                    steps.push("GitHub: verify-it's-you challenge — polling operator gmail for a device-confirmation link (up to 60s)");
+                    steps.push("GitHub: verify-it's-you challenge — polling operator inbox for a device-confirmation link (up to 60s)");
                     try {
                         const { readGitHubChallengeLink } = await import("./read-otp.js");
                         const linkResult = await readGitHubChallengeLink({
@@ -5903,7 +6127,7 @@ export class SignupAgent {
                     otpResult = { code: null, reason: "no_machine_token" };
                 }
                 else {
-                    steps.push(`Email-OTP gate detected (${pathOf(gateState.url)}) — polling operator gmail for the code` +
+                    steps.push(`Email-OTP gate detected (${pathOf(gateState.url)}) — polling operator inbox for the code` +
                         (domain !== null ? ` (from_domain=${domain})` : ""));
                     otpResult = await readOperatorOtp({
                         machineToken,
@@ -6726,6 +6950,8 @@ ${formatInventory(input.inventory)}`,
         // ran (current page WAS a keys page but had no affordance), a
         // different keys URL on the same origin may carry the create
         // control (org-scoped vs account-scoped keys pages).
+        let consecutive404 = 0;
+        const MAX_CONSECUTIVE_404 = 3;
         for (let i = 0; i < STUCK_LOOP_FALLBACK_PATHS.length; i++) {
             let currentUrl;
             try {
@@ -6745,6 +6971,28 @@ ${formatInventory(input.inventory)}`,
             catch {
                 continue;
             }
+            // Abort the walk once guessed keys paths keep 404ing — this host's
+            // convention isn't in our list, so the remaining ~20 paths would all
+            // 404 too and burn the run's 600s budget (axiom/fathom/loops). A real
+            // (non-404) page resets the counter so a host that mixes 404s with a
+            // live keys page is still fully walked.
+            try {
+                const after = await this.browser.getState();
+                const bodyText = await this.browser.extractText().catch(() => "");
+                if (looksLike404(titleFromHtml(after.html), bodyText)) {
+                    consecutive404 += 1;
+                    if (consecutive404 >= MAX_CONSECUTIVE_404) {
+                        steps.push(`Existing-account recovery: ${consecutive404} consecutive 404s on guessed keys URLs — ` +
+                            `this host's keys path isn't in our list; aborting the walk.`);
+                        break;
+                    }
+                    continue;
+                }
+                consecutive404 = 0;
+            }
+            catch {
+                // best-effort — fall through to the extract attempt
+            }
             const here = await tryHere();
             if (here !== null)
                 return here;
@@ -6877,6 +7125,11 @@ ${formatInventory(input.inventory)}`,
         let prevContentSig = null;
         let lastActionKind = null;
         let lastActionSelector = null;
+        // Fired once: the unique-org-name recovery on a stall whose real cause is
+        // a "name taken" validation (kinde's business_details — the operator's
+        // prior account already used "tsagent", so the pre-filled name collides
+        // and the auto-derived subdomain is rejected, re-presenting the step).
+        let uniqueNameRetried = false;
         const actionEffects = [];
         // 0.8.2-rc.10 — escalation for the stuck-loop detector.
         //
@@ -6905,6 +7158,17 @@ ${formatInventory(input.inventory)}`,
         // walking every fallback path.
         let prematureDoneFallbacks = 0;
         const MAX_PREMATURE_DONE_FALLBACKS = 3;
+        // Navigate budget. A planner that can't find the key page (project-
+        // scoped URLs it can't construct — supabase; or an SPA that ignores
+        // direct navs and stays put — last9) keeps emitting `navigate` round
+        // after round, burning the entire 600s deadline (MEASURED 2026-06-09).
+        // `navigate` is exempt from the stuck-loop detector (it's meant to
+        // change the URL), so cap the TOTAL navigates: a legit dashboard is
+        // reachable in a handful, and past the cap the planner is just guessing.
+        // Past the cap we force non-navigate planning and, if still nothing,
+        // break — converting a 600s hang into a prompt, honest failure.
+        let navigateCount = 0;
+        const MAX_POST_VERIFY_NAVIGATES = 8;
         // Dead-URL memory. The planner guesses credential-page URLs
         // (e.g. /user/personal_access_tokens/new) that 404; without memory it
         // re-guesses the same dead URL round after round — xata and fly each
@@ -7151,6 +7415,51 @@ ${formatInventory(input.inventory)}`,
             }
             prevContentSig = contentSig;
             if (isStalledOnActions(actionEffects)) {
+                // Unique-name-collision recovery (fires ONCE, before giving up). The
+                // stall is often NOT "clicks not registering" but a server-side
+                // validation: an org/business/workspace NAME the operator's prior
+                // account already took, which on many forms drives a derived subdomain
+                // — so editing the domain directly doesn't stick; the NAME field must
+                // change. MEASURED 2026-06-09 (kinde): the pre-filled "tsagent" was
+                // taken, the domain went aria-invalid, and Next re-presented the step.
+                // Detect a taken/unavailable signal, overwrite the name field with a
+                // unique value (which re-derives a unique subdomain), resubmit, re-loop.
+                const bodyLow = (await this.browser.extractText().catch(() => "")).toLowerCase();
+                // NB: leading \b only, NO trailing \b — extractText() glues adjacent
+                // elements without whitespace ("…already taken" + "region" →
+                // "takenregion"), so a trailing boundary made this miss (MEASURED:
+                // kinde, takenSignal=false while the body clearly contained "taken").
+                // The leading \b still rejects mid-word hits like "mistaken"/"overtaken".
+                const takenSignal = /\b(?:taken|already (?:in use|exists|registered|taken)|not available|unavailable|already exists|choose another|try another)/.test(bodyLow);
+                const nameField = takenSignal ? pickUniqueNameField(inventory) : null;
+                if (process.env.BOT_DEBUG_CHOOSER) {
+                    console.error(`[uniquename-debug] takenSignal=${takenSignal} nameField=${nameField?.name ?? nameField?.id ?? "null"} ` +
+                        `textInputs=${JSON.stringify(inventory
+                            .filter((e) => e.tag === "input")
+                            .map((e) => `${e.type}|${e.name ?? e.id ?? "?"}`))} bodyHas_taken=${bodyLow.includes("taken")}`);
+                }
+                if (!uniqueNameRetried && nameField !== null) {
+                    uniqueNameRetried = true;
+                    const unique = `tsq${Math.floor(100000 + Math.random() * 900000)}`;
+                    args.steps.push(`Post-verify: stall is a name-taken collision — overwriting ${JSON.stringify(nameField.name ?? nameField.id ?? "name field")} with a unique value and resubmitting.`);
+                    try {
+                        await this.browser.type(nameField.selector, unique);
+                        await this.browser.wait(1);
+                        const submit = pickOnboardingSubmit(inventory);
+                        if (submit !== null) {
+                            await this.browser.click(submit.selector);
+                            await this.browser.wait(2);
+                        }
+                        // Reset the stall window so the resubmit gets a fair shot.
+                        actionEffects.length = 0;
+                        prevContentSig = null;
+                        hint = undefined;
+                        continue;
+                    }
+                    catch (err) {
+                        args.steps.push(`Post-verify: unique-name retry failed (${err instanceof Error ? err.message : String(err)}) — falling through.`);
+                    }
+                }
                 // Capture the exact page that defeated the wizard so the N1
                 // onboarding-wizard class is debuggable post-hoc (post-verify pages
                 // weren't being snapshotted — imagekit's step-1/3 role-select stall
@@ -7201,7 +7510,7 @@ ${formatInventory(input.inventory)}`,
                 detectEmailOtpGate(state.url, state.title, await this.browser.extractText().catch(() => ""))) {
                 otpPolledUrls.add(state.url);
                 const domain = fromDomainFromUrl(state.url);
-                args.steps.push(`Post-verify round ${round}: post-OAuth email-OTP gate (${pathOf(state.url)}) — polling operator gmail for the code` +
+                args.steps.push(`Post-verify round ${round}: post-OAuth email-OTP gate (${pathOf(state.url)}) — polling operator inbox for the code` +
                     (domain !== null ? ` (from_domain=${domain})` : ""));
                 const otp = await readOperatorOtp({
                     machineToken: args.machineToken,
@@ -7402,6 +7711,28 @@ ${formatInventory(input.inventory)}`,
                 continue;
             }
             if (nextStep.kind === "navigate") {
+                navigateCount += 1;
+                if (navigateCount > MAX_POST_VERIFY_NAVIGATES) {
+                    // Over budget: the planner is URL-guessing (supabase project-scoped
+                    // keys it can't address; last9's SPA that ignores direct navs). One
+                    // more shot CLICKING the current inventory, then give up — don't
+                    // burn the rest of the 600s deadline on more dead navigates.
+                    const clickable = inventory.filter((e) => e.tag === "button" || e.tag === "a");
+                    if (clickable.length > 0 && navigateCount <= MAX_POST_VERIFY_NAVIGATES + 2) {
+                        args.steps.push(`Post-verify: navigate budget (${MAX_POST_VERIFY_NAVIGATES}) exhausted — forcing a click on the current page instead of guessing more URLs.`);
+                        hint =
+                            `You have navigated ${navigateCount} times without reaching an API-key page. ` +
+                                `STOP navigating to guessed URLs. CLICK an element from the inventory below ` +
+                                `to advance the onboarding/dashboard, or emit 'done' if there is genuinely no ` +
+                                `key affordance here.`;
+                        continue;
+                    }
+                    this.lastPostVerifyDoneReason =
+                        `[stuck_loop] post-verify exhausted the navigate budget (${navigateCount} navigates) without ` +
+                            `reaching a credential page — the key is behind onboarding/URL the planner can't address.`;
+                    args.steps.push(`Post-verify: navigate budget exhausted (${navigateCount}) with no credential — breaking out instead of burning the run deadline.`);
+                    break;
+                }
                 prevNavigateFromUrl = state.url;
                 // Remember where we're going so the next round can blocklist it
                 // if it 404s.