@botbuddy/cli 1.53.1 → 1.54.0

package/package.json

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

package/src/stack.mjs

@@ -586,6 +586,7 @@ const CONSIDERED_VERDICT_TEXT = {
   HOST_CAPACITY_WAIT: () => "Docker pressure full",
   HOST_CAPACITY_BUDGET_FULL: () => "slot budget full",
   HOST_CAPACITY_INVENTORY_UNKNOWN: () => "unknown Docker resources in its census",
+  HOST_PRESSURE: () => "host under pressure",
   TENANT_RESERVATION_FULL: () => "tenant reservation full",
   SLOT_HELD: () => "this slot is already leased there",
   HOST_HELPER_OUTDATED: () => "Helper predates remote leases (protocol < 4)",
@@ -605,6 +606,33 @@ export function describeConsidered(considered) {
     });
 }
 
+/**
+ * BOT-1630: the typed park reason of a queued lease, or null. The server holds a host under
+ * pressure (`docker info` failing, low memory, engine footprint) with verdict HOST_PRESSURE, and
+ * a Helper that hits it mid-provision defers the lease back to the queue with that reason.
+ */
+export function queuedParkReason(d) {
+  if (!d || typeof d !== "object") return null;
+  const ledger = d.ledger && typeof d.ledger === "object" ? d.ledger : null;
+  if (ledger?.verdict === "HOST_PRESSURE" || ledger?.capacity?.code === "HOST_PRESSURE") return "host_pressure";
+  const here = Array.isArray(d.considered) ? d.considered.find((c) => c?.host_key === d.host_key) : null;
+  if (here?.verdict_code === "HOST_PRESSURE") return "host_pressure";
+  if (d.provision_defer_reason === "HOST_PRESSURE") return "host_pressure";
+  return null;
+}
+
+/** BOT-1630: "docker_unresponsive (docker_command_failed:docker info:-2; clears …)" per binding dimension. */
+export function describePressure(d) {
+  const reasons = d?.ledger?.capacity?.pressure?.reasons;
+  if (!Array.isArray(reasons) || reasons.length === 0) return null;
+  return reasons.filter((r) => r && typeof r.dimension === "string").map((r) => {
+    const parts = [];
+    if (r.observed != null) parts.push(r.limit != null ? `${r.observed} vs limit ${r.limit}` : String(r.observed));
+    if (typeof r.clears_at === "string") parts.push(`clears ${r.clears_at}`);
+    return parts.length ? `${r.dimension} (${parts.join("; ")})` : r.dimension;
+  }).join(", ") || null;
+}
+
 export function describeUnitLedger(ledger) {
   if (!ledger || typeof ledger !== "object") return [];
   const cap = ledger.capacity ?? {};
@@ -3547,16 +3575,28 @@ async function runStackLifecycleOnce(opts, childArgv, adapters, incidentBox) {
       const cleanup = await requestCleanup();
       return { exitCode: SIGNAL_EXIT[receivedSignal], outcome: "interrupted", leaseId, cleanup };
     }
+    // BOT-1630: ONE park budget (--timeout) across every park. A Helper that finds the host under
+    // pressure mid-provision defers the lease back to `queued` (its place kept); run then parks
+    // again against the same deadline instead of timing out on the provision clock.
+    const parkDeadlineMs = (adapters.now ?? Date.now)() + opts.timeout * 1000;
+    let parkView = request.data;
+    let parkReason = null;
+    for (;;) {
     if (state === "queued") {
       // BOT-2019: say where the lease sits (server dispatch rank, or why it has none) before parking.
-      stderrLine(`stack: lease ${leaseId} queued — ${describeQueuePosition(request.data)}`);
-      for (const line of describeUnitLedger(request.data.ledger)) stderrLine(`stack: ${line}`);
-      for (const line of describeConsidered(request.data.considered)) stderrLine(`stack: ${line}`);
+      stderrLine(`stack: lease ${leaseId} queued — ${describeQueuePosition(parkView)}`);
+      for (const line of describeUnitLedger(parkView.ledger)) stderrLine(`stack: ${line}`);
+      for (const line of describeConsidered(parkView.considered)) stderrLine(`stack: ${line}`);
+      parkReason = queuedParkReason(parkView) ?? parkReason;
+      if (parkReason === "host_pressure") {
+        const why = describePressure(parkView);
+        stderrLine(`stack: parked — park_reason host_pressure${why ? `: ${why}` : ""}; the lease keeps its queue place and starts when the host's pressure clears`);
+      }
       activeWaitAbort = new AbortController();
       // BOT-2013: every reap state (reaping / reaped / reap_failed) means the queued lease is lost.
       // BOT-2099: an auth/availability blip is retried inside the park until its deadline;
       // it never releases a queued lease or becomes the lease's outcome.
-      const parked = await resilientWait(leaseId, (s) => s !== "queued" && s != null, isReaped, { timeoutSec: opts.timeout, auth: rpc.auth, signal: activeWaitAbort.signal });
+      const parked = await resilientWait(leaseId, (s) => s !== "queued" && s != null, isReaped, { timeoutSec: opts.timeout, deadlineMs: parkDeadlineMs, auth: rpc.auth, signal: activeWaitAbort.signal });
       activeWaitAbort = null;
       const incident = parkIncident ? { incident: parkIncident } : {};
       if (parked?.interrupted || receivedSignal) { const cleanup = await requestCleanup(); return { exitCode: SIGNAL_EXIT[receivedSignal], outcome: "interrupted", leaseId, cleanup, ...incident }; }
@@ -3578,7 +3618,7 @@ async function runStackLifecycleOnce(opts, childArgv, adapters, incidentBox) {
             error: `lease ${leaseId} parked ${opts.timeout}s inside a platform incident (${parkIncident.reason} since ${parkIncident.first_at}), so its admission was never observed`,
           };
         }
-        return { exitCode: EXIT.TIMEOUT, outcome: "timeout", leaseId, error: `parked ${opts.timeout}s without capacity`, cleanup, ...incident, ...(ledger ? { ledger } : {}) };
+        return { exitCode: EXIT.TIMEOUT, outcome: "timeout", leaseId, error: `parked ${opts.timeout}s without capacity`, cleanup, ...incident, ...(ledger ? { ledger } : {}), ...(parkReason ? { parkReason } : {}) };
       }
       if (parked?.failed) { const cleanup = await requestCleanup(); return { exitCode: EXIT.LEASE_FAILED, outcome: "error", leaseId, error: `lease was ${parked.state} while queued (reap_reason=${parked.reap_reason ?? "unknown"})`, cleanup, ...incident }; }
       if (parked?.error || parked?.auth) { const cleanup = await requestCleanup(); return { exitCode: parked?.auth ? EXIT.AUTH : EXIT.LEASE_FAILED, outcome: "error", leaseId, error: parked?.error || "lease did not leave queue", cleanup, ...incident }; }
@@ -3593,17 +3633,33 @@ async function runStackLifecycleOnce(opts, childArgv, adapters, incidentBox) {
       // provisionTimeout before the belt-and-braces recheck below ever notices
       // the lease is no longer provisioning. isReaped (== "reaping" || "reaped")
       // already covers both; cmdUp's equivalent waits use it for this reason.
-      const active = await resilientWait(leaseId, (s) => s === "active", isReaped, { timeoutSec: provisionTimeout, auth: rpc.auth, signal: activeWaitAbort.signal });
+      // BOT-1630: `queued` also ends this wait — a deferred provision (HOST_PRESSURE, capacity).
+      const active = await resilientWait(leaseId, (s) => s === "active" || s === "queued", isReaped, { timeoutSec: provisionTimeout, auth: rpc.auth, signal: activeWaitAbort.signal });
       activeWaitAbort = null;
       if (active?.interrupted || receivedSignal) { const cleanup = await requestCleanup(); return { exitCode: SIGNAL_EXIT[receivedSignal], outcome: "interrupted", leaseId, cleanup }; }
       if (active?.authUnavailable) { const cleanup = await requestCleanup(); return authUnavailableResult(active, "provisioning", cleanup); }
+      if (active?.state === "queued" && !active.timeout && !active.failed && !active.error && !active.auth) {
+        const read = await readLeaseQuietly(leaseId);
+        parkView = read?.ok && read.data?.success ? read.data : { host_key: placement.hostKey };
+        const why = parkView.provision_defer_reason ?? "host capacity";
+        stderrLine(`stack: lease ${leaseId} was deferred back to the queue while provisioning (${why}) — its place is kept; parking again`);
+        state = "queued";
+        continue;
+      }
       if (active?.timeout) {
         // BOT-1822 belt-and-braces: the zero-poll wait can still miss a live
         // `stack_lease` signal (an older server before this fix, a relay hiccup,
         // BOT-1816's class of dropped wakes) even though the lease genuinely went
-        // active. One direct read before declaring a timeout tells that apart from
-        // a lease that truly never provisioned, instead of reaping a healthy stack.
+        // active or was deferred back to queued. One direct read before declaring
+        // a timeout avoids reaping a healthy stack or destroying a kept queue place.
         const recheck = await api.get(leaseId);
+        if (recheck?.ok && recheck.data?.success && recheck.data.state === "queued") {
+          parkView = recheck.data;
+          const why = parkView.provision_defer_reason ?? "host capacity";
+          stderrLine(`stack: lease ${leaseId} was deferred back to the queue while provisioning (${why}) — its place is kept; parking again`);
+          state = "queued";
+          continue;
+        }
         if (!(recheck?.ok && recheck.data?.success && recheck.data.state === "active")) {
           const cleanup = await requestCleanup();
           return { exitCode: EXIT.TIMEOUT, outcome: "timeout", leaseId, error: `physical provision did not reach active in ${provisionTimeout}s`, cleanup, ...(parkIncident ? { incident: parkIncident } : {}) };
@@ -3621,6 +3677,8 @@ async function runStackLifecycleOnce(opts, childArgv, adapters, incidentBox) {
         return { exitCode: active?.auth ? EXIT.AUTH : EXIT.LEASE_FAILED, outcome: "error", leaseId, error: active?.error || `lease ${active?.state ?? "failed"} before reaching active${why}`, cleanup, ...(parkIncident ? { incident: parkIncident } : {}) };
       }
     }
+    break;
+    }
     const current = await api.get(leaseId);
     if (!current?.ok || !current.data?.success || current.data.state !== "active" || !current.data.connection || typeof current.data.connection !== "object") {
       const cleanup = await requestCleanup();