@trusty-squire/mcp 0.8.2-rc.8 → 0.8.2

package/dist/bot/agent.js

@@ -145,6 +145,136 @@ export class LLMCallBudgetExceeded extends Error {
         this.name = "LLMCallBudgetExceeded";
     }
 }
+// 0.8.2-rc.10 — common dashboard paths that vendors host their
+// per-account API key UI at. Ordered most-specific first so a
+// fallback navigate doesn't land short of the actual page. Returned
+// as an array of path-strings; the caller composes them onto the
+// origin of the currently-stuck URL and skips any already tried.
+//
+// Patterns harvested from Anthropic (settings/keys), Sentry
+// (settings/account/api/auth-tokens), Neon (settings#api-keys),
+// Render (account/api-keys), Postmark (account/api_tokens),
+// OpenRouter (keys), and a long tail of vendors converging on the
+// same conventions.
+const STUCK_LOOP_FALLBACK_PATHS = [
+    "/settings/keys",
+    "/settings/api-keys",
+    "/settings/api_keys",
+    "/settings/tokens",
+    "/settings/api-tokens",
+    "/settings/account/api/auth-tokens/",
+    "/account/api-keys",
+    "/account/api_tokens",
+    "/account/keys",
+    "/account/tokens",
+    "/api-keys",
+    "/api_keys",
+    "/keys",
+    "/tokens",
+    "/auth-tokens",
+    "/dashboard/api-keys",
+    "/dashboard/keys",
+];
+// 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
+// batches; subsequent runs land on a dashboard whose API-keys page
+// shows only the NAMES of existing keys (the values were revealed
+// once at create-time and aren't recoverable). Without this
+// classifier those runs fall through to a generic
+// oauth_onboarding_failed and the harvester treats them like a
+// repairable bug.
+//
+// Conservative rules: must be on a URL that names an API-key page
+// (keys / api-keys / api-tokens / auth-tokens / api_keys), AND the
+// page text shows BOTH a masking glyph pattern (•••, ***, ─•) AND
+// an existing-key word, OR the planner's last reason explicitly
+// describes the same shape.
+const EXISTING_KEY_URL_HINT = /(?:api[-_/]keys?|api[-_/]tokens?|auth[-_/]tokens?|personal[-_/]access[-_/]tokens?|\/keys(?:\b|\/|$)|\/tokens(?:\b|\/|$)|\/settings\/keys\b|\/settings\/tokens\b|#api[-_/]keys\b|#api[-_/]tokens\b)/i;
+const MASKED_KEY_GLYPHS = /(?:•{3,}|\*{3,}|─•|·{3,}|•{3,}|x{6,}|[A-Za-z0-9]{2,4}[•*]{5,})/;
+// 0.8.2-rc.12 — widened to catch Neon's existing-key list shape
+// (the per-row layout has a "Key name" header + "Created <date>" +
+// "Last used <date|never>" — no glyph, no "existing" word, just the
+// columns of an API-key listing table). The conservative AND with
+// EXISTING_KEY_URL_HINT keeps this from misfiring on marketing copy
+// elsewhere on a non-keys URL.
+const EXISTING_KEY_WORDS = /\b(?:existing\s+(?:api\s+)?(?:key|token)|previously\s+created|created\s+by\b|api\s+keys?\s*\(\d+\)|tokens?\s*\(\d+\)|reveal|copy\s+key|key\s+name\b|last\s+used\b|created(?:\s+\w+){0,3}\s+(?:\d{1,2},?\s+)?\d{4}\b)/i;
+const NO_CREATE_AFFORDANCE_HINT = /\b(?:cannot\s+(?:reveal|extract|read)|values?\s+(?:is\s+)?masked|only\s+shown\s+once|cannot\s+(?:see|view|copy)\s+(?:the\s+)?(?:key|secret|value)|key\s+(?:value|secret)\s+(?:is\s+)?(?:not\s+)?(?:available|recoverable|extractable|shown))\b/i;
+export function detectExistingAccountNoExtract(input) {
+    if (!EXISTING_KEY_URL_HINT.test(input.url))
+        return false;
+    // Planner reason naming the no-reveal shape is the strongest single
+    // signal — the planner has SEEN the page and is describing it.
+    if (NO_CREATE_AFFORDANCE_HINT.test(input.lastPlannerReason)) {
+        return true;
+    }
+    // 0.8.2-rc.12 — three independent positive paths, ANY of which is
+    // enough since we already gated on the URL matching an API-keys
+    // page (which alone weeds out the marketing-tile false-positives
+    // the conservative pre-rc.12 path was protecting against):
+    //   1. Mask glyphs in the page (•••, asterisks, ··· — the literal
+    //      "value is hidden" decoration most vendors use).
+    //   2. Two or more existing-key word patterns matched (a key
+    //      LISTING shape: "Key name" + "Last used" + "Created <date>"
+    //      is unmistakable when found on a /keys-style URL).
+    //   3. Mask glyph PLUS any existing-key word (the original
+    //      detector — keeps the conservative behavior for vendors
+    //      whose listing UI uses different column labels).
+    const hasMaskGlyph = MASKED_KEY_GLYPHS.test(input.pageText);
+    // Tally up to 5 distinct existing-key signals; 2+ is enough.
+    const existingKeyMatches = [];
+    const allWords = input.pageText.match(new RegExp(EXISTING_KEY_WORDS, "gi"));
+    if (allWords !== null) {
+        const distinct = new Set();
+        for (const m of allWords) {
+            distinct.add(m.toLowerCase().replace(/\s+/g, " "));
+            if (distinct.size >= 5)
+                break;
+        }
+        existingKeyMatches.push(...distinct);
+    }
+    if (hasMaskGlyph && existingKeyMatches.length >= 1)
+        return true;
+    if (existingKeyMatches.length >= 2)
+        return true;
+    if (hasMaskGlyph && /\bAPI\s+keys?\b/i.test(input.pageText))
+        return true;
+    return false;
+}
+// Pick the next fallback URL to try from STUCK_LOOP_FALLBACK_PATHS
+// keyed against the origin of the currently-stuck URL. Returns null
+// when every path has already been attempted. Exported for unit tests.
+export function pickStuckLoopFallbackUrl(currentUrl, alreadyTried) {
+    let origin;
+    try {
+        origin = new URL(currentUrl).origin;
+    }
+    catch {
+        return null;
+    }
+    // Skip a candidate when the current URL's path ALREADY matches it
+    // (case-insensitive, trailing-slash tolerant). The planner is stuck
+    // ON the page the candidate points to — navigating to the same URL
+    // again won't break the cycle, only a different path will.
+    const currentPath = (() => {
+        try {
+            return new URL(currentUrl).pathname.replace(/\/+$/, "").toLowerCase();
+        }
+        catch {
+            return "";
+        }
+    })();
+    for (const path of STUCK_LOOP_FALLBACK_PATHS) {
+        const candidate = `${origin}${path}`;
+        if (alreadyTried.has(candidate))
+            continue;
+        const candidatePath = path.replace(/\/+$/, "").toLowerCase();
+        if (candidatePath === currentPath)
+            continue;
+        return candidate;
+    }
+    return null;
+}
 // Best-effort canonical signup URL for a service when the caller
 // didn't pass one. Most dev-SaaS targets (Resend, Postmark, Mailgun,
 // MailerSend, IPInfo, Stripe, PostHog) live at <name>.com/signup —
@@ -1461,6 +1591,43 @@ export function extractAllLabeledTokensFromReason(reason, pageText) {
 function escapeRegex(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+// Keys that the postVerifyLoop's accumulator stores for housekeeping —
+// they're NOT extracted credentials and must NOT count as "we found
+// something" when deciding whether an extract round succeeded.
+const NON_CREDENTIAL_KEYS = new Set([
+    "api_key_truncated", // truncated stub from extractCredentials Pass 1
+    "password", // signup form metadata (email-verification path)
+    "email", // signup form metadata
+]);
+// True iff the credentials Record holds at least one extracted value
+// (api_key, username, or any labeled multi-cred field). Excludes
+// metadata + truncated stubs. Used to decide "this extract round
+// produced something — continue the loop / capture a synthetic extract
+// round" vs "every tier missed — try the planner-quoted fallback".
+export function hasAnyExtractedCredential(creds) {
+    for (const key of Object.keys(creds)) {
+        if (NON_CREDENTIAL_KEYS.has(key))
+            continue;
+        return true;
+    }
+    return false;
+}
+// True iff the credentials Record contains a multi-credential bundle
+// — anything beyond the legacy single api_key/username pair. Used by
+// the post-verify loop's early-exit so a partial multi-cred capture
+// doesn't return prematurely (Cloudinary's api_key surfaces 4-5
+// rounds before api_secret; the legacy exit fired the moment api_key
+// was set, losing cloud_name + api_secret).
+export function isMultiCredBundle(creds) {
+    for (const key of Object.keys(creds)) {
+        if (NON_CREDENTIAL_KEYS.has(key))
+            continue;
+        if (key === "api_key" || key === "username")
+            continue;
+        return true;
+    }
+    return false;
+}
 export function extractApiKeyFromText(text) {
     const prefixed = [
         /\bre_[a-zA-Z0-9_]{20,}\b/, // Resend (key body contains underscores)
@@ -2766,6 +2933,34 @@ export class SignupAgent {
                             ...this.resultTail(),
                         };
                     }
+                    // 0.8.2-rc.10 — same sentinel-pattern routing the runOAuthFlow
+                    // path uses. The post-verify loop sets lastPostVerifyDoneReason
+                    // with [stuck_loop] or [existing_account_no_extract] markers
+                    // when it bails on a planner-loop or pre-existing-key state;
+                    // surface those distinctly rather than as the generic
+                    // no_credentials_after_already_signed_in.
+                    if (this.lastPostVerifyDoneReason !== null &&
+                        this.lastPostVerifyDoneReason.startsWith("[stuck_loop]")) {
+                        return {
+                            success: false,
+                            error: `planner_stuck: ${task.service}'s dashboard re-picked the same step repeatedly ` +
+                                `with no inventory change and the bot's hardcoded API-key URL fallbacks did not ` +
+                                `advance the page — finish the signup manually.`,
+                            steps,
+                            ...this.resultTail(),
+                        };
+                    }
+                    if (this.lastPostVerifyDoneReason !== null &&
+                        this.lastPostVerifyDoneReason.startsWith("[existing_account_no_extract]")) {
+                        return {
+                            success: false,
+                            error: `existing_account_no_extract: ${task.service}'s dashboard shows pre-existing API ` +
+                                `keys for this identity but the values are masked and unrecoverable — wipe the ` +
+                                `test identity's account on ${task.service} or sign in manually and reveal the key.`,
+                            steps,
+                            ...this.resultTail(),
+                        };
+                    }
                     return {
                         success: false,
                         error: "no_credentials_after_already_signed_in: bot detected an authenticated dashboard " +
@@ -3359,14 +3554,20 @@ export class SignupAgent {
             }
         }
         let credentials = await this.extractCredentials();
-        if (credentials.api_key === undefined) {
-            credentials = await this.postVerifyLoop({
-                service: task.service,
-                maxRounds: task.postVerifyMaxRounds ?? 12,
-                steps,
-                ...(task.scopeHint !== undefined ? { scopeHint: task.scopeHint } : {}),
-            });
-        }
+        // 0.8.2-rc.15 — always enter postVerifyLoop. The legacy short-
+        // circuit ("only call postVerifyLoop if api_key wasn't already
+        // visible") returned early on multi-cred services that happen to
+        // land with api_key plain-visible — cloud_name + api_secret on
+        // Cloudinary, application_id + admin_api_key on Algolia — and the
+        // siblings were never extracted. postVerifyLoop's top-of-iter
+        // early-exit is itself multi-cred-aware (rc.13), so when there's
+        // nothing more to do, it returns on the first iteration.
+        credentials = await this.postVerifyLoop({
+            service: task.service,
+            maxRounds: task.postVerifyMaxRounds ?? 12,
+            steps,
+            ...(task.scopeHint !== undefined ? { scopeHint: task.scopeHint } : {}),
+        });
         if (credentials.api_key !== undefined) {
             return {
                 success: true,
@@ -3412,6 +3613,41 @@ export class SignupAgent {
                 ...this.resultTail(),
             };
         }
+        // 0.8.2-rc.10 — planner stuck-loop, fallback URLs exhausted. The
+        // postVerifyLoop marks this with the [stuck_loop] sentinel so the
+        // operator sees a distinct status (it's not an "OAuth onboarding"
+        // failure — OAuth succeeded; the planner got stuck on the
+        // post-OAuth navigation).
+        if (this.lastPostVerifyDoneReason !== null &&
+            this.lastPostVerifyDoneReason.startsWith("[stuck_loop]")) {
+            return {
+                success: false,
+                error: `planner_stuck: ${task.service}'s post-OAuth dashboard re-picked the same step ` +
+                    `repeatedly with no inventory change and the bot's hardcoded API-key URL fallbacks ` +
+                    `did not advance the page — finish the signup manually.`,
+                steps,
+                ...this.resultTail(),
+            };
+        }
+        // 0.8.2-rc.10 — existing-account state with no extractable
+        // credential. The postVerifyLoop's existing-key detector
+        // (detectExistingAccountNoExtract) classifies a run that lands on
+        // an authenticated dashboard whose API-keys page surfaces only
+        // masked existing keys + no path to a fresh value. Surfacing this
+        // distinctly so the harvester can flag it (e.g. periodically wipe
+        // the chrome profile for the test identity) rather than treat it
+        // as a real bot failure.
+        if (this.lastPostVerifyDoneReason !== null &&
+            this.lastPostVerifyDoneReason.startsWith("[existing_account_no_extract]")) {
+            return {
+                success: false,
+                error: `existing_account_no_extract: ${task.service}'s dashboard shows pre-existing API ` +
+                    `keys for this identity but the values are masked and unrecoverable — wipe the ` +
+                    `test identity's account on ${task.service} or sign in manually and reveal the key.`,
+                steps,
+                ...this.resultTail(),
+            };
+        }
         return {
             success: false,
             error: `oauth_onboarding_failed: signed in to ${task.service} via ${provider.label} but ` +
@@ -3690,6 +3926,26 @@ ${formatInventory(input.inventory)}`,
     }
     async postVerifyLoop(args) {
         let credentials = await this.extractCredentials();
+        // 0.8.2-rc.15 — also seed DOM-proximity at loop entry. If the
+        // bot lands directly on the api-keys page (Cloudinary navigates
+        // through onboarding to the dashboard automatically, sometimes
+        // landing on /settings/api-keys), labeled siblings are visible
+        // immediately and the loop's top-of-iter check (which respects
+        // isMultiCredBundle) can hold the loop open for the planner to
+        // emit an explicit extract. Without this seed, only api_key
+        // would be set on entry and isMultiCredBundle would return
+        // false → loop exits with a partial bundle.
+        try {
+            const labeledSeed = await this.extractFromDomProximity();
+            for (const [k, v] of Object.entries(labeledSeed)) {
+                if (credentials[k] === undefined)
+                    credentials[k] = v;
+            }
+        }
+        catch {
+            // Non-fatal — the planner's explicit extract round will run
+            // DOM-proximity again, this is just an opportunistic seed.
+        }
         let loginAttempts = 0;
         let planFailures = 0;
         // 0.8.2-rc.6 — separate counter for upstream-blip retries. Doesn't
@@ -3760,6 +4016,26 @@ ${formatInventory(input.inventory)}`,
         // navigate produced no progress. Inject a hint forcing a CLICK
         // on something visible in the current inventory.
         let prevNavigateFromUrl = null;
+        // 0.8.2-rc.10 — escalation for the stuck-loop detector.
+        //
+        // The existing detector injects a re-plan hint when the planner
+        // returns the same kind+selector twice with no inventory change,
+        // but the planner often ignores the "pick a different KIND" hint
+        // and just picks a slightly different SELECTOR for another click.
+        // Anthropic's batch failure (rc.8) showed 6 wasted rounds of this
+        // before a navigate finally broke the cycle: clicking the sidebar
+        // "API Keys" link on a dashboard that wasn't routing to it.
+        //
+        // Escalation strategy: after N stuck-fires within the SAME URL,
+        // try a hard navigate to a guessed API-keys URL (one per origin).
+        // If the URL has already advanced past the stuck zone, reset the
+        // counter. After every fallback URL is exhausted AND we're still
+        // stuck, mark the run [stuck_loop] so the caller surfaces the
+        // dedicated error code instead of the generic
+        // oauth_onboarding_failed.
+        let stuckFiresAtUrl = 0;
+        let lastStuckFireUrl = null;
+        const triedFallbackUrls = new Set();
         // 0.8.1 — capture chain index is independent of the planner loop
         // round. The loop has two early-`continue` paths (page mid-navigation
         // throw, planner-rejection re-plan) that increment `round` WITHOUT
@@ -3771,11 +4047,60 @@ ${formatInventory(input.inventory)}`,
         // contiguous 0..N-1 chain regardless of how many planner re-plans
         // happen mid-run.
         let capturedRound = 0;
+        // 0.8.2-rc.12 — multi-cred-aware loop exit. Track the number of
+        // distinct credential keys we've accumulated; if we're in a
+        // multi-cred bundle (cloud_name, api_secret, application_id, …)
+        // keep planning past the first api_key surfacing so siblings can
+        // accumulate. Bounded by `roundsSinceLastNewCredential` so a
+        // page that never produces a sibling doesn't loop forever.
+        let lastCredentialKeyCount = Object.keys(credentials).filter((k) => !NON_CREDENTIAL_KEYS.has(k)).length;
+        let roundsSinceLastNewCredential = 0;
+        const MAX_ROUNDS_AWAITING_MORE_CREDENTIALS = 3;
+        // 0.8.2-rc.16 — when the loop's pre-entry seed already had a
+        // credential (Cloudinary's billing/plans page exposes the api_key
+        // via a hidden field that extractCredentials catches), we cannot
+        // trust that result as authoritative for multi-cred: the bot
+        // hasn't navigated to a labeled api-keys page yet, so cloud_name
+        // + api_secret are not yet visible to extractFromDomProximity.
+        // Hold the loop open until the planner has issued at least one
+        // explicit extract step — only then has the bot affirmatively
+        // surveyed the labeled credentials surface.
+        const seedHadCredential = credentials.api_key !== undefined || credentials.username !== undefined;
+        let plannerExtractEmitted = false;
         for (let round = 0; round < args.maxRounds; round++) {
-            if (credentials.api_key !== undefined || credentials.username !== undefined) {
+            const currentCredentialKeyCount = Object.keys(credentials).filter((k) => !NON_CREDENTIAL_KEYS.has(k)).length;
+            if (currentCredentialKeyCount > lastCredentialKeyCount) {
+                roundsSinceLastNewCredential = 0;
+                lastCredentialKeyCount = currentCredentialKeyCount;
+            }
+            else if (lastCredentialKeyCount > 0) {
+                roundsSinceLastNewCredential += 1;
+            }
+            // Multi-cred services hold the loop open until either the
+            // planner returns `done`, the budget expires, or we've made
+            // no credential progress for MAX_ROUNDS_AWAITING_MORE_CREDENTIALS
+            // consecutive rounds. Single-cred services keep the legacy
+            // behavior of returning the moment api_key surfaces — EXCEPT
+            // when the api_key came from the pre-loop seed and the
+            // planner hasn't yet emitted an explicit extract step. In
+            // that case we let the planner run until extract fires.
+            const inMultiCredMode = isMultiCredBundle(credentials);
+            const haveOnlySeedCredentials = seedHadCredential && !plannerExtractEmitted;
+            if (!inMultiCredMode &&
+                (credentials.api_key !== undefined || credentials.username !== undefined) &&
+                !haveOnlySeedCredentials) {
                 args.steps.push(`Post-verify: credentials found on round ${round}.`);
                 return credentials;
             }
+            if (inMultiCredMode &&
+                roundsSinceLastNewCredential >= MAX_ROUNDS_AWAITING_MORE_CREDENTIALS &&
+                (credentials.api_key !== undefined || credentials.username !== undefined)) {
+                const summary = Object.keys(credentials)
+                    .filter((k) => !NON_CREDENTIAL_KEYS.has(k))
+                    .join(", ");
+                args.steps.push(`Post-verify: multi-cred bundle stable for ${roundsSinceLastNewCredential} rounds — returning what we have (${summary}).`);
+                return credentials;
+            }
             // Settle the page first — the previous round's click may have
             // triggered a navigation, and reading a page mid-navigation
             // throws "execution context destroyed". waitForFormReady is
@@ -4068,6 +4393,94 @@ ${formatInventory(input.inventory)}`,
                     const uncheckedBoxHint = uncheckedBoxes.length > 0
                         ? `\n\nVisible checkboxes you haven't ticked yet (often a TOS / agreement gate):\n${uncheckedBoxes.join("\n")}\n\nIssue {"kind":"check"} on any that look like agreements / required confirmations.`
                         : "";
+                    // 0.8.2-rc.10 — escalation. Track stuck-fires per URL so we
+                    // can switch tactics once the gentle re-plan hint has clearly
+                    // failed (the planner refuses to break the cycle on its own,
+                    // see the Anthropic six-round pattern in rc.8).
+                    if (lastStuckFireUrl === state.url) {
+                        stuckFiresAtUrl += 1;
+                    }
+                    else {
+                        stuckFiresAtUrl = 1;
+                        lastStuckFireUrl = state.url;
+                    }
+                    // After two stuck fires at the same URL, escalate to a
+                    // hardcoded /settings/keys-style navigation. Vendors almost
+                    // always have ONE canonical path; the dashboard often gates
+                    // it behind a sidebar link the planner can't reliably resolve
+                    // (Anthropic, Neon, Sentry, Mistral, …). The fallback list is
+                    // ordered most-specific first so a service whose dashboard
+                    // root happens to share /settings with the API-keys page
+                    // doesn't land short of the actual page.
+                    if (stuckFiresAtUrl >= 2) {
+                        // 0.8.2-rc.12 — when the bot is ALREADY on a URL that names
+                        // an API-keys page (path contains /keys, /tokens, /api-keys,
+                        // etc.) AND the page text shows masked-credential markers,
+                        // the dashboard is genuinely showing a pre-existing key
+                        // we can't unmask (Neon's `ts-7229` is the canonical case —
+                        // the value was revealed once at create-time and is gone).
+                        // Skip the fallback-URL navigate entirely (it would land
+                        // on a 404 for vendors whose api-keys page lives at an
+                        // org-scoped URL like `/app/<org>/settings#api-keys`) and
+                        // classify as existing_account_no_extract directly.
+                        try {
+                            const stuckPageText = await this.browser
+                                .extractText()
+                                .catch(() => "");
+                            if (detectExistingAccountNoExtract({
+                                url: state.url,
+                                pageText: stuckPageText,
+                                lastPlannerReason: nextStep.reason,
+                            })) {
+                                this.lastPostVerifyDoneReason =
+                                    `[existing_account_no_extract] stuck-loop at ${state.url} on an existing API-keys page with masked credentials; ` +
+                                        `latest planner reason: ${nextStep.reason}`;
+                                args.steps.push(`Post-verify: stuck-loop on an existing-keys page — classified as existing_account_no_extract, breaking out.`);
+                                break;
+                            }
+                        }
+                        catch {
+                            // best-effort — fall through to the regular fallback path
+                            // if the page-text read failed.
+                        }
+                        const fallback = pickStuckLoopFallbackUrl(state.url, triedFallbackUrls);
+                        if (fallback !== null) {
+                            triedFallbackUrls.add(fallback);
+                            args.steps.push(`Post-verify: stuck-loop detected ${stuckFiresAtUrl}x at ${state.url} — escalating to a hardcoded API-key URL: ${fallback}`);
+                            try {
+                                await this.browser.goto(fallback);
+                                await this.browser.waitForInteractiveDom(5, 15_000);
+                            }
+                            catch (err) {
+                                args.steps.push(`Post-verify: stuck-loop fallback navigate failed (${err instanceof Error ? err.message : String(err)}) — continuing.`);
+                            }
+                            // Reset signature tracking so the next round starts clean
+                            // against the new URL's inventory. Don't reset
+                            // stuckFiresAtUrl here — it's keyed by URL and the URL
+                            // about to be observed will be different, which naturally
+                            // resets it on the next loop entry.
+                            prevSignature = null;
+                            prevInventorySize = -1;
+                            hint = undefined;
+                            // Don't bump capturedRound — captureOnboardingRound above
+                            // already wrote a capture for this round (the stuck-loop
+                            // detector runs AFTER the capture, so the planner's
+                            // observed step IS on disk). Bumping again here would
+                            // leave a phantom gap in the chain that verifyCaptureChain
+                            // rejects as missing_round.
+                            continue;
+                        }
+                        // Every plausible fallback URL has been tried and we're
+                        // still stuck. Mark with the [stuck_loop] sentinel so the
+                        // caller surfaces planner_stuck instead of the generic
+                        // oauth_onboarding_failed, then break out of the loop.
+                        this.lastPostVerifyDoneReason =
+                            `[stuck_loop] planner re-picked the same ${nextStep.kind} step ${stuckFiresAtUrl} times at ${state.url} with no inventory change; ` +
+                                `hardcoded API-key URL fallbacks exhausted (tried: ${[...triedFallbackUrls].join(", ") || "none"}). ` +
+                                `Latest planner reason: ${nextStep.reason}`;
+                        args.steps.push(`Post-verify: stuck-loop unresolvable — breaking out with planner_stuck.`);
+                        break;
+                    }
                     args.steps.push(sameSelector
                         ? `Post-verify: no-progress detected — same ${nextStep.kind} on same selector, inventory unchanged. Re-planning instead of re-running.`
                         : `Post-verify: no-progress detected — successive click steps with no inventory change. Forcing a non-click action.`);
@@ -4137,126 +4550,128 @@ ${formatInventory(input.inventory)}`,
             hint = undefined;
             try {
                 if (nextStep.kind === "extract") {
-                    credentials = await this.extractCredentials();
-                    if (credentials.api_key === undefined) {
-                        // rc.28 — planner-quoted-token fallback. The regex
-                        // library missed (IPInfo's 14-char hex; some other
-                        // shape) but the planner's reason often literally
-                        // quotes the value. Accept it IF it's also present
-                        // verbatim in the visible page text — that's the
-                        // anti-hallucination guardrail.
-                        // rc.38 — verify the planner-quoted value against both
-                        // visible text AND every input's `value` attribute. The
-                        // rc.37 Upstash retest showed the bot quoting a bare UUID
-                        // it observed in a create-key modal whose UUID lived in
-                        // an <input readonly value="…"> — textContent doesn't
-                        // include input values, so the verbatim-in-page check
-                        // rejected a real credential. Concatenating input values
-                        // closes the gap without weakening the anti-hallucination
-                        // guarantee (the candidate still has to appear SOMEWHERE
-                        // verifiable on the page).
-                        const [pageText, inputValues] = await Promise.all([
-                            this.browser.extractText().catch(() => ""),
-                            this.browser.extractAllInputValues().catch(() => []),
-                        ]);
-                        const verifySource = pageText + "\n" + inputValues.join("\n");
-                        // Phase E — multi-cred-aware extraction. Try the labeled
-                        // multi-credential parser FIRST. If the planner labeled
-                        // 2+ distinct credentials in its reason, fold them all
-                        // into the credentials Record. If the parser found at
-                        // least one new value (cloud_name, api_secret, etc. —
-                        // anything beyond the single api_key the legacy path
-                        // captures), prefer this. Falls through to the single-
-                        // value extractQuotedTokenFromReason when no labeled
-                        // tokens parsed (single-cred services, ad-hoc planner
-                        // prose without explicit labels).
-                        const labeled = extractAllLabeledTokensFromReason(nextStep.reason, verifySource);
-                        const labeledKeys = Object.keys(labeled);
-                        if (labeledKeys.length >= 2 || (labeledKeys.length === 1 && labeled["api_key"] === undefined)) {
-                            credentials = { ...credentials, ...labeled };
-                            const summary = labeledKeys
-                                .map((k) => `${k}=${labeled[k].slice(0, 4)}…${labeled[k].slice(-4)}`)
-                                .join(", ");
-                            args.steps.push(`Post-verify ${round + 1}/${args.maxRounds}: extracted ${labeledKeys.length} labeled credential(s) ` +
-                                `via Phase E parser (${summary})`);
-                            // When the planner's reason explicitly flags a masked
-                            // credential ("api_secret is masked", "hidden behind
-                            // asterisks", "click Reveal to show"), Phase E only
-                            // captured the visible values — try to reveal + extract
-                            // the rest on the same round before continuing. Without
-                            // this, the loop returns success with a partial bundle
-                            // and never tries the reveal click.
-                            const MASKED_HINT = /\b(?:masked|hidden|bullets?|asterisks?|••+|\*{3,}|reveal|unmask)\b/i;
-                            if (MASKED_HINT.test(nextStep.reason)) {
-                                try {
-                                    const revealRes = await this.browser.revealMaskedCredentials();
-                                    args.steps.push(`Post-verify ${round + 1}/${args.maxRounds}: reveal pass clicked=${revealRes.clicked} diagnostic=[${revealRes.diagnostic.join("; ")}]`);
-                                    if (revealRes.clicked > 0) {
-                                        const labeledAfter = await this.extractFromDomProximity();
-                                        const newKeys = Object.keys(labeledAfter).filter((k) => credentials[k] === undefined);
-                                        if (newKeys.length > 0) {
-                                            for (const k of newKeys)
-                                                credentials[k] = labeledAfter[k];
-                                            args.steps.push(`Post-verify ${round + 1}/${args.maxRounds}: post-reveal DOM-proximity extracted ${newKeys.length} more (${newKeys.join(", ")})`);
-                                        }
-                                        else {
-                                            // Surface ALL labeled candidates we found, so
-                                            // we can see whether the value is on-page but
-                                            // mislabeled vs. genuinely not surfaced.
-                                            const allLabeled = await this.browser.extractLabeledCredentialCandidates();
-                                            const summary = allLabeled
-                                                .filter((c) => !c.isMasked)
-                                                .slice(0, 8)
-                                                .map((c) => `${c.value.slice(0, 6)}…(${c.value.length}ch)/${c.label ?? "no-label"}`)
-                                                .join(", ");
-                                            args.steps.push(`Post-verify ${round + 1}/${args.maxRounds}: post-reveal had ${allLabeled.length} candidates; visible: ${summary}`);
-                                        }
-                                    }
+                    // rc.16 — record that the planner has now affirmatively
+                    // asked to extract from the current page. The top-of-iter
+                    // early-exit consults this to distinguish "api_key came
+                    // from a hidden field on a billing page" (don't exit) from
+                    // "api_key came from a labeled credential row the planner
+                    // just observed" (safe to exit on single-cred services).
+                    plannerExtractEmitted = true;
+                    // 0.8.2-rc.12 — multi-cred preservation + always-on Phase E.
+                    //
+                    // Pre-rc.12 the extract step was a tower of "if no api_key,
+                    // try Phase E; else done." That short-circuit silently lost
+                    // cloud_name + api_secret on Cloudinary-class services whose
+                    // api_key is plain-visible to the legacy regex extractor —
+                    // the legacy path filled credentials.api_key, the if-branch
+                    // skipped Phase E entirely, and the loop's top-of-iter exit
+                    // returned a partial bundle.
+                    //
+                    // New shape: run the legacy extractor, Phase E, the reveal
+                    // pass, and DOM-proximity UNCONDITIONALLY on every extract
+                    // round, merging each into `credentials` first-wins. A later
+                    // pass never clobbers a value an earlier pass labeled. This
+                    // mirrors the design doc: Phase E is the multi-cred surface;
+                    // single-cred is just multi-cred-with-one-key.
+                    const [pageText, inputValues] = await Promise.all([
+                        this.browser.extractText().catch(() => ""),
+                        this.browser.extractAllInputValues().catch(() => []),
+                    ]);
+                    const verifySource = pageText + "\n" + inputValues.join("\n");
+                    // Tier 1 — legacy single-cred extractor (api_key by shape).
+                    // Merge into the running accumulator instead of overwriting;
+                    // a Phase E label captured on a prior round wins over a
+                    // later legacy regex hit.
+                    const legacy = await this.extractCredentials();
+                    for (const [k, v] of Object.entries(legacy)) {
+                        if (credentials[k] === undefined)
+                            credentials[k] = v;
+                    }
+                    // Tier 2 — Phase E labeled-token parser over the planner's
+                    // reason. Picks up cloud_name='dlq4xgrca' / api_key='4917…'
+                    // / application_id='X' / admin_api_key='…' style narrative.
+                    const labeled = extractAllLabeledTokensFromReason(nextStep.reason, verifySource);
+                    const labeledNewKeys = Object.keys(labeled).filter((k) => credentials[k] === undefined);
+                    if (labeledNewKeys.length > 0) {
+                        for (const k of labeledNewKeys)
+                            credentials[k] = labeled[k];
+                        const summary = labeledNewKeys
+                            .map((k) => `${k}=${labeled[k].slice(0, 4)}…${labeled[k].slice(-4)}`)
+                            .join(", ");
+                        args.steps.push(`Post-verify ${round + 1}/${args.maxRounds}: Phase E surfaced ${labeledNewKeys.length} labeled credential(s) (${summary})`);
+                    }
+                    // Tier 2.5 — reveal-then-extract when the planner explicitly
+                    // flagged a masked credential. Fires whether or not we
+                    // already have other credentials — Cloudinary's api_secret
+                    // sits beside an already-visible api_key in the table.
+                    const MASKED_HINT = /\b(?:masked|hidden|bullets?|asterisks?|••+|\*{3,}|reveal|unmask)\b/i;
+                    if (MASKED_HINT.test(nextStep.reason)) {
+                        try {
+                            const revealRes = await this.browser.revealMaskedCredentials();
+                            args.steps.push(`Post-verify ${round + 1}/${args.maxRounds}: reveal pass clicked=${revealRes.clicked} diagnostic=[${revealRes.diagnostic.join("; ")}]`);
+                            if (revealRes.clicked > 0) {
+                                const labeledAfter = await this.extractFromDomProximity();
+                                const afterNewKeys = Object.keys(labeledAfter).filter((k) => credentials[k] === undefined);
+                                if (afterNewKeys.length > 0) {
+                                    for (const k of afterNewKeys)
+                                        credentials[k] = labeledAfter[k];
+                                    args.steps.push(`Post-verify ${round + 1}/${args.maxRounds}: post-reveal DOM-proximity extracted ${afterNewKeys.length} more (${afterNewKeys.join(", ")})`);
                                 }
-                                catch (err) {
-                                    args.steps.push(`Post-verify ${round + 1}/${args.maxRounds}: reveal pass error (${err instanceof Error ? err.message : String(err)})`);
+                                else {
+                                    // Diagnostic: which candidates were seen on the page?
+                                    // Helps debug "Reveal click landed but the value
+                                    // didn't appear in proximity to a known label".
+                                    const allLabeled = await this.browser.extractLabeledCredentialCandidates();
+                                    const candSummary = allLabeled
+                                        .filter((c) => !c.isMasked)
+                                        .slice(0, 8)
+                                        .map((c) => `${c.value.slice(0, 6)}…(${c.value.length}ch)/${c.label ?? "no-label"}`)
+                                        .join(", ");
+                                    args.steps.push(`Post-verify ${round + 1}/${args.maxRounds}: post-reveal had ${allLabeled.length} candidates; visible: ${candSummary}`);
                                 }
                             }
-                            consecutiveFailedExtracts = 0;
-                            continue;
-                        }
-                        const quoted = extractQuotedTokenFromReason(nextStep.reason, verifySource);
-                        if (quoted !== null) {
-                            credentials = { ...credentials, api_key: quoted };
-                            args.steps.push(`Post-verify ${round + 1}/${args.maxRounds}: extracted token via ` +
-                                `planner-quoted fallback (${quoted.slice(0, 4)}…${quoted.slice(-4)})`);
-                            consecutiveFailedExtracts = 0;
-                            continue;
-                        }
-                        // Tier 4 — DOM-proximity labeled credential extraction.
-                        // Run BEFORE bailing the extract. Walks the visible DOM,
-                        // finds credential-shape strings, pairs each with its
-                        // nearest credential-label text by Euclidean center
-                        // distance. Catches multi-cred pages where the planner
-                        // mentioned ONE value but the DOM shows several (the
-                        // planner's narrative-style extract reason missed the
-                        // sibling labels). Also tries to unmask hidden secrets
-                        // first by clicking visible Reveal/Eye/Copy buttons.
-                        try {
-                            await this.browser.revealMaskedCredentials();
                         }
-                        catch {
-                            // Best-effort; never block the extract pass on a
-                            // reveal-click failure.
+                        catch (err) {
+                            args.steps.push(`Post-verify ${round + 1}/${args.maxRounds}: reveal pass error (${err instanceof Error ? err.message : String(err)})`);
                         }
+                    }
+                    // Tier 3 — DOM-proximity labeled extractor. Walks the
+                    // visible DOM, pairs credential-shape strings with their
+                    // nearest credential-label text. Catches services whose
+                    // planner-reason narrative missed sibling labels but whose
+                    // DOM still has them as <td>/<dt> pairs.
+                    try {
                         const labeledFromDom = await this.extractFromDomProximity();
-                        const newKeys = Object.keys(labeledFromDom).filter((k) => credentials[k] === undefined);
-                        if (newKeys.length > 0) {
-                            for (const k of newKeys)
+                        const domNewKeys = Object.keys(labeledFromDom).filter((k) => credentials[k] === undefined);
+                        if (domNewKeys.length > 0) {
+                            for (const k of domNewKeys)
                                 credentials[k] = labeledFromDom[k];
-                            const summary = newKeys
-                                .map((k) => {
-                                const v = labeledFromDom[k];
-                                return `${k}=${v.slice(0, 4)}…${v.slice(-4)}`;
-                            })
+                            const summary = domNewKeys
+                                .map((k) => `${k}=${labeledFromDom[k].slice(0, 4)}…${labeledFromDom[k].slice(-4)}`)
                                 .join(", ");
-                            args.steps.push(`Post-verify ${round + 1}/${args.maxRounds}: extracted ${newKeys.length} labeled credential(s) ` +
-                                `via DOM-proximity fallback (${summary})`);
+                            args.steps.push(`Post-verify ${round + 1}/${args.maxRounds}: DOM-proximity surfaced ${domNewKeys.length} more (${summary})`);
+                        }
+                    }
+                    catch {
+                        // best-effort; never abort an extract pass on DOM-proximity
+                        // failure (page mid-navigation etc).
+                    }
+                    // Anything found across all tiers? hasMultiCredCredentials
+                    // also catches non-api_key labels (cloud_name, application_id).
+                    if (hasAnyExtractedCredential(credentials)) {
+                        consecutiveFailedExtracts = 0;
+                        continue;
+                    }
+                    // True extract failure — every tier missed. Try the legacy
+                    // single-value planner-quoted fallback for services whose
+                    // planner prose just bare-quotes the value without a known
+                    // label vocabulary (Railway UUID-only, IPInfo 14-hex).
+                    {
+                        const quoted = extractQuotedTokenFromReason(nextStep.reason, verifySource);
+                        if (quoted !== null) {
+                            credentials.api_key = quoted;
+                            args.steps.push(`Post-verify ${round + 1}/${args.maxRounds}: extracted token via ` +
+                                `planner-quoted fallback (${quoted.slice(0, 4)}…${quoted.slice(-4)})`);
                             consecutiveFailedExtracts = 0;
                             continue;
                         }
@@ -4324,9 +4739,6 @@ ${formatInventory(input.inventory)}`,
                                     "generate a fresh one — its full value is shown once, on creation.";
                         }
                     }
-                    else {
-                        consecutiveFailedExtracts = 0;
-                    }
                 }
                 else if (nextStep.kind === "click") {
                     await this.browser.click(nextStep.selector);
@@ -4342,13 +4754,46 @@ ${formatInventory(input.inventory)}`,
                     // services without modal-delay returns in <1s. Saves both
                     // time (no overshoot wait) and correctness (catches the
                     // modal-render race).
+                    // 0.8.2-rc.12 — merge polled extract into the running
+                    // credentials accumulator (was previously assigned to a
+                    // throwaway `pollExtract` local). On modal-key reveal
+                    // flows (OpenRouter, Anthropic, OpenAI) the credential
+                    // appears only here, and the legacy assignment was lost
+                    // unless the next round's top-of-iter re-read just
+                    // happened to find it again — a flaky guarantee.
+                    //
+                    // 0.8.2-rc.15 — also poll DOM-proximity. A click that
+                    // reveals an api_secret next to a known label (Cloudinary
+                    // reveal click → api_secret becomes visible next to "API
+                    // Secret" text) wouldn't surface in the legacy api_key-
+                    // shaped regex, so a multi-cred reveal landed nothing
+                    // unless the explicit extract round re-fired afterward.
                     const credentialDeadline = Date.now() + 8000;
-                    let pollExtract = {};
                     while (Date.now() < credentialDeadline) {
                         await this.browser.wait(0.5);
                         try {
-                            pollExtract = await this.extractCredentials();
-                            if (pollExtract.api_key !== undefined)
+                            const pollExtract = await this.extractCredentials();
+                            for (const [k, v] of Object.entries(pollExtract)) {
+                                if (credentials[k] === undefined)
+                                    credentials[k] = v;
+                            }
+                            try {
+                                const pollLabeled = await this.extractFromDomProximity();
+                                for (const [k, v] of Object.entries(pollLabeled)) {
+                                    if (credentials[k] === undefined)
+                                        credentials[k] = v;
+                                }
+                            }
+                            catch {
+                                // DOM-proximity failure is non-fatal; we'll retry
+                                // the next tick or fall through to the next round.
+                            }
+                            // Early-exit when we have an api_key — most services'
+                            // happy path completes in <1s. Multi-cred siblings
+                            // (api_secret, cloud_name) keep accumulating across
+                            // subsequent rounds; we don't hold the inner poll for
+                            // them here.
+                            if (credentials.api_key !== undefined)
                                 break;
                         }
                         catch {
@@ -4433,9 +4878,24 @@ ${formatInventory(input.inventory)}`,
             }
             // Re-extract — but tolerate the page still navigating from the
             // step just taken; the next round settles and re-reads.
-            const hadCredentialsBefore = credentials.api_key !== undefined || credentials.username !== undefined;
+            // 0.8.2-rc.12 — MERGE into the running accumulator. The pre-
+            // rc.12 unconditional assignment wiped multi-cred fields the
+            // explicit extract round just accumulated (cloud_name, api_secret,
+            // etc.); on the next round's top-of-iter early-exit, only the
+            // legacy single api_key survived.
+            // 0.8.2-rc.12 — count distinct credential keys before re-extract
+            // so the synthetic-extract trigger fires on ANY new key, not just
+            // the legacy api_key / username pair. A cloudinary reveal click
+            // can produce a fresh api_secret while api_key was already set;
+            // the pre-rc.12 trigger silently skipped the synthetic capture
+            // and the synthesizer then rejected on no_extract_step.
+            const credCountBefore = Object.keys(credentials).filter((k) => !NON_CREDENTIAL_KEYS.has(k)).length;
             try {
-                credentials = await this.extractCredentials();
+                const reExtract = await this.extractCredentials();
+                for (const [k, v] of Object.entries(reExtract)) {
+                    if (credentials[k] === undefined)
+                        credentials[k] = v;
+                }
             }
             catch {
                 // page mid-navigation — next round's waitForFormReady handles it
@@ -4453,8 +4913,8 @@ ${formatInventory(input.inventory)}`,
             // RIGHT NOW (the action just ran, the token row is now visible).
             // Best-effort — a capture failure must never block returning the
             // credential we already have.
-            const haveNewCredentials = !hadCredentialsBefore &&
-                (credentials.api_key !== undefined || credentials.username !== undefined);
+            const credCountAfter = Object.keys(credentials).filter((k) => !NON_CREDENTIAL_KEYS.has(k)).length;
+            const haveNewCredentials = credCountAfter > credCountBefore;
             if (haveNewCredentials && nextStep.kind !== "extract") {
                 try {
                     const [postState, postInventory] = await Promise.all([
@@ -4503,6 +4963,39 @@ ${formatInventory(input.inventory)}`,
                 }
             }
         }
+        // 0.8.2-rc.10 — existing-account-no-extract classifier. Runs once
+        // at loop exit when no credential surfaced AND no more specific
+        // marker (paywall, anti-bot, stuck_loop) was already set on
+        // lastPostVerifyDoneReason. The test identity
+        // (methoxine@gmail.com) accumulates real signups across batches;
+        // re-running against the same vendor lands the bot on an
+        // authenticated dashboard whose API-keys page shows a masked
+        // pre-existing key it cannot reveal (most vendors only show the
+        // key value once at create-time). Reporting these as
+        // oauth_onboarding_failed is misleading — the bot did navigate
+        // correctly, the state is just unrecoverable for this identity.
+        const alreadyClassified = this.lastPostVerifyDoneReason !== null &&
+            this.lastPostVerifyDoneReason.startsWith("[");
+        if (credentials.api_key === undefined &&
+            credentials.username === undefined &&
+            !alreadyClassified) {
+            try {
+                const finalState = await this.browser.getState();
+                const finalText = await this.browser.extractText().catch(() => "");
+                if (detectExistingAccountNoExtract({
+                    url: finalState.url,
+                    pageText: finalText,
+                    lastPlannerReason: this.lastPostVerifyDoneReason ?? "",
+                })) {
+                    this.lastPostVerifyDoneReason =
+                        `[existing_account_no_extract] at ${finalState.url}; latest planner reason: ${this.lastPostVerifyDoneReason ?? "(none — loop exhausted)"}`;
+                    args.steps.push("Post-verify: classified as existing_account_no_extract — masked pre-existing key on an authenticated dashboard.");
+                }
+            }
+            catch {
+                // best-effort classifier — never block returning the (empty) credentials
+            }
+        }
         return credentials;
     }
     // Sign in with the credentials created during signup, so the
@@ -4602,17 +5095,30 @@ Strategy:
   return "extract" for a masked key, and do not return "extract" twice
   in a row. Instead click "Create API Key" / "New API Key" / "Generate"
   to make a fresh key, then extract its full value.
-- **REVEAL-CLICK BEFORE EXTRACT** — when a credential is shown masked
-  (•••••, asterisks, dots) AND there is a VISIBLE "Show", "Reveal",
-  "Eye", or eye-icon button NEXT TO IT (typically same row in a
-  credentials table — Cloudinary, Twilio, Stripe all follow this
-  pattern for api_secret / auth_token / secret_key), emit a CLICK
-  on that show/reveal button FIRST. Do NOT return extract on the same
-  round as the masked display — the masked text would be parsed as
-  the value. Next round the value will be visible and your extract
-  step can quote it. The bot's reveal-pass is a fallback; explicit
-  clicks via the planner are more reliable because you can see the
-  exact button in the screenshot.
+- **PARTIAL MULTI-CRED EXTRACT IS BETTER THAN ZERO** — on a multi-
+  cred page where some credentials are visible and others are masked
+  behind a Reveal button, return {"kind":"extract"} NOW for the
+  visible labels (the bot's labeled extractor folds them into the
+  credentials bundle) AND in the same reason field flag the masked
+  credential so the bot's automatic reveal pass fires. Example
+  reason for Cloudinary: "cloud_name='dlq4xgrca' and
+  api_key='491741466469613' are visible in the table; api_secret is
+  hidden behind a Reveal button — please unmask." The masked
+  credential's label MUST appear with one of the trigger words
+  (masked / hidden / reveal / unmask / bullets / asterisks) so the
+  reveal pass triggers. Do this BEFORE attempting any explicit
+  reveal click — getting the visible values into the bundle first
+  means a failed reveal click only loses the masked credential, not
+  the visible ones too.
+- **REVEAL-CLICK AS A FALLBACK** — when the page has ONLY a masked
+  credential (no visible siblings) AND there is a VISIBLE "Show",
+  "Reveal", "Eye", or eye-icon button next to it, emit a CLICK on
+  that button. If a previous reveal click had no effect (the page's
+  inventory and screenshot look identical), do NOT keep retrying —
+  emit {"kind":"extract"} anyway: the bot's labeled extractor will
+  capture whatever IS visible (even if just a cloud_name with no
+  api_secret) and return the partial bundle to the caller, which is
+  more useful than five wasted rounds of clicking a dead reveal.
 - To reach API keys, prefer a {"kind":"navigate"} straight to the
   service's API-keys settings URL — note these usually live under the
   user/ACCOUNT settings, not a project or workspace's settings.