@botbuddy/cli 1.64.11 → 1.64.12

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.12",
+  "source_commit": "ac15a977c04652b558eb4353f232ba4e26c87740",
+  "source_sha256": "6eadb8a389e466c1de0b4e3ad98a4978482eef4ae4afa59013f367efdd9b8805",
   "target": "darwin-arm64",
-  "sha256": "a466dac8ca5a03259c0e3bf03538f5c24ce0da9de09b8b3b626c63f6279c0b65"
+  "sha256": "50423b55ca6646d05cc79d73f3eac4ecc55f0d7bbed05f288e8b297c2a5b3cec"
 }

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.12",
+  "source_commit": "ac15a977c04652b558eb4353f232ba4e26c87740",
+  "source_sha256": "6eadb8a389e466c1de0b4e3ad98a4978482eef4ae4afa59013f367efdd9b8805",
   "target": "linux-x64",
-  "sha256": "53eab9515e51d2b35b7da60db3a8ab5107310499b22a77614e19bffcbd40ca88"
+  "sha256": "851f72b5be98d48eb631ea5dac259e0be32bcc1cf218c53e666bcdcc0bd02e6d"
 }

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.12",
+  "source_commit": "ac15a977c04652b558eb4353f232ba4e26c87740",
+  "source_sha256": "6eadb8a389e466c1de0b4e3ad98a4978482eef4ae4afa59013f367efdd9b8805",
   "targets": {
     "darwin-arm64": {
       "goos": "darwin",
       "goarch": "arm64",
       "binary": "daemon/bin/darwin-arm64/botbuddy-daemon",
-      "sha256": "a466dac8ca5a03259c0e3bf03538f5c24ce0da9de09b8b3b626c63f6279c0b65",
+      "sha256": "50423b55ca6646d05cc79d73f3eac4ecc55f0d7bbed05f288e8b297c2a5b3cec",
       "mode": "0755"
     },
     "linux-x64": {
       "goos": "linux",
       "goarch": "amd64",
       "binary": "daemon/bin/linux-x64/botbuddy-daemon",
-      "sha256": "53eab9515e51d2b35b7da60db3a8ab5107310499b22a77614e19bffcbd40ca88",
+      "sha256": "851f72b5be98d48eb631ea5dac259e0be32bcc1cf218c53e666bcdcc0bd02e6d",
       "mode": "0755"
     }
   }

package/package.json

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

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,
     });
   }