@trusty-squire/mcp 0.9.18 → 0.9.19-rc.10

package/dist/bot/agent.js

@@ -32,7 +32,7 @@ import { MAX_POST_VERIFY_NAVIGATES, MAX_PREMATURE_DONE_FALLBACKS, MAX_UPSTREAM_B
 import { PostSignupSyntheticCapture } from "./post-signup-synthetic-capture.js";
 import { CredentialExtractionFlow, DOM_LABEL_TO_KEY, NON_CREDENTIAL_KEYS, extractAllLabeledTokensFromReason, hasAnyExtractedCredential, hasUsableCredentialBundle, } from "./credential-extraction-flow.js";
 export { extractAllLabeledTokensFromReason, hasAnyExtractedCredential, isMultiCredBundle, } from "./credential-extraction-flow.js";
-import { captureOnboardingRound, updateCapturedRoundSemantic, } from "./onboarding-capture.js";
+import { captureOnboardingRound, hasCapturedAnyRound, hasCapturedExtractRound, nextCaptureRound, updateCapturedRoundSemantic, } from "./onboarding-capture.js";
 import { evaluateSemanticTransition, inferSemanticTransition, } from "./semantic-transition.js";
 import { KEYS_DESTINATION_URL, runNavSearch, } from "./nav-search.js";
 import { wasRecentlyPrewarmed, recordPrewarmSuccess } from "./prewarm-cache.js";
@@ -401,6 +401,16 @@ const SERVICE_KEYS_PATHS = {
     // /settings/* and /api-keys guesses miss it and the planner can get stuck
     // in Business Account > Team Members.
     paddle: ["/authentication-v2"],
+    // Together AI's project-scoped keys route is discoverable in the DOM, but the
+    // planner can loop between Create key and payment-skip affordances after it
+    // lands there. Pin the route so recovery starts at the credential surface.
+    togetherai: [
+        "https://api.together.ai/settings/projects/~current/api-keys",
+        "/settings/projects/~current/api-keys",
+    ],
+    // Cartesia's authenticated root/dashboard can expose key rows with Reveal
+    // controls; generic /settings/* guesses hit 404/error shells first.
+    cartesia: ["/", "/dashboard", "/start", "/api-keys"],
 };
 // Normalize a service name to the slug used as a SERVICE_KEYS_PATHS key:
 // lowercased, alphanumerics only. Mirrors guessSignupUrl's slug rule so
@@ -409,6 +419,80 @@ const SERVICE_KEYS_PATHS = {
 export function serviceSlug(service) {
     return service.toLowerCase().replace(/[^a-z0-9]/g, "");
 }
+export function hasCuratedServiceKeyPath(service) {
+    return SERVICE_KEYS_PATHS[serviceSlug(service)] !== undefined;
+}
+function elementLabel(el) {
+    return [
+        el.visibleText,
+        el.ariaLabel,
+        el.title,
+        el.labelText,
+        el.iconLabel,
+        el.href,
+        el.testId,
+    ]
+        .filter((s) => s !== null && s !== undefined)
+        .join(" ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+export function shouldRevealBeforeCredentialSweep(input) {
+    const haystack = `${input.url}\n${input.pageText}`;
+    return (/\b(?:api[\s_-]*(?:keys?|tokens?)|access[\s_-]*tokens?|personal[\s_-]*access[\s_-]*tokens?|secret[\s_-]*keys?|auth[\s_-]*tokens?|credentials?|reveal|show\s+(?:key|token|secret)|copy\s+(?:key|token|secret))\b/i.test(haystack) &&
+        /(?:•{3,}|\*{3,}|[A-Za-z0-9]{2,4}[•*]{4,}|\b(?:reveal|show|unmask|view)\b)/i.test(haystack));
+}
+export function credentialActionSignature(step, inventory) {
+    if (!("selector" in step) || step.selector === undefined)
+        return null;
+    const target = inventory.find((e) => e.selector === step.selector);
+    const label = [
+        target?.visibleText,
+        target?.ariaLabel,
+        target?.title,
+        target?.labelText,
+        target?.iconLabel,
+        step.reason,
+    ]
+        .filter((s) => s !== null && s !== undefined)
+        .join(" ")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (label.length === 0)
+        return null;
+    const lower = label.toLowerCase();
+    if (/\b(?:create|generate|new|add|issue|mint)\b.*\b(?:api\s*)?(?:key|token|secret|credential)s?\b/.test(lower) ||
+        /\b(?:api\s*)?(?:key|token|secret|credential)s?\b.*\b(?:create|generate|new|add|issue|mint)\b/.test(lower)) {
+        return `${step.kind}:create-key`;
+    }
+    if (/\b(?:skip|maybe later|not now|without)\b.*\b(?:payment|billing|card|deposit|credits?)\b/.test(lower) ||
+        /\b(?:payment|billing|card|deposit|credits?)\b.*\b(?:skip|maybe later|not now|without)\b/.test(lower)) {
+        return `${step.kind}:skip-payment`;
+    }
+    if (/\b(?:add|make|initial)\b.*\b(?:payment|deposit|credits?)\b/.test(lower)) {
+        return `${step.kind}:payment`;
+    }
+    return null;
+}
+export function isRepeatingCredentialActionCycle(signatures, pageText = "") {
+    const interesting = signatures.some((s) => /(?:create-key|payment|deposit)/.test(s)) ||
+        /\b(?:api\s*keys?|tokens?|payment|billing|deposit|credits?)\b/i.test(pageText);
+    if (!interesting)
+        return false;
+    const last3 = signatures.slice(-3);
+    if (last3.length === 3 &&
+        last3.every((s) => s === last3[0]) &&
+        /(?:create-key|skip-payment|payment)/.test(last3[0] ?? "")) {
+        return true;
+    }
+    const last5 = signatures.slice(-5);
+    return (last5.length === 5 &&
+        last5[0] === last5[2] &&
+        last5[2] === last5[4] &&
+        last5[1] === last5[3] &&
+        last5[0] !== last5[1] &&
+        last5.some((s) => /(?:create-key|skip-payment|payment)/.test(s)));
+}
 // 0.8.2-rc.10 — heuristic for "this account already exists on the
 // service and its API keys are masked, with no path to reveal them."
 // The test identity (methoxine@gmail.com) accumulates state across
@@ -613,6 +697,51 @@ export function findKeyNameInput(inventory) {
 // should the bot. Exported, pure (operates on the inventory shape only).
 const API_KEYS_HREF = /\/(?:api[-_]?keys?|api[-_]?tokens?|access[-_]?tokens?|auth[-_]?tokens?|secret[-_]?keys?|personal[-_]?access[-_]?tokens?|developers?|keys?|tokens?)(?:[/?#]|$)/i;
 const API_KEYS_TEXT = /\b(?:api|access|secret|auth|personal\s+access)\s*(?:keys?|tokens?)\b/i;
+// Find a settings / API-keys / dashboard nav link to ESCAPE a stuck onboarding
+// wizard. MEASURED 2026-06-24 (cloudinary /app/welcome): the welcome survey's
+// clicks don't register (STALLED), but it's an OVERLAY on the real product
+// dashboard whose sidebar — Home → /app/home, Settings → /app/settings — is
+// already in the inventory. Navigating to settings/keys/home reaches the
+// credential surface behind the wizard. Prefers settings/account/keys (where
+// API credentials live) over a bare home/dashboard link. Anchor href is
+// authoritative; text is the backstop (cloudinary's Settings link is icon-only,
+// no visible text — only the href identifies it).
+const WIZARD_ESCAPE_HREF = /\/(?:settings|account|api[-_]?keys?|developers?|dashboard|home|console)(?:\/|$|\?)/i;
+const WIZARD_ESCAPE_TEXT = /\b(?:settings|account|dashboard|api\s*keys?|developers?|console)\b/i;
+export function findWizardEscapeNavLink(inventory, alreadyClicked = new Set()) {
+    let best = null;
+    for (const el of inventory) {
+        // Escape via a NAV LINK (anchor), not a wizard survey button — a role
+        // option like "Back End Developer" is a button and must never be mistaken
+        // for a "Developers" settings link.
+        const isNavLink = el.tag === "a" || el.role === "link";
+        if (!isNavLink || el.visible === false)
+            continue;
+        if (alreadyClicked.has(el.selector))
+            continue;
+        const href = el.href ?? "";
+        const text = [el.visibleText, el.ariaLabel, el.title, el.labelText, el.iconLabel]
+            .filter((s) => s !== null && s !== undefined)
+            .join(" ");
+        const hrefHit = href.length > 0 && WIZARD_ESCAPE_HREF.test(href);
+        const textHit = WIZARD_ESCAPE_TEXT.test(text);
+        if (!hrefHit && !textHit)
+            continue;
+        let score = 0;
+        if (hrefHit)
+            score += 4; // a navigable target beats a text guess
+        // settings/account/keys are where API credentials live — rank above home.
+        if (/\/(?:settings|account|api[-_]?keys?|developers?)(?:\/|$|\?)/i.test(href))
+            score += 3;
+        if (/\b(?:settings|account|api\s*keys?|developers?)\b/i.test(text))
+            score += 2;
+        if (el.tag === "a" && href.length > 0)
+            score += 1;
+        if (best === null || score > best.score)
+            best = { el, score };
+    }
+    return best?.el ?? null;
+}
 export function findApiKeysNavLink(inventory, alreadyClicked = new Set()) {
     const candidates = [];
     for (const el of inventory) {
@@ -661,6 +790,58 @@ export function findApiKeysNavLink(inventory, alreadyClicked = new Set()) {
     candidates.sort((a, b) => b.score - a.score);
     return candidates[0].el;
 }
+export function findRenderAccountSettingsLink(inventory, alreadyClicked = new Set()) {
+    for (const el of inventory) {
+        if (el.visible === false)
+            continue;
+        if (alreadyClicked.has(el.selector))
+            continue;
+        const clickable = el.tag === "a" ||
+            el.tag === "button" ||
+            el.role === "link" ||
+            el.role === "button";
+        if (!clickable)
+            continue;
+        const label = elementLabel(el);
+        if (/\baccount settings\b/i.test(label) || /\/u\/[^/\s]+\/settings(?:[#?\s]|$)/i.test(label)) {
+            return el;
+        }
+    }
+    return null;
+}
+export function findRenderAccountMenuTrigger(inventory) {
+    const candidates = [];
+    for (const el of inventory) {
+        if (el.visible === false)
+            continue;
+        const clickable = el.tag === "button" || el.role === "button";
+        if (!clickable)
+            continue;
+        const label = elementLabel(el);
+        if (label.length === 0)
+            continue;
+        const normalized = label.toLowerCase().trim();
+        if (/\b(?:new|upgrade|search|settings|billing|projects?|blueprints?|notifications?|contact support|create|add)\b/i.test(normalized)) {
+            continue;
+        }
+        let score = 0;
+        if (el.landmark === "header")
+            score += 4;
+        if (/^[a-z]{1,3}$/i.test(normalized))
+            score += 3;
+        if (/\b(?:profile|account|user|avatar)\b/i.test(label))
+            score += 2;
+        if (el.inViewport === true)
+            score += 1;
+        if (score <= 0)
+            continue;
+        candidates.push({ el, score });
+    }
+    if (candidates.length === 0)
+        return null;
+    candidates.sort((a, b) => b.score - a.score);
+    return candidates[0].el;
+}
 const RELOCATED_PAGE_TEXT = /\b(?:404|page not found|not found|does not exist|no longer exists|has moved|moved|migrated|now (?:lives|exists)|part of .* instead|teams? list|organisations? list|organizations? list)\b/i;
 const CREDENTIAL_CONTEXT_TEXT = /\b(?:api[\s_-]*(?:keys?|tokens?)|access[\s_-]*tokens?|personal[\s_-]*access[\s_-]*tokens?|secret[\s_-]*keys?|auth[\s_-]*tokens?|credentials?|developers?)\b/i;
 const RELOCATION_RECOVERY_TEXT = /\b(?:teams?|organisations?|organizations?|accounts?|settings|profile|dashboard|developers?|api|keys?|tokens?|credentials?)\b/i;
@@ -3728,6 +3909,16 @@ export function extractApiKeyFromText(text) {
         // pattern only fires on Zeabur-style keys. Surfaced from the
         // rc.23 snapshot review.
         /\bsk-[a-z0-9]{28,38}\b/, // Zeabur
+        // PostHog PERSONAL API key — `phx_<43+ alnum>`. MEASURED 2026-06-24: the
+        // post-OAuth create-personal-api-key flow mints a `phx_`-prefixed secret —
+        // the planner SAW it (and even OCR-transcribed it with errors), but no regex
+        // matched so the DOM extractor stored nothing and the run bailed
+        // oauth_onboarding_failed while a real key sat on the page. The {40,60}
+        // bound keeps it clear of short prefixed noise. Deliberately NOT matching
+        // the `phc_` PROJECT key —
+        // that's a PUBLIC analytics key embedded in client JS on every PostHog site
+        // (see extract-credentials.test "ignores a PostHog project key").
+        /\bphx_[A-Za-z0-9]{40,60}\b/, // PostHog personal API key
         // OpenRouter, Anthropic, OpenAI — these are the dominant
         // OAuth-completed-then-copy-needed services. Specific-prefix
         // patterns first so a labeled-pattern fallback isn't load-
@@ -5841,7 +6032,7 @@ export class SignupAgent {
             // branch will actually consult it (candidates present, NOT committed, and
             // no provider button hit yet). Computing it unconditionally would fire a
             // spurious extractText() every round and diverge from the inline path.
-            const needScanShell = oauthCandidates.length > 0 && !state.committedToEmailPath && oauthButtonHitRaw === null;
+            const needScanShell = oauthCandidates.length > 0 && !state.oauthProvenUnavailable && oauthButtonHitRaw === null;
             const oauthScanShell = needScanShell &&
                 (inventory.length <= 1 ||
                     !hasCredentialInput ||
@@ -7568,6 +7759,7 @@ export class SignupAgent {
                                 ...(task.scopeHint !== undefined ? { scopeHint: task.scopeHint } : {}),
                                 ...(task.machineToken !== undefined ? { machineToken: task.machineToken } : {}),
                                 ...(task.apiBase !== undefined ? { apiBase: task.apiBase } : {}),
+                                allowOperatorInboxOtp: task.allowOperatorInboxOtp === true,
                             });
                         }
                         if (hasUsableCredentialBundle(credentials)) {
@@ -7839,6 +8031,7 @@ export class SignupAgent {
                                         ...(task.scopeHint !== undefined ? { scopeHint: task.scopeHint } : {}),
                                         ...(task.machineToken !== undefined ? { machineToken: task.machineToken } : {}),
                                         ...(task.apiBase !== undefined ? { apiBase: task.apiBase } : {}),
+                                        allowOperatorInboxOtp: task.allowOperatorInboxOtp === true,
                                     });
                                 }
                             }
@@ -7887,6 +8080,9 @@ export class SignupAgent {
                 }
             }
             if (credentials.api_key !== undefined || credentials.username !== undefined) {
+                // Form-fill + email success returns here WITHOUT entering the post-verify
+                // loop, so its extract-round salvage never ran — write one now (mailjet).
+                await this.salvageExtractCaptureIfNeeded(task.service, credentials, false);
                 return {
                     success: true,
                     credentials: { ...credentials, password, email: task.email },
@@ -8451,7 +8647,8 @@ export class SignupAgent {
                 // degrades to the phone-tap path below.
                 if (provider.id === "github" &&
                     task.machineToken !== undefined &&
-                    task.machineToken.length > 0) {
+                    task.machineToken.length > 0 &&
+                    task.allowOperatorInboxOtp === true) {
                     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");
@@ -9069,6 +9266,9 @@ export class SignupAgent {
                     machineToken.length === 0) {
                     otpResult = { code: null, reason: "no_machine_token" };
                 }
+                else if (task.allowOperatorInboxOtp !== true) {
+                    otpResult = { code: null, reason: "operator_inbox_consent_missing" };
+                }
                 else {
                     steps.push(`Email-OTP gate detected (${pathOf(gateState.url)}) — polling operator inbox for the code` +
                         (domain !== null ? ` (from_domain=${domain})` : ""));
@@ -9222,6 +9422,7 @@ export class SignupAgent {
                 ...(task.scopeHint !== undefined ? { scopeHint: task.scopeHint } : {}),
                 ...(task.machineToken !== undefined ? { machineToken: task.machineToken } : {}),
                 ...(task.apiBase !== undefined ? { apiBase: task.apiBase } : {}),
+                allowOperatorInboxOtp: task.allowOperatorInboxOtp === true,
             });
         }
         catch (err) {
@@ -9692,6 +9893,7 @@ ${formatInventory(input.inventory)}`,
             ...(task.scopeHint !== undefined ? { scopeHint: task.scopeHint } : {}),
             ...(task.machineToken !== undefined ? { machineToken: task.machineToken } : {}),
             ...(task.apiBase !== undefined ? { apiBase: task.apiBase } : {}),
+            allowOperatorInboxOtp: task.allowOperatorInboxOtp === true,
         });
     }
     // Drive the browser toward the API key after the account exists —
@@ -10351,6 +10553,38 @@ Prefer items naming keys / tokens / API / developer / secrets; then credentials
         // form-fill phase already captured (captureSignupFormRounds); 0 on the
         // OAuth path, so this is unchanged for OAuth skills.
         let capturedRound = this.captureChainRound;
+        if (hasCuratedServiceKeyPath(args.service)) {
+            const fallback = pickStuckLoopFallbackUrl(this.browser.currentUrl(), recovery.triedFallbackUrls, args.service, this.resolvedSignupUrl);
+            if (fallback !== null) {
+                recovery.triedFallbackUrls.add(fallback);
+                args.steps.push(`Post-verify: nav-search exhausted but ${args.service} has a curated credential route — trying ${fallback} before greedy planning.`);
+                try {
+                    await this.browser.goto(fallback);
+                    await this.browser.waitForInteractiveDom(5, 15_000).catch(() => undefined);
+                    const direct = await this.harvestVisibleCredentials();
+                    for (const [k, v] of Object.entries(direct)) {
+                        if (credentials[k] === undefined)
+                            credentials[k] = v;
+                    }
+                    if (hasAnyExtractedCredential(credentials)) {
+                        await this.writeFastPathSyntheticCapture(args.service, capturedRound, oauth, "curated credential route synthetic extract — nav-search exhausted, fallback route exposed credentials");
+                        return credentials;
+                    }
+                    const minted = await this.attemptMintNewKey(args.steps, args.service);
+                    if (minted !== null && hasAnyExtractedCredential(minted)) {
+                        for (const [k, v] of Object.entries(minted)) {
+                            if (credentials[k] === undefined)
+                                credentials[k] = v;
+                        }
+                        await this.writeFastPathSyntheticCapture(args.service, capturedRound, oauth, "curated credential route synthetic extract — minted/extracted after nav-search fallback");
+                        return credentials;
+                    }
+                }
+                catch (err) {
+                    args.steps.push(`Post-verify: curated credential route fallback errored (${err instanceof Error ? err.message : String(err)}) — continuing with greedy planner.`);
+                }
+            }
+        }
         const credentialTracker = new PostSignupCredentialTracker(credentials);
         // Gate URLs we've already polled the operator's gmail for, so a
         // multi-round wait on the same email-OTP page doesn't re-poll.
@@ -10390,6 +10624,23 @@ Prefer items naming keys / tokens / API / developer / secrets; then credentials
             // the planner choosing the right click, so an on-screen key is never
             // missed into a maxRounds bail. Merge-only (never overwrites a prior
             // capture); both extractors are best-effort.
+            try {
+                const currentUrl = this.browser.currentUrl();
+                if (!recovery.revealSweepUrls.has(currentUrl)) {
+                    const sweepText = await this.browser.extractVisibleText().catch(() => "");
+                    if (shouldRevealBeforeCredentialSweep({ url: currentUrl, pageText: sweepText })) {
+                        recovery.revealSweepUrls.add(currentUrl);
+                        const reveal = await this.browser.revealMaskedCredentials();
+                        if (reveal.clicked > 0) {
+                            args.steps.push(`Post-verify round ${round}: credential surface has reveal controls — clicked ${reveal.clicked} before sweeping.`);
+                            await this.browser.wait(1);
+                        }
+                    }
+                }
+            }
+            catch {
+                // reveal is opportunistic; normal extraction still runs below
+            }
             try {
                 const sweep = await this.extractCredentials();
                 for (const [k, v] of Object.entries(sweep)) {
@@ -10449,10 +10700,17 @@ Prefer items naming keys / tokens / API / developer / secrets; then credentials
                 try {
                     if (await this.browser.hasDisabledSubmit()) {
                         const picked = await this.browser.fillRequiredComboboxes();
-                        if (picked.length > 0) {
+                        // The scope/preset pattern (API-key creation forms) gates submit
+                        // behind a segmented "All access" + a LemonSelect preset the
+                        // combobox filler can't see — satisfy those too before giving up.
+                        const scoped = picked.length > 0
+                            ? []
+                            : await this.browser.satisfyScopePresets().catch(() => []);
+                        const satisfied = [...picked, ...scoped];
+                        if (satisfied.length > 0) {
                             comboboxFilled = true;
-                            args.steps.push(`Post-verify: satisfied ${picked.length} required onboarding select(s) ` +
-                                `to clear a disabled submit — ${picked.join(", ")}`);
+                            args.steps.push(`Post-verify: satisfied ${satisfied.length} required onboarding select(s) ` +
+                                `to clear a disabled submit — ${satisfied.join(", ")}`);
                             await this.browser.waitForFormReady().catch(() => undefined);
                         }
                         else {
@@ -10706,6 +10964,77 @@ Prefer items naming keys / tokens / API / developer / secrets; then credentials
             else {
                 lastReachablePostVerifyUrl = state.url;
             }
+            if (serviceSlug(args.service) === "render" &&
+                !hasAnyExtractedCredential(credentials) &&
+                /dashboard\.render\.com/i.test(state.url)) {
+                const onRenderAccountSettings = /\/u\/[^/]+\/settings\b/i.test(state.url);
+                if (!onRenderAccountSettings) {
+                    const accountSettingsLink = findRenderAccountSettingsLink(inventory, recovery.clickedKeysLinks);
+                    if (accountSettingsLink !== null) {
+                        recovery.clickedKeysLinks.add(accountSettingsLink.selector);
+                        const label = accountSettingsLink.visibleText ??
+                            accountSettingsLink.ariaLabel ??
+                            accountSettingsLink.href ??
+                            accountSettingsLink.selector;
+                        args.steps.push(`Post-verify round ${round}: Render account menu exposes "${label.slice(0, 60)}" — entering account settings before API-key navigation.`);
+                        try {
+                            await this.browser.click(accountSettingsLink.selector);
+                            await this.browser.waitForInteractiveDom(5, 15_000).catch(() => undefined);
+                            hint = undefined;
+                            recovery.prevSignature = null;
+                            recovery.prevInventorySize = -1;
+                            continue;
+                        }
+                        catch (err) {
+                            args.steps.push(`Post-verify round ${round}: Render account-settings click failed (${err instanceof Error ? err.message : String(err)}) — continuing.`);
+                        }
+                    }
+                    else if (!recovery.triedRenderAccountMenu) {
+                        const accountMenu = findRenderAccountMenuTrigger(inventory);
+                        if (accountMenu !== null) {
+                            recovery.triedRenderAccountMenu = true;
+                            const label = accountMenu.visibleText ??
+                                accountMenu.ariaLabel ??
+                                accountMenu.title ??
+                                accountMenu.selector;
+                            args.steps.push(`Post-verify round ${round}: Render dashboard has no API-key link visible — opening account menu "${label.slice(0, 40)}".`);
+                            try {
+                                await this.browser.click(accountMenu.selector);
+                                await this.browser.waitForInteractiveDom(5, 15_000).catch(() => undefined);
+                                hint = undefined;
+                                recovery.prevSignature = null;
+                                recovery.prevInventorySize = -1;
+                                continue;
+                            }
+                            catch (err) {
+                                args.steps.push(`Post-verify round ${round}: Render account-menu click failed (${err instanceof Error ? err.message : String(err)}) — continuing.`);
+                            }
+                        }
+                    }
+                }
+                else if (!/#api-keys\b/i.test(state.url)) {
+                    const keysLink = findApiKeysNavLink(inventory, recovery.clickedKeysLinks);
+                    if (keysLink !== null) {
+                        recovery.clickedKeysLinks.add(keysLink.selector);
+                        const label = keysLink.visibleText ??
+                            keysLink.ariaLabel ??
+                            keysLink.href ??
+                            keysLink.selector;
+                        args.steps.push(`Post-verify round ${round}: Render account settings reached — clicking API-key anchor "${label.slice(0, 60)}".`);
+                        try {
+                            await this.browser.click(keysLink.selector);
+                            await this.browser.waitForInteractiveDom(5, 15_000).catch(() => undefined);
+                            hint = undefined;
+                            recovery.prevSignature = null;
+                            recovery.prevInventorySize = -1;
+                            continue;
+                        }
+                        catch (err) {
+                            args.steps.push(`Post-verify round ${round}: Render API-key anchor click failed (${err instanceof Error ? err.message : String(err)}) — continuing.`);
+                        }
+                    }
+                }
+            }
             const emailAlias = args.verificationEmailAlias ??
                 args.credentials?.email ??
                 args.oauthAccountEmail;
@@ -10978,6 +11307,72 @@ Prefer items naming keys / tokens / API / developer / secrets; then credentials
                         }
                     }
                 }
+                // JS-click recovery FIRST. The dominant wizard-stall cause is a custom
+                // radio-card selection whose React onClick a normal (coordinate/CDP)
+                // click doesn't fire, so the page never changes and "Next" stays
+                // inert — MEASURED 2026-06-24 (auth0 Account-Type Personal/Company,
+                // cloudinary survey, posthog role-picker class). Re-dispatch the recent
+                // page-mutating clicks via page.evaluate(el.click()) (clickViaJs), which
+                // fires the handler; the selection commits and the next forward click
+                // advances. One attempt, then fall through to the escape/stall.
+                if (!recovery.triedWizardJsClick && typeof this.browser.clickViaJs === "function") {
+                    recovery.triedWizardJsClick = true;
+                    const recentClickSelectors = recovery.actionEffects
+                        .filter((e) => e.kind === "click" && e.selector !== null)
+                        .map((e) => e.selector)
+                        .filter((s, i, a) => a.indexOf(s) === i);
+                    if (recentClickSelectors.length > 0) {
+                        args.steps.push(`Post-verify: STALLED in a wizard — re-dispatching ${recentClickSelectors.length} recent click(s) via JS ` +
+                            `(custom radio-card onClick that the normal click didn't fire).`);
+                        for (const sel of recentClickSelectors) {
+                            await this.browser.clickViaJs(sel).catch(() => undefined);
+                            await this.browser.wait(1);
+                        }
+                        // Then JS-click a forward/submit button so a now-enabled Next advances.
+                        const fwd = pickOnboardingSubmit(inventory);
+                        if (fwd !== null) {
+                            await this.browser.clickViaJs(fwd.selector).catch(() => undefined);
+                        }
+                        await this.browser.waitForInteractiveDom(5, 15_000).catch(() => undefined);
+                        recovery.actionEffects.length = 0;
+                        recovery.prevContentSig = null;
+                        hint = undefined;
+                        continue;
+                    }
+                }
+                // Wizard-escape before giving up. A re-presenting onboarding wizard
+                // whose clicks don't register is an OVERLAY on the real product
+                // dashboard — its sidebar (Home/Settings/API Keys) is already in the
+                // inventory. Navigate to a settings/keys/home nav link to reach the
+                // credential surface behind it (MEASURED 2026-06-24, cloudinary
+                // /app/welcome: the survey no-ops but Settings → /app/settings is right
+                // there). One attempt, then honor the stall.
+                if (!recovery.triedWizardEscape) {
+                    recovery.triedWizardEscape = true;
+                    const escapeLink = findWizardEscapeNavLink(inventory, recovery.clickedKeysLinks);
+                    if (escapeLink !== null) {
+                        recovery.clickedKeysLinks.add(escapeLink.selector);
+                        const label = escapeLink.visibleText ?? escapeLink.ariaLabel ?? escapeLink.href ?? "the dashboard";
+                        args.steps.push(`Post-verify: STALLED in an onboarding wizard — escaping to ${JSON.stringify(label.slice(0, 40))} ` +
+                            `(the wizard overlays the product dashboard; the key surface is behind it).`);
+                        try {
+                            if (escapeLink.href !== undefined && escapeLink.href !== null && escapeLink.href.length > 0) {
+                                await this.browser.goto(new URL(escapeLink.href, state.url).toString());
+                            }
+                            else {
+                                await this.browser.click(escapeLink.selector);
+                            }
+                            await this.browser.waitForInteractiveDom(5, 15_000).catch(() => undefined);
+                            recovery.actionEffects.length = 0;
+                            recovery.prevContentSig = null;
+                            hint = undefined;
+                            continue;
+                        }
+                        catch (err) {
+                            args.steps.push(`Post-verify: wizard-escape navigate failed (${err instanceof Error ? err.message : String(err)}) — honoring the stall.`);
+                        }
+                    }
+                }
                 // 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
@@ -11037,6 +11432,7 @@ Prefer items naming keys / tokens / API / developer / secrets; then credentials
             if (hint === undefined &&
                 args.machineToken !== undefined &&
                 args.machineToken.length > 0 &&
+                args.allowOperatorInboxOtp === true &&
                 !otpPolledUrls.has(state.url) &&
                 detectEmailOtpGate(state.url, state.title, await this.browser.extractText().catch(() => ""), inventory)) {
                 otpPolledUrls.add(state.url);
@@ -11604,6 +12000,46 @@ Prefer items naming keys / tokens / API / developer / secrets; then credentials
                 recovery.prevSignature = null;
                 recovery.prevInventorySize = inventory.length;
             }
+            const actionCycleSignature = credentialActionSignature(nextStep, inventory);
+            if (actionCycleSignature !== null) {
+                recovery.recentCredentialActionSignatures.push(actionCycleSignature);
+                if (recovery.recentCredentialActionSignatures.length > 8) {
+                    recovery.recentCredentialActionSignatures =
+                        recovery.recentCredentialActionSignatures.slice(-8);
+                }
+                if (isRepeatingCredentialActionCycle(recovery.recentCredentialActionSignatures, visiblePageText)) {
+                    args.steps.push(`Post-verify: detected repeating credential-action cycle (${recovery.recentCredentialActionSignatures.slice(-5).join(" → ")}) — trying extraction/fallback instead of repeating it.`);
+                    const harvested = await this.harvestVisibleCredentials().catch(() => ({}));
+                    for (const [k, v] of Object.entries(harvested)) {
+                        if (credentials[k] === undefined)
+                            credentials[k] = v;
+                    }
+                    if (hasAnyExtractedCredential(credentials)) {
+                        await this.writeFastPathSyntheticCapture(args.service, capturedRound, oauth, "repeating credential-action cycle synthetic extract — credentials were already visible");
+                        return credentials;
+                    }
+                    const fallback = pickStuckLoopFallbackUrl(state.url, recovery.triedFallbackUrls, args.service, this.resolvedSignupUrl);
+                    if (fallback !== null) {
+                        recovery.triedFallbackUrls.add(fallback);
+                        args.steps.push(`Post-verify: credential-action cycle fallback — navigating to ${fallback}`);
+                        try {
+                            await this.browser.goto(fallback);
+                            await this.browser.waitForInteractiveDom(5, 15_000).catch(() => undefined);
+                        }
+                        catch (err) {
+                            args.steps.push(`Post-verify: credential-action cycle fallback navigate failed (${err instanceof Error ? err.message : String(err)}) — continuing.`);
+                        }
+                        recovery.prevSignature = null;
+                        recovery.prevInventorySize = -1;
+                        hint = undefined;
+                        continue;
+                    }
+                    this.lastPostVerifyDoneReason =
+                        `[stuck_loop] planner repeated credential/payment actions (${recovery.recentCredentialActionSignatures.slice(-5).join(" → ")}) with no usable credential and no fallback URL remaining.`;
+                    args.steps.push(`Post-verify: credential-action cycle unresolvable — breaking out with planner_stuck.`);
+                    break;
+                }
+            }
             // Record the kind of the step we're ABOUT to execute (all re-plan
             // `continue` guards are behind us here) so next round can judge
             // whether it changed the page — the stalled-wizard breaker above.
@@ -11983,6 +12419,16 @@ Prefer items naming keys / tokens / API / developer / secrets; then credentials
                 }
             }
         }
+        // Salvage the synthesis path. The bot's credential-tracker / background
+        // extraction can populate `credentials` without a planner `extract` action
+        // ever running — the loop then ends on a `done`/`click`, so the on-disk
+        // capture has no extract round and the synthesizer REJECTS it
+        // (no_extract_step) even though the run SUCCEEDED. MEASURED 2026-06-24
+        // (serpapi/galileo/mailjet: extracted api_key, last round was `done`, skill
+        // never promoted). When we're about to return a real credential but no
+        // extract round was captured this run, write one for the final page so the
+        // success becomes a replayable skill instead of an OF#2-only win.
+        await this.salvageExtractCaptureIfNeeded(args.service, credentials, oauth);
         return credentials;
     }
     // 0.8.3-rc.1 — write a single synthetic extract round when the
@@ -12000,6 +12446,23 @@ Prefer items naming keys / tokens / API / developer / secrets; then credentials
     //
     // Best-effort: a capture failure here must NEVER block returning
     // the credential we already have.
+    // Salvage the synthesis path for ANY successful exit (not just the post-verify
+    // loop). When a run returns a real credential but no `extract` round was
+    // captured — the form-fill+email path (mailjet) returns before the post-verify
+    // loop ever runs, so its salvage never fires — write a synthetic extract round
+    // for the final page so the success becomes a replayable skill. Gated on
+    // hasCapturedAnyRound: a LONE extract round (no captured nav/OAuth steps — the
+    // no_rounds class, e.g. galileo's OAuth-fast-path) can't be replayed and would
+    // synth-reject anyway, so don't write one. Idempotent via hasCapturedExtractRound.
+    async salvageExtractCaptureIfNeeded(service, credentials, oauth) {
+        if (!hasAnyExtractedCredential(credentials))
+            return;
+        if (hasCapturedExtractRound(service))
+            return;
+        if (!hasCapturedAnyRound(service))
+            return;
+        await this.writeFastPathSyntheticCapture(service, nextCaptureRound(service), oauth, "salvage synthetic extract — credential captured on a non-post-verify exit; no planner extract round ran");
+    }
     async writeFastPathSyntheticCapture(service, capturedRound, oauth, reason = "fast-path synthetic extract — credentials were already on the page before any planner round ran") {
         try {
             const [state, inventory] = await Promise.all([