@botbuddy/cli 1.64.11 → 1.64.13

package/daemon-release/darwin-arm64.json

@@ -1,7 +1,7 @@
 {
-  "release_version": "1.64.11",
-  "source_commit": "b6f2d83fd2179b508bcc5695f8fb25579c25c463",
-  "source_sha256": "9c7a5f7704e390901aba149696d263398e96efc63c280979022b1da9ca634dcb",
+  "release_version": "1.64.13",
+  "source_commit": "db2f7f45e8e0444857a2046c18481e107e3ebf58",
+  "source_sha256": "1533000de11720445186669ac3bf3eb7c663962f809b4035a52fa4de9c368213",
   "target": "darwin-arm64",
-  "sha256": "a466dac8ca5a03259c0e3bf03538f5c24ce0da9de09b8b3b626c63f6279c0b65"
+  "sha256": "8c2dd7c45a7e1c697fa47e5044a1b1cd6703efbb7fc648e1042a104c784094bb"
 }

package/daemon-release/linux-x64.json

@@ -1,7 +1,7 @@
 {
-  "release_version": "1.64.11",
-  "source_commit": "b6f2d83fd2179b508bcc5695f8fb25579c25c463",
-  "source_sha256": "9c7a5f7704e390901aba149696d263398e96efc63c280979022b1da9ca634dcb",
+  "release_version": "1.64.13",
+  "source_commit": "db2f7f45e8e0444857a2046c18481e107e3ebf58",
+  "source_sha256": "1533000de11720445186669ac3bf3eb7c663962f809b4035a52fa4de9c368213",
   "target": "linux-x64",
-  "sha256": "53eab9515e51d2b35b7da60db3a8ab5107310499b22a77614e19bffcbd40ca88"
+  "sha256": "81345fbe3fde99c1b41f7d1738f00ef2bf4be9de12fe39e0755f23546ed4ed3f"
 }

package/daemon-release/manifest.json

@@ -1,21 +1,21 @@
 {
   "schema_version": 1,
-  "release_version": "1.64.11",
-  "source_commit": "b6f2d83fd2179b508bcc5695f8fb25579c25c463",
-  "source_sha256": "9c7a5f7704e390901aba149696d263398e96efc63c280979022b1da9ca634dcb",
+  "release_version": "1.64.13",
+  "source_commit": "db2f7f45e8e0444857a2046c18481e107e3ebf58",
+  "source_sha256": "1533000de11720445186669ac3bf3eb7c663962f809b4035a52fa4de9c368213",
   "targets": {
     "darwin-arm64": {
       "goos": "darwin",
       "goarch": "arm64",
       "binary": "daemon/bin/darwin-arm64/botbuddy-daemon",
-      "sha256": "a466dac8ca5a03259c0e3bf03538f5c24ce0da9de09b8b3b626c63f6279c0b65",
+      "sha256": "8c2dd7c45a7e1c697fa47e5044a1b1cd6703efbb7fc648e1042a104c784094bb",
       "mode": "0755"
     },
     "linux-x64": {
       "goos": "linux",
       "goarch": "amd64",
       "binary": "daemon/bin/linux-x64/botbuddy-daemon",
-      "sha256": "53eab9515e51d2b35b7da60db3a8ab5107310499b22a77614e19bffcbd40ca88",
+      "sha256": "81345fbe3fde99c1b41f7d1738f00ef2bf4be9de12fe39e0755f23546ed4ed3f",
       "mode": "0755"
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbuddy/cli",
-  "version": "1.64.11",
+  "version": "1.64.13",
   "description": "BotBuddy \u2014 Swarm coordination CLI for multi-agent workflows",
   "type": "module",
   "bin": {

package/src/commands.mjs

@@ -10,7 +10,7 @@ import { bootstrapHarnessSession, clearHarnessSession, doctorBootstrapState, for
 import { loadConfig, getConfig, clearConfig, getConfigPath, SERVER_URL } from "./config.mjs";
 import { resolveOwnerToken, resolveAgentKey, clearOwnerToken } from "./cli-credentials.mjs";
 import { agentProfileKeyLabel } from "./credential-kinds.mjs";
-import { buildAcquireResourcesPayload, LocksUsageError } from "./locks.mjs";
+import { buildAcquireResourcesPayload, LocksUsageError, classifyLockResponse, lockOutcomeLines, unlockOutcomeLines, UNLOCK_QUEUED_USAGE } from "./locks.mjs";
 import { CallUsageError, discoveryUrlFor, formatDiscovery, parseCallArgs } from "./discovery.mjs";
 import { cmdStack } from "./stack.mjs";
 import { cmdManagedAllocation } from "./managed-allocation.mjs";
@@ -302,7 +302,14 @@ ${bold("STAGING SIGN-IN")} (BOT-2084)
 ${bold("LOCKS")}
   locks -m [--host name]     Reserve typed local resources, including Playwright MCP lanes
   lock <resource_name> <type>  Acquire one named lock (acquire_lock)
-  unlock <resource_name>     Release one named lock (release_lock)
+                             locks/lock: exit 0 acquired · 2 queued · 1 refused.
+                             Use a resource only after exit 0; queued means another
+                             agent holds it and you are in line for it.
+  unlock <resource_name>     Release one named lock you hold (release_lock); it
+                             does not withdraw a queued request
+  unlock --queued <resource_id> <resource_lock_id>
+                             Withdraw your queued request (ids from the queued
+                             lock result; retire_queued_lock_attempt)
 
 ${bold("DURABLE WORKLOADS")}  (${cyan("bb help run")})
   run --session-id <id> --environment <env> -- <command>
@@ -1713,23 +1720,41 @@ export async function cmdMcp(args, {
   die(`Unknown mcp subcommand: ${sub}. Run ${cyan("botbuddy mcp --help")}.`);
 }
 
-function cmdLock(args) {
+// BOT-2994: each lock command returns its exit code (0 acquired · 2 queued ·
+// 1 refused; auth 3 / transport 5 unchanged) and says on stderr what the caller
+// holds. stdout keeps the server's result exactly as before.
+async function finishLock(response, lines) {
+  const outcome = classifyLockResponse(response);
+  for (const line of lines(outcome)) console.error(line);
+  return outcome.exit;
+}
+
+async function cmdLock(args) {
   if (args.length < 2) die("Usage: botbuddy lock <resource_name> <type>");
-  return callTool("acquire_lock", { resource_name: args[0], resource_type: args[1] });
+  return finishLock(await callTool("acquire_lock", { resource_name: args[0], resource_type: args[1] }), lockOutcomeLines);
 }
 
-function cmdLocks(args) {
+async function cmdLocks(args) {
+  let payload;
   try {
-    return callTool("acquire_resources", buildAcquireResourcesPayload(args));
+    payload = buildAcquireResourcesPayload(args);
   } catch (error) {
     if (error instanceof LocksUsageError) die(error.message);
     throw error;
   }
+  return finishLock(await callTool("acquire_resources", payload), lockOutcomeLines);
 }
 
-function cmdUnlock(args) {
+async function cmdUnlock(args) {
+  // BOT-2994: release_lock only releases a lock you HOLD; a queued request is
+  // withdrawn by its exact resource + queued-ledger ids (retire_queued_lock_attempt).
+  if (args[0] === "--queued") {
+    if (args.length !== 3 || !args[1] || !args[2] || args[1].startsWith("-") || args[2].startsWith("-")) die(UNLOCK_QUEUED_USAGE);
+    const response = await callTool("retire_queued_lock_attempt", { resource_id: args[1], resource_lock_id: args[2] });
+    return finishLock(response, (outcome) => unlockOutcomeLines(outcome, { queued: true }));
+  }
   if (!args[0]) die("Usage: botbuddy unlock <resource_name>");
-  return callTool("release_lock", { resource_name: args[0] });
+  return finishLock(await callTool("release_lock", { resource_name: args[0] }), (outcome) => unlockOutcomeLines(outcome));
 }
 
 function cmdTask(args) {

package/src/locks.mjs

@@ -152,3 +152,108 @@ export function buildAcquireResourcesPayload(args, options = {}) {
     ...(environment ? { environment } : {}),
   };
 }
+
+// BOT-2994: `bb lock`, `bb locks` and `bb unlock` exit by what the server did, not
+// by whether it answered. Before this every one of them exited 0, so a shell loop
+// that trusted the exit code drove another agent's Playwright lane (ENT-6416).
+// 0 = acquired (or released / withdrawn); 2 = queued behind a holder (you hold
+// nothing yet; wait for the grant or withdraw); 1 = refused or not understood.
+// Auth (3) and transport (5) exits from callTool pass through unchanged.
+export const LOCK_EXIT = Object.freeze({ ACQUIRED: 0, REFUSED: 1, QUEUED: 2 });
+
+function parseJson(text) {
+  try { return JSON.parse(text); } catch { return undefined; }
+}
+
+function toolText(response) {
+  const content = response?.result?.content;
+  if (!Array.isArray(content)) return null;
+  const text = content.map((part) => part?.text ?? "").join("\n");
+  return text || null;
+}
+
+/**
+ * Classify a lock tool response (acquire_lock, acquire_resources, release_lock,
+ * retire_queued_lock_attempt) as returned by callTool: the JSON-RPC body, or a
+ * numeric exit when callTool already classified an auth/transport failure.
+ * Fails closed: an error flag, `success: false`, or an unreadable result is
+ * never "acquired".
+ */
+export function classifyLockResponse(response) {
+  if (typeof response === "number") return { exit: response, results: [] };
+  const isError = response?.result?.isError === true;
+  const text = toolText(response);
+  if (text === null) return { exit: LOCK_EXIT.REFUSED, results: [] };
+  const parsed = parseJson(text);
+  let results;
+  if (parsed && Array.isArray(parsed.results)) {
+    results = parsed.results.map((r) => ({ ...r, success: r?.success === true }));
+  } else if (parsed && typeof parsed === "object" && "success" in parsed) {
+    results = [{ ...parsed, resource_name: parsed.resource_name ?? parsed.resource, success: parsed.success === true && !isError }];
+  } else {
+    // The human success string (acquire_lock / release_lock) or a plain error text.
+    results = [{ success: !isError, message: text }];
+  }
+  const failed = results.filter((r) => !r.success);
+  let exit = LOCK_EXIT.ACQUIRED;
+  if (failed.some((r) => r.queued !== true)) exit = LOCK_EXIT.REFUSED;
+  else if (failed.length) exit = LOCK_EXIT.QUEUED;
+  else if (isError || !results.length) exit = LOCK_EXIT.REFUSED;
+  return { exit, results };
+}
+
+function holderLabel(holder) {
+  if (!holder || typeof holder !== "object") return null;
+  const who = holder.agent ?? holder.agent_name ?? holder.name ?? null;
+  if (!who) return null;
+  const ticket = holder.ticket_id ? `, ${holder.ticket_id}` : "";
+  return `${who}${ticket}`;
+}
+
+// `bb wait 'lock:…,claim=true'` only addresses typed resources
+// (`<subtype>:<host>:<slot>`); an untyped name gets no wait line.
+function claimWaitFor(name) {
+  const parts = typeof name === "string" ? name.split(":") : [];
+  if (parts.length !== 3 || parts.some((p) => !p)) return null;
+  const [subtype, host, slot] = parts;
+  return `bb wait 'lock:subtype=${subtype},host=${host},slot=${slot},claim=true' --heartbeat`;
+}
+
+/** The stderr lines that tell the caller what it holds and what to do next. */
+export function lockOutcomeLines({ exit, results }) {
+  if (exit === LOCK_EXIT.ACQUIRED || exit > LOCK_EXIT.QUEUED) return [];
+  const lines = [`✗ Lock not acquired (exit ${exit}: ${exit === LOCK_EXIT.QUEUED ? "queued" : "refused"}). Do not use ${results.length > 1 ? "these resources" : "this resource"} until a lock command exits 0.`];
+  for (const r of results.filter((x) => !x.success)) {
+    const name = r.resource_name ?? r.resource ?? "resource";
+    const holder = holderLabel(r.holder);
+    if (r.queued === true) {
+      lines.push(`  ${name}: queued${holder ? ` behind ${holder}` : ""}${r.queue_depth != null ? ` (queue depth ${r.queue_depth})` : ""}.`);
+      const wait = claimWaitFor(name);
+      if (wait) lines.push(`    wait to be handed it:  ${wait}`);
+      if (r.resource_id && r.resource_lock_id) lines.push(`    or withdraw the request: bb unlock --queued ${r.resource_id} ${r.resource_lock_id}`);
+    } else {
+      lines.push(`  ${name}: refused${holder ? ` (held by ${holder})` : ""}${r.message ? ` — ${r.message}` : ""}`);
+    }
+  }
+  const held = results.filter((r) => r.success && r.resource_name);
+  if (held.length && results.length > 1) {
+    lines.push("  Acquired in this batch (release what you will not use):");
+    for (const r of held) lines.push(`    bb unlock ${r.resource_name}`);
+  }
+  return lines;
+}
+
+/** `bb unlock` refused: say how a queued caller withdraws instead. */
+export function unlockOutcomeLines({ exit, results }, { queued = false } = {}) {
+  if (exit === LOCK_EXIT.ACQUIRED || exit > LOCK_EXIT.QUEUED) return [];
+  // The first line is the server's reason; later lines are generic guidance.
+  const why = results.find((r) => r.message)?.message?.split("\n")[0];
+  if (queued) return [`✗ Queued request not withdrawn${why ? `: ${why}` : ""}.`];
+  return [
+    `✗ Lock not released${why ? `: ${why}` : ""}.`,
+    "  bb unlock <name> releases a lock you hold; it does not withdraw a queued request.",
+    "  To withdraw one, use the ids from the queued lock result: bb unlock --queued <resource_id> <resource_lock_id>",
+  ];
+}
+
+export const UNLOCK_QUEUED_USAGE = "Usage: botbuddy unlock --queued <resource_id> <resource_lock_id>";

package/src/pw/run.mjs

@@ -92,7 +92,7 @@ async function gate({ env, host, lane, deps }) {
     // callerIds/holder let staging-auth cleanup touch only what this caller installed.
     const callerIds = [...selfAgentIds];
     if (status.held && selfAgentIds.has(status.heldBy)) return { allowed: true, coordinator, canonicalHost, holderMatch: "self", holder: status.heldBy, callerIds };
-    if (status.held && status.ownerIsCaller === true) return { allowed: true, coordinator, canonicalHost, holderMatch: "owner", holder: status.heldBy ?? null, callerIds };
+    if (status.held && status.ownerIsCaller === true) return { allowed: true, coordinator, canonicalHost, holderMatch: "owner", holder: status.heldBy ?? null, holderName: status.heldByName ?? null, callerIds };
     // Distinguish an expired/free lane from one another operator holds so the
     // operator knows whether to re-acquire vs. wait for a handover (BOT-660). Name it
     // by the server's canonical host so a not-held message matches the dashboard even
@@ -296,6 +296,23 @@ async function runPwInner(argv, deps = {}) {
   // Report the host the lock service actually stored (alias-collapsed), so the
   // status view and lane telemetry match the server, not the local string (AC-4).
   const effHost = auth.canonicalHost ?? host;
+  // BOT-2994: a lane is driven only by the agent that holds it. The gate also
+  // passes a same-owner holder (BOT-1490 owner_is_caller), and every agent one
+  // person runs shares that owner, so an agent whose `bb lock` had only queued
+  // drove another agent's browser (ENT-6416, 2026-11-03). Resolve an owner-only
+  // match to the exact agent once (server whoami); only read-only `status` may
+  // proceed without it. `auth` keeps its own staging refusal receipt below.
+  let holderMatch = auth.holderMatch;
+  if (holderMatch === "owner" && auth.holder && authCtx.resolveCallerId) {
+    const me = await authCtx.resolveCallerId().catch(() => null);
+    if (me && me === auth.holder) { holderMatch = "self"; authCtx.callerIds = [...authCtx.callerIds, me]; }
+  }
+  if (holderMatch === "owner" && plan.mode !== "status" && plan.mode !== "auth") {
+    const lane = `playwright_lane:${effHost}:${plan.lane}`;
+    const who = `${auth.holder ?? "unknown"}${auth.holderName ? ` (${auth.holderName})` : ""}`;
+    stderr.write(`bb-pw: lane lock ${lane} is held by ${who}, another agent session of your owner, not this agent session. A lane is driven only by the agent that holds it. Claim a lane from this session with bb locks -m --lane <n> --ticket <ticket> and use it only after that exits 0, or wait to be handed this one: bb wait 'lock:subtype=playwright_lane,host=${effHost},slot=${plan.lane},claim=true' --heartbeat\n`);
+    return 3;
+  }
   // BOT-1318: resolve the lane's browser-acceptance tracker AFTER the gate (a
   // refused/unverified lane writes no lifecycle) and never for unlocked local mode.
   let tracker = null;
@@ -312,11 +329,6 @@ async function runPwInner(argv, deps = {}) {
   if (tracker && envResolution.error) { stderr.write(`${envResolution.error}\n`); return 2; }
   const environment = envResolution.environment ?? null;
   if (plan.mode === "auth") {
-    let holderMatch = auth.holderMatch;
-    if (holderMatch === "owner" && auth.holder && authCtx.resolveCallerId) {
-      const me = await authCtx.resolveCallerId().catch(() => null);
-      if (me && me === auth.holder) { holderMatch = "self"; authCtx.callerIds = [...authCtx.callerIds, me]; }
-    }
     if (holderMatch !== "self") return stagingAuth.refuse({ stdout, stderr }, "exact_lane_holder_required", 3, {}, authVars(plan, deps));
     if (tracker) {
       const browserSession = await tracker.status();

package/src/staging-pool/cli.mjs

@@ -284,7 +284,10 @@ export async function takeForLane({
       const g = guidance("pool_empty", guidanceVars(ctx, { persona: entry.alias }));
       effective = { ...health, reason: "pool_empty", agentAction: g.agent_action, remedy: remedyLine(g), message: g.message, cause: g.cause, actor: g.actor_label, next: g.next, doc: g.doc, help: g.help };
     }
+    // BOT-2952: the pool's own detail (an Auth outage at take time) survives the health's.
+    const poolDetail = error.detail;
     for (const field of GUIDANCE_FIELDS) if (effective[field] !== undefined) error[field] = effective[field];
+    if (poolDetail) error.detail = [poolDetail, effective.detail].filter(Boolean).join(" ");
     throw error;
   }
 }

package/src/staging-pool/errors.mjs

@@ -135,7 +135,7 @@ export const ERROR_CODES = Object.freeze({
   // already asked the human-installed job to refill now, so the agent waits once and retries.
   pool_empty: entry("agent", "take",
     "The staging session pool is healthy but has no ready session for {persona}.",
-    "Agents took every ready session since the last tick, or the ready ones were dead or AAL1 (factor rotated) and were discarded; automatic refill creates a durable job before the single retry.",
+    "Agents took every ready session since the last tick, or the ready ones were dead or AAL1 (factor rotated) and were discarded, or staging Auth did not answer their liveness check and they were kept (detail says so); automatic refill creates a durable job before the single retry.",
     "Automatic refill is requested by bb pw auth; wait for its refill job, then {retry} once; if it fails, report this code", "retry_once"),
   pool_refill_unavailable: entry("agent", "take",
     "The staging session pool is empty and automatic refill did not return a durable job.",

package/src/staging-pool/pool.mjs

@@ -483,6 +483,7 @@ export function createSessionPool({
         const entry = (health.personas[persona] ??= {
           belowTargetTicks: 0,
           consecutiveMintFailures: 0,
+          backoffMintFailures: 0,
           nextMintAttemptAt: null,
           lastMintError: null,
         });
@@ -505,20 +506,33 @@ export function createSessionPool({
               await mintIntoReady(persona);
               counts[persona] += 1;
               entry.consecutiveMintFailures = 0;
+              entry.backoffMintFailures = 0;
               entry.nextMintAttemptAt = null;
               entry.lastMintError = null;
             } catch (error) {
               summary.mintFailures += 1;
               entry.consecutiveMintFailures += 1;
               entry.lastMintError = error?.code ?? "error";
-              entry.nextMintAttemptAt = new Date(
-                now() + nextMintBackoffMs({ failures: entry.consecutiveMintFailures, intervalMs }),
-              ).toISOString();
+              // BOT-2952: an outage that never got a password grant created no AAL1 session and
+              // ran no MFA verify, so it retries on the next tick and does not lengthen a later
+              // backoff. A 429 is Auth asking us to slow down, so it backs off like any other
+              // failure, on its own streak.
+              const outage =
+                error?.transient === true && error?.passwordGrantSucceeded === false && error?.rateLimited !== true;
+              if (outage) {
+                entry.nextMintAttemptAt = null;
+              } else {
+                entry.backoffMintFailures = (entry.backoffMintFailures ?? 0) + 1;
+                entry.nextMintAttemptAt = new Date(
+                  now() + nextMintBackoffMs({ failures: entry.backoffMintFailures, intervalMs }),
+                ).toISOString();
+              }
               logger({
                 event: "mint_failed",
                 persona,
                 code: entry.lastMintError,
                 message: error?.message ?? String(error),
+                outage,
                 consecutiveMintFailures: entry.consecutiveMintFailures,
                 nextMintAttemptAt: entry.nextMintAttemptAt,
               });
@@ -567,6 +581,7 @@ export function createSessionPool({
       }
     }
     candidates.sort((a, b) => b.verifiedAt - a.verifiedAt);
+    let inconclusive = null;
     for (const { slotId } of candidates) {
       const takenDir = join(dirs.taken, slotId);
       if (!(await claim(join(dirs.ready, slotId), takenDir))) continue;
@@ -582,8 +597,23 @@ export function createSessionPool({
         continue;
       }
       const result = await signIn.refresh({ target, storedSession: slot.storedSession, persona });
+      if (!result.ok && result.transient) {
+        // BOT-2952: Auth did not answer, which says nothing about this slot. It goes back to
+        // ready unchanged (the tick does the same, BOT-2947) and the next slot is tried; a
+        // persona has at most 4. Nothing unverified is ever handed out.
+        inconclusive = result.reason;
+        await fs.rm(join(takenDir, "claim.json"), { force: true });
+        try {
+          await fs.rename(takenDir, join(dirs.ready, slotId));
+        } catch (error) {
+          // A tick purged it between the claim marker's removal and the rename.
+          if (error?.code !== "ENOENT") throw error;
+        }
+        logger({ event: "take_inconclusive", slotId, persona, reason: result.reason });
+        continue;
+      }
       if (!result.ok) {
-        logger({ event: "take_discard", slotId, persona, reason: result.reason, transient: Boolean(result.transient) });
+        logger({ event: "take_discard", slotId, persona, reason: result.reason, transient: false });
         await removeSlot(takenDir);
         continue;
       }
@@ -602,7 +632,11 @@ export function createSessionPool({
       logger({ event: "take_ok", slotId, persona, owner: meta.owner });
       return { slotId, statePath: join(takenDir, "state.json"), dir: takenDir, meta };
     }
-    throw new PoolEmptyError(persona, tickIntervalHint);
+    const empty = new PoolEmptyError(persona, tickIntervalHint);
+    if (inconclusive) {
+      empty.detail = `Staging Auth did not answer the liveness check (${inconclusive}); the ready sessions were kept for a retry.`;
+    }
+    throw empty;
   }
 
   async function discardTaken(slotId) {

package/src/staging-pool/signin-gotrue-totp.mjs

@@ -16,12 +16,17 @@ import { assertPersonaAllowed } from "./policy.mjs";
 import { decodeJwtClaims, toStoredSession } from "./state-file.mjs";
 
 export class SignInError extends Error {
-  constructor(code, message, { transient = false, status } = {}) {
+  constructor(code, message, { transient = false, status, passwordGrantSucceeded, rateLimited } = {}) {
     super(message);
     this.name = "SignInError";
     this.code = code;
     this.transient = transient;
     this.status = status;
+    // BOT-2952: set on mint_retries_exhausted. false = no attempt got a password grant, so no
+    // AAL1 session existed and no MFA verify ran (the pool retries next tick, no backoff).
+    if (passwordGrantSucceeded !== undefined) this.passwordGrantSucceeded = passwordGrantSucceeded;
+    // A 429 on any attempt: Auth answered "slow down", so the pool keeps its backoff.
+    if (rateLimited !== undefined) this.rateLimited = rateLimited;
   }
 }
 
@@ -93,9 +98,12 @@ export function createGoTrueTotpSignIn({
   async function mint({ target, persona }) {
     assertPersonaAllowed(target, persona);
     let lastFailure = "no attempt made";
+    let passwordGrantSucceeded = false;
+    let rateLimited = false;
     for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-      const retry = async (reason, { waitWindow = false } = {}) => {
+      const retry = async (reason, { waitWindow = false, response } = {}) => {
         lastFailure = reason;
+        if (response?.status === 429) rateLimited = true;
         logger({ event: "mint_retry", persona, attempt, reason });
         if (attempt < maxAttempts) {
           if (waitWindow) await waitForNextTotpWindow();
@@ -108,7 +116,7 @@ export function createGoTrueTotpSignIn({
       });
       if (password.status !== 200) {
         if (isTransient(password)) {
-          await retry(`password grant ${describeFailure(password)}`);
+          await retry(`password grant ${describeFailure(password)}`, { response: password });
           continue;
         }
         if (isCredentialRefusal(password)) {
@@ -120,6 +128,7 @@ export function createGoTrueTotpSignIn({
           status: password.status,
         });
       }
+      passwordGrantSucceeded = true;
       const aal1Token = password.body?.access_token;
       const factor = (password.body?.user?.factors ?? []).find(
         (candidate) => candidate.factor_type === "totp" && candidate.status === "verified",
@@ -135,7 +144,7 @@ export function createGoTrueTotpSignIn({
           continue;
         }
         if (isTransient(challenge)) {
-          await retry(`challenge ${describeFailure(challenge)}`);
+          await retry(`challenge ${describeFailure(challenge)}`, { response: challenge });
           continue;
         }
         throw new SignInError("challenge_failed", `MFA challenge refused: ${describeFailure(challenge)}.`, {
@@ -158,7 +167,7 @@ export function createGoTrueTotpSignIn({
           continue;
         }
         if (isTransient(verify)) {
-          await retry(`verify ${describeFailure(verify)}`);
+          await retry(`verify ${describeFailure(verify)}`, { response: verify });
           continue;
         }
         throw new SignInError("verify_failed", `MFA verify refused: ${describeFailure(verify)}.`, { status: verify.status });
@@ -176,6 +185,8 @@ export function createGoTrueTotpSignIn({
     }
     throw new SignInError("mint_retries_exhausted", `Mint gave up after ${maxAttempts} attempts (last: ${lastFailure}).`, {
       transient: true,
+      passwordGrantSucceeded,
+      rateLimited,
     });
   }