@botbuddy/cli 1.36.0 → 1.36.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbuddy/cli",
-  "version": "1.36.0",
+  "version": "1.36.2",
   "description": "BotBuddy — Swarm coordination CLI for multi-agent workflows",
   "type": "module",
   "bin": {

package/src/session-bootstrap.mjs

@@ -43,10 +43,10 @@ export async function saveHarnessSession(session, { cwd = process.cwd() } = {})
     worktree: root,
     minted_at: new Date().toISOString(),
     expires_at: session.expires_at,
-    // BOT-1650 (Codex round-28 P2): mark provenance so a TIMER wait only relays for
-    // a bootstrap-issued cache (the cross-shell receipt-of-principal contract). A
-    // bb setup / self-heal cache shares this schema but omits this marker, so a
-    // plain timer from such a shell stays fully offline.
+    // BOT-1650 (Codex round-28 P2): mark bootstrap provenance. Since BOT-2000 a
+    // TIMER wait relays for ANY runtime cache (bootstrap or bb setup / self-heal),
+    // so this marker no longer gates timer relaying; it still distinguishes a
+    // bootstrap-issued cache for the bootstrap bridge's own reuse checks.
     harness_origin: "bootstrap_agent_session",
     ...(session.session_token_generation ? { session_token_generation: session.session_token_generation } : {}),
   };

package/src/stack.mjs

@@ -1587,19 +1587,24 @@ export async function cmdUp(opts, {
   }), opts, EXIT.OK);
 }
 
-async function cmdStatus(leaseId, opts, { rpc = retryingStackCall() } = {}) {
+export async function cmdStatus(leaseId, opts, { rpc = retryingStackCall(), emitResult = emit } = {}) {
   const auth = await rpc.init();
-  if (!auth) return emit(buildReceipt({ command: "status", outcome: "error", lease_id: leaseId, error: "not authenticated — run `botbuddy login`" }), opts, EXIT.AUTH);
+  if (!auth) return emitResult(buildReceipt({ command: "status", outcome: "error", lease_id: leaseId, error: "not authenticated — run `botbuddy login`" }), opts, EXIT.AUTH);
   const got = await rpc.call("get_stack_lease", { lease_id: leaseId });
   if (!got.ok) return got.auth
-    ? emit(buildReceipt({ command: "status", outcome: "error", lease_id: leaseId, error: got.error }), opts, EXIT.AUTH)
-    : emit(buildReceipt({ command: "status", outcome: "error", lease_id: leaseId, error: got.error }), opts, EXIT.BACKEND);
+    ? emitResult(buildReceipt({ command: "status", outcome: "error", lease_id: leaseId, error: got.error }), opts, EXIT.AUTH)
+    : emitResult(buildReceipt({ command: "status", outcome: "error", lease_id: leaseId, error: got.error }), opts, EXIT.BACKEND);
   const g = got.data;
-  if (!g.success) return emit(buildReceipt({ command: "status", outcome: "error", lease_id: leaseId, code: g.code, error: g.code }), opts, EXIT.BACKEND);
-  return emit(buildReceipt({
+  if (!g.success) return emitResult(buildReceipt({ command: "status", outcome: "error", lease_id: leaseId, code: g.code, error: g.code }), opts, EXIT.BACKEND);
+  return emitResult(buildReceipt({
     command: "status", outcome: g.state, lease_id: leaseId, state: g.state,
     host_key: g.host_key, slot: g.slot, connection: g.connection,
     queue_position: g.queue_position, idle_ttl_secs: g.idle_ttl_secs, queued: g.queued,
+    // BOT-1960: a lease fenced in `reaping` says since when, and — once the server gave up
+    // retrying its failed reap — that it is reap_failed and why.
+    ...(g.reap_requested_at ? { reap_requested_at: g.reap_requested_at } : {}),
+    ...(g.reap_failed_at ? { reap_failed: true, reap_failed_at: g.reap_failed_at } : {}),
+    ...(g.state === "reaping" && g.error ? { error: g.error } : {}),
   }), opts, EXIT.OK);
 }
 
@@ -1803,7 +1808,27 @@ export async function cmdDone(leaseId, opts, {
     if (fin.ok && fin.data?.success) state = fin.data.state;
     else process.stderr.write(`${yellow("⚠")} stack: finalize failed (${fin.error || fin.data?.code}); the reaper will reconcile.\n`);
   }
+  // BOT-1960: on a lease fenced in `reaping` by a FAILED reap, the server re-enqueues the
+  // reap (the first time also resetting its retry budget) — or, once that budget is spent,
+  // refuses. Say which, instead of a `released` that changed nothing.
+  const retry = r.data.reap_retry;
+  if (state === "reaping" && retry?.code === "REAP_RETRY_BUDGET_SPENT") {
+    const since = r.data.reap_failed_at ? ` (since ${r.data.reap_failed_at})` : "";
+    return emitResult(buildReceipt({ command: "done", outcome: "reap_failed", lease_id: leaseId, state, disposition,
+      reap_failed_at: r.data.reap_failed_at ?? null, reap_retry: { enqueued: false, code: retry.code },
+      error: `the reap failed on every retry${since}; no retries left — the lease stays reaping and its slot stays fenced. ` +
+        "Remove the project's leftover containers (operator / `botbuddy docker hygiene`); the container census then finalizes the lease.",
+    }), opts, EXIT.LEASE_FAILED);
+  }
+  const retried = retry?.code === "REAP_RETRY_ENQUEUED"
+    ? {
+      reap_retry: { enqueued: true, attempt: retry.attempt, budget_reset: retry.budget_reset === true },
+      note: `the previous reap failed; a new reap job (attempt ${retry.attempt}) was enqueued` +
+        (retry.budget_reset === true ? " and the reap retry budget was reset" : ""),
+    }
+    : {};
   return emitResult(buildReceipt({ command: "done", outcome: "released", lease_id: leaseId, state, disposition,
+    ...retried,
     ...(helperTeardown ? { teardown: "helper" } : {}),
     ...(legacyTargetProof ? { legacy_target_proof: legacyTargetProof } : {}) }), opts, EXIT.OK);
 }

package/src/wait.mjs

@@ -19,7 +19,7 @@ import { VERSION } from "./version.mjs";
 import { fileURLToPath } from "node:url";
 import { latestPublicCliCommand } from "./public-invocation.mjs";
 import { AGENT_KEY_RE, readAgentSessionTokenEnv, legacyAgentAliasHint } from "./agent-key.mjs";
-import { clearAgentState, hasBootstrapAgentSession, isRejectedCachedSession, resolveAgentSessionCredential, selfHealAgentSession } from "./agent-session.mjs";
+import { clearAgentState, hasAgentSessionRuntime, isRejectedCachedSession, resolveAgentSessionCredential, selfHealAgentSession } from "./agent-session.mjs";
 import { touchAgentStateExpiry } from "./agent-state.mjs";
 import { SETUP_BLOCK } from "./setup-block.mjs";
 import { createWaitCheckpointStore, WaitCheckpointError } from "./wait-checkpoint.mjs";
@@ -1568,11 +1568,12 @@ export async function runWait(argv, { recoveryLocalWaitId = null } = {}) {
       : new WaitCheckpointError("wait_checkpoint_write_failed", String(error?.message ?? error)));
   }
 
-  // BOT-1650: a plain timer stays offline, but a timer from a bootstrapped harness
-  // registers so its terminal receipt proves the current session principal (the
-  // cross-shell bootstrap contract). Detected without a network self-heal.
+  // BOT-1650 / BOT-2000: a timer from a worktree with any agent-session runtime
+  // file (bootstrap or `bb setup`) registers, so it shows on /waits and its terminal
+  // receipt proves the session principal. Only a credential-less worktree's timer
+  // stays offline. Detected without a network self-heal.
   const needsRelay = conditions.some((c) => c.type !== "timer")
-    || await hasBootstrapAgentSession({ cwd: process.cwd() });
+    || await hasAgentSessionRuntime({ cwd: process.cwd() });
   if (needsRelay) {
     try {
       const credential = await resolveAgentSessionCredential({ argv, env: process.env, cwd: process.cwd() });