@trusty-squire/mcp 0.8.2-rc.21 → 0.8.2-rc.4

package/dist/bot/agent.js

@@ -93,22 +93,6 @@ const ONBOARDING_PAYWALL_PATTERNS = [
     /\b(?:plan\s+|account\s+)?payment\s+required\b/i,
     /\bcomplet(?:e|ing)\s+(?:billing|payment)\b/i,
     /\bbilling\s+setup\s+(?:is\s+)?required\b/i,
-    // 0.8.2-rc.5 — Together.ai's post-OAuth landing surfaces a "payment
-    // form" gate that the post-verify planner reliably describes in its
-    // `done` reason:
-    //
-    //   "This page shows a payment form, and it's not possible to proceed
-    //    further without inputting payment information."
-    //
-    // None of the rc.39 patterns covered "payment form" / "payment
-    // information" — together fell through to `oauth_onboarding_failed`,
-    // which is misleading (the OAuth handshake succeeded; the wall is
-    // billing). Patterns are scoped to the "form/information requirement"
-    // shape so a marketing tile mentioning "payment information" doesn't
-    // false-positive.
-    /\bpayment\s+form\b/i,
-    /\binput(?:ting)?\s+payment\s+information\b/i,
-    /\benter(?:ing)?\s+payment\s+information\b/i,
 ];
 // Negators that, if they appear in the ~30 characters immediately
 // before a paywall pattern match, flip its meaning from a demand
@@ -145,136 +129,6 @@ 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 —
@@ -892,46 +746,6 @@ export function detectAlreadySignedIn(args) {
         })) {
             return true;
         }
-        // 0.8.2-rc.5 — PostHog-class onboarding wizard. When the URL is
-        // dashboard-y (path like /project/<id>/onboarding) and the page
-        // shows project-picker / account-menu / onboarding-skip
-        // affordances WITHOUT a credential input or OAuth provider button,
-        // the user is authenticated and the wizard is interstitial. The
-        // rc.3 overnight run for posthog landed exactly here and bailed
-        // `oauth_required` because the inventory had only:
-        //   - "Default project" (project picker)
-        //   - "BBento" (account avatar toggle)
-        //   - "Hand off setup" (skip-onboarding affordance)
-        //
-        // Detect this shape via a second-tier signal set. Conservative —
-        // we already gated on "no credential inputs" and "dashboardyPath",
-        // so a true signup chooser (which has neither of those AND the
-        // path is /signup or /login) cannot reach this branch.
-        const POST_AUTH_AFFORDANCE = /^\s*(?:hand\s*off\s*setup|skip\s*(?:onboarding|setup|for\s*now)|invite\s*(?:teammates|members|your\s*team)|set\s*up\s*billing|finish\s*setup|get\s*started|continue\s*to\s*(?:dashboard|app|console))\s*$/i;
-        // Workspace / project / org picker shape. We pattern-match
-        // generously because PostHog's reads "Default project" but other
-        // SaaS dashboards read "My workspace" / "Acme org" / similar. The
-        // structural cue is "button with one of the workspace-noun words"
-        // — see TS-1923 (PostHog rc.3 regression).
-        const WORKSPACE_PICKER = /\b(?:workspace|workspaces|project(?:s)?|organization|organizations|team(?:s)?)\b/i;
-        const hasPostAuthAffordance = inventory.some((e) => POST_AUTH_AFFORDANCE.test((e.visibleText ?? e.ariaLabel ?? "").trim()));
-        if (hasPostAuthAffordance) {
-            // Single signal — the skip-onboarding / handoff verb is strong
-            // enough on its own. No login page ever offers "Hand off setup".
-            return true;
-        }
-        // Weaker pair: a workspace-picker shape AND the page lacks a
-        // primary call-to-action that reads as signup ("Continue with
-        // Google", "Sign up", etc.). Used as a backstop for SPA dashboards
-        // whose only visible buttons are picker toggles.
-        const hasWorkspacePicker = inventory.some((e) => WORKSPACE_PICKER.test((e.visibleText ?? e.ariaLabel ?? "").trim()));
-        const hasSignupOrOAuthAffordance = inventory.some((e) => {
-            const t = (e.visibleText ?? e.ariaLabel ?? "").trim();
-            return /\b(?:sign[\s-]*up|signup|continue\s+with|log\s+in\s+with|sign\s+in\s+with)\b/i.test(t);
-        });
-        if (hasWorkspacePicker && !hasSignupOrOAuthAffordance) {
-            return true;
-        }
     }
     return false;
 }
@@ -1591,43 +1405,6 @@ 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)
@@ -2117,27 +1894,12 @@ export class SignupAgent {
                 // Parse/validation failure — includes a hallucinated selector
                 // rejected by the inventory check. An error replan.
                 const reason = err instanceof Error ? err.message : String(err);
-                // 0.8.2-rc.6 — mirror the post-verify upstream-blip carve-out.
-                // The form-fill planner is also vulnerable to sustained
-                // upstream-proxy degradation: the rc.3 + rc.5 batch runs
-                // showed openrouter / resend / sentry losing 4+ consecutive
-                // proxy calls in a row when the free-tier upstream was
-                // throttling. Don't punt to planning_failed for upstream
-                // weather — keep re-planning until the budget runs out at the
-                // top-level F2 deadline, OR a true logic failure shows up.
-                const isUpstreamBlip = /\b50[234]\b/.test(reason) ||
-                    /\bupstream_(?:error|unreachable)\b/i.test(reason) ||
-                    /\bnetwork error\b/i.test(reason);
-                if (!isUpstreamBlip && ++errorReplans > MAX_ERROR_REPLANS) {
+                if (++errorReplans > MAX_ERROR_REPLANS) {
                     return { kind: "planning_failed", reason: `planner output never validated: ${reason}` };
                 }
-                steps.push(isUpstreamBlip
-                    ? `⚠ planner request hit a transient upstream blip (${reason}) — retrying`
-                    : `⚠ plan rejected (${reason}) — re-planning`);
-                if (!isUpstreamBlip) {
-                    hint =
-                        "Your previous plan used a selector not in the inventory. Use ONLY selectors copied verbatim from a `selector=` field.";
-                }
+                steps.push(`⚠ plan rejected (${reason}) — re-planning`);
+                hint =
+                    "Your previous plan used a selector not in the inventory. Use ONLY selectors copied verbatim from a `selector=` field.";
                 continue;
             }
             steps.push(`Plan: ${plan.actions.length} action(s), confidence=${plan.confidence}` +
@@ -2582,22 +2344,12 @@ export class SignupAgent {
             if (this.llmCallCount >= MAX_LLM_CALLS_PER_SIGNUP) {
                 throw new LLMCallBudgetExceeded(MAX_LLM_CALLS_PER_SIGNUP);
             }
-            // 0.8.2-rc.8 — count the call only AFTER the upstream actually
-            // replied. The old code incremented before the proxy fetch which
-            // means a proxy 502 (caught & surfaced after the 4-attempt retry
-            // budget exhausts) cost the same budget unit as a real planner
-            // reply. The rc.7 sentry batch run hit this: 2 upstream-blip
-            // retries consumed 2 of the 15 calls on top of the 9 successful
-            // post-verify rounds — the planner ran out of budget on the 8th
-            // permission scope, 5 short of the API key. Failed calls produce
-            // no progress; charging them against the budget is wrong. Behave
-            // like a meter: only count consumption that actually delivered.
+            this.llmCallCount += 1;
             const resp = await client.createMessage({
                 system: args.system,
                 user: args.userBlocks,
                 max_tokens: args.maxTokens,
             });
-            this.llmCallCount += 1;
             this.backendsUsed.push(resp.backend);
             return resp.text;
         };
@@ -2933,34 +2685,6 @@ 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 " +
@@ -3554,20 +3278,14 @@ export class SignupAgent {
             }
         }
         let credentials = await this.extractCredentials();
-        // 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) {
+            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,
@@ -3613,41 +3331,6 @@ 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 ` +
@@ -3926,37 +3609,8 @@ ${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
-        // gate planFailures (so a transient 502 won't push us into the
-        // terminal stop branch after 4 rounds), but is still bounded so a
-        // permanently-down proxy can't loop forever. Generous because each
-        // blip costs ~5s of network + retry-backoff and the run already
-        // has a 10-min top-level timeout — but tight enough that a truly
-        // dead upstream doesn't burn the whole maxRounds budget on noise.
-        let upstreamBlipRetries = 0;
-        const MAX_UPSTREAM_BLIP_RETRIES = 8;
         const oauth = args.credentials === undefined;
         // Re-plan hint for the next round — set when an `extract` step
         // found no key, which means the visible key text is masked /
@@ -4016,26 +3670,6 @@ ${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
@@ -4047,60 +3681,11 @@ ${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++) {
-            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) {
+            if (credentials.api_key !== undefined || credentials.username !== undefined) {
                 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
@@ -4148,47 +3733,17 @@ ${formatInventory(input.inventory)}`,
                 // form-fill planner has. Bounded so a persistently broken
                 // planner still terminates.
                 const reason = err instanceof Error ? err.message : String(err);
-                // 0.8.2-rc.6 — distinguish upstream-blip from planner-logic
-                // failure. The proxy retry-with-backoff (rc.5) handles most
-                // transient 502s within a single call, but during a sustained
-                // upstream degradation the retry budget exhausts and surfaces
-                // here as a planFailure. Counting those toward the 4x stop
-                // threshold is wrong — they're not the planner's fault, the
-                // upstream is just temporarily unavailable. We allow these to
-                // burn a round (forward progress is impossible without a
-                // planner reply) but don't tick planFailures, so a transient
-                // blip can't push us into the terminal stop branch.
-                const isUpstreamBlip = /\b50[234]\b/.test(reason) ||
-                    /\bupstream_(?:error|unreachable)\b/i.test(reason) ||
-                    /\bnetwork error\b/i.test(reason);
-                if (isUpstreamBlip) {
-                    upstreamBlipRetries += 1;
-                    if (upstreamBlipRetries > MAX_UPSTREAM_BLIP_RETRIES) {
-                        args.steps.push(`Post-verify round ${round}: upstream proxy degraded for ${upstreamBlipRetries} rounds — stopping (likely sustained outage).`);
-                        break;
-                    }
-                }
-                else {
-                    planFailures += 1;
-                }
+                planFailures += 1;
                 if (planFailures > 3) {
                     args.steps.push(`Post-verify round ${round}: planner failed ${planFailures}x (${reason}) — stopping.`);
                     break;
                 }
-                const label = isUpstreamBlip ? "transient upstream blip" : "planner output rejected";
-                args.steps.push(`Post-verify round ${round}: ${label} (${reason})` +
-                    (isUpstreamBlip
-                        ? ` — retrying (${upstreamBlipRetries}/${MAX_UPSTREAM_BLIP_RETRIES}).`
-                        : " — re-planning."));
-                // No re-plan hint on an upstream blip — the planner's previous
-                // output (if any) was fine; only the request itself failed.
-                if (!isUpstreamBlip) {
-                    hint =
-                        "Your previous step was REJECTED. A click/fill/select `selector` must be " +
-                            "EXACTLY the value after `selector=` on one inventory line — copy only that " +
-                            "value (it runs to the end of the line), never the leading `[n] tag …` part " +
-                            "and never the whole line.";
-                }
+                args.steps.push(`Post-verify round ${round}: planner output rejected (${reason}) — re-planning.`);
+                hint =
+                    "Your previous step was REJECTED. A click/fill/select `selector` must be " +
+                        "EXACTLY the value after `selector=` on one inventory line — copy only that " +
+                        "value (it runs to the end of the line), never the leading `[n] tag …` part " +
+                        "and never the whole line.";
                 continue;
             }
             // rc.22 — redact tokens before pushing to the step trail.
@@ -4393,94 +3948,6 @@ ${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.`);
@@ -4550,131 +4017,129 @@ ${formatInventory(input.inventory)}`,
             hint = undefined;
             try {
                 if (nextStep.kind === "extract") {
-                    // 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(", ")})`);
+                    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}`);
+                                        }
+                                    }
                                 }
-                                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}`);
+                                catch (err) {
+                                    args.steps.push(`Post-verify ${round + 1}/${args.maxRounds}: reveal pass error (${err instanceof Error ? err.message : String(err)})`);
                                 }
                             }
+                            consecutiveFailedExtracts = 0;
+                            continue;
                         }
-                        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 domNewKeys = Object.keys(labeledFromDom).filter((k) => credentials[k] === undefined);
-                        if (domNewKeys.length > 0) {
-                            for (const k of domNewKeys)
-                                credentials[k] = labeledFromDom[k];
-                            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}: 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;
+                            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.
+                        }
+                        const labeledFromDom = await this.extractFromDomProximity();
+                        const newKeys = Object.keys(labeledFromDom).filter((k) => credentials[k] === undefined);
+                        if (newKeys.length > 0) {
+                            for (const k of newKeys)
+                                credentials[k] = labeledFromDom[k];
+                            const summary = newKeys
+                                .map((k) => {
+                                const v = labeledFromDom[k];
+                                return `${k}=${v.slice(0, 4)}…${v.slice(-4)}`;
+                            })
+                                .join(", ");
+                            args.steps.push(`Post-verify ${round + 1}/${args.maxRounds}: extracted ${newKeys.length} labeled credential(s) ` +
+                                `via DOM-proximity fallback (${summary})`);
+                            consecutiveFailedExtracts = 0;
+                            continue;
+                        }
                         consecutiveFailedExtracts += 1;
                         // Best-effort diagnostic upload: when extract returns
                         // null despite the planner asserting a credential is
@@ -4739,6 +4204,9 @@ ${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);
@@ -4754,46 +4222,13 @@ ${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 {
-                            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)
+                            pollExtract = await this.extractCredentials();
+                            if (pollExtract.api_key !== undefined)
                                 break;
                         }
                         catch {
@@ -4878,24 +4313,9 @@ ${formatInventory(input.inventory)}`,
             }
             // Re-extract — but tolerate the page still navigating from the
             // step just taken; the next round settles and re-reads.
-            // 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;
+            const hadCredentialsBefore = credentials.api_key !== undefined || credentials.username !== undefined;
             try {
-                const reExtract = await this.extractCredentials();
-                for (const [k, v] of Object.entries(reExtract)) {
-                    if (credentials[k] === undefined)
-                        credentials[k] = v;
-                }
+                credentials = await this.extractCredentials();
             }
             catch {
                 // page mid-navigation — next round's waitForFormReady handles it
@@ -4913,8 +4333,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 credCountAfter = Object.keys(credentials).filter((k) => !NON_CREDENTIAL_KEYS.has(k)).length;
-            const haveNewCredentials = credCountAfter > credCountBefore;
+            const haveNewCredentials = !hadCredentialsBefore &&
+                (credentials.api_key !== undefined || credentials.username !== undefined);
             if (haveNewCredentials && nextStep.kind !== "extract") {
                 try {
                     const [postState, postInventory] = await Promise.all([
@@ -4963,39 +4383,6 @@ ${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
@@ -5095,30 +4482,17 @@ 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.
-- **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.
+- **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.
 - 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.