@botbuddy/cli 1.41.1 → 1.42.0

package/package.json

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

package/src/stack.mjs

@@ -174,6 +174,11 @@ ${bold("REMOTE LEASES")} (BOT-2142, stack run)
   The receipt carries execution_mode (local|remote), execution_host_key, requester_host,
   transport (none|ssh-forward), and for a remote lease forwards [{name, remote, local}] + bundle.
   The child also gets BOTBUDDY_STACK_EXECUTION_MODE and BOTBUDDY_STACK_TRANSPORT.
+  Requeue (BOT-2207): under auto, a lease that QUEUES on this machine uploads its bundle at once;
+  every minute the control plane re-offers it to this owner's other hosts and it may move there
+  (placement_reason moved_remote_on_requeue), and run then forwards to the new host. While queued,
+  run prints one \`considered: <host> — <verdict>\` line per host weighed (e.g. "census stale 131 s");
+  the receipt carries placement_reason and considered[].
   5 REMOTE_UNREACHABLE    the host has no ssh_target (an operator must set it), or
                           \`ssh <target>\` could not open the forwards (BatchMode: key auth only)
   5 REMOTE_UNSUPPORTED    --remote, but the control plane placed the lease locally (pre-remote server)
@@ -455,6 +460,35 @@ export function describeQueuePosition(d) {
  * starved lease names its holders instead of only its position. Other tenants' leases are
  * tenant + state + since; unleased stacks are 5-character prefixes (the server redacts).
  */
+// BOT-2207: one human line per host the control plane weighed for an \`auto\` lease
+// (request_stack_lease / get_stack_lease \`considered[]\`), e.g. "considered: mac-mini — census
+// stale 131 s". An unknown verdict code is printed as-is.
+const CONSIDERED_VERDICT_TEXT = {
+  ADMITS: (c) => `admits (${c.free_slots ?? 0} free)`,
+  HOST_CAPACITY_INVENTORY_STALE: (c) => (Number.isFinite(c.snapshot_age_seconds) ? `census stale ${c.snapshot_age_seconds} s` : "no census yet"),
+  HOST_CAPACITY_SOURCE_STALE: () => "capacity beacon stale",
+  HOST_CAPACITY_WAIT: () => "Docker pressure full",
+  HOST_CAPACITY_BUDGET_FULL: () => "slot budget full",
+  HOST_CAPACITY_INVENTORY_UNKNOWN: () => "unknown Docker resources in its census",
+  TENANT_RESERVATION_FULL: () => "tenant reservation full",
+  SLOT_HELD: () => "this slot is already leased there",
+  HOST_HELPER_OUTDATED: () => "Helper predates remote leases (protocol < 4)",
+  HOST_NO_SSH_TARGET: () => "no ssh_target set",
+  HOST_INACTIVE: () => "host inactive",
+};
+
+export function describeConsidered(considered) {
+  if (!Array.isArray(considered)) return [];
+  return considered
+    .filter((c) => c && typeof c === "object" && typeof c.host_key === "string")
+    .map((c) => {
+      const name = (typeof c.display_name === "string" && c.display_name) || c.host_key;
+      const where = c.location === "local" ? " (this machine)" : "";
+      const text = CONSIDERED_VERDICT_TEXT[c.verdict_code]?.(c) ?? String(c.verdict_code ?? "unknown");
+      return `considered: ${name}${where} — ${text}`;
+    });
+}
+
 export function describeUnitLedger(ledger) {
   if (!ledger || typeof ledger !== "object") return [];
   const cap = ledger.capacity ?? {};
@@ -2752,7 +2786,7 @@ async function runStackLifecycleOnce(opts, childArgv, adapters, incidentBox) {
   // BOT-2142: the remote lease's forwards, and whether they died under a running child.
   let tunnel = null;
   let tunnelLost = null;
-  const placement = { mode: null, hostKey: null, requesterHost: null, transport: "none", forwards: null, bundle: null };
+  const placement = { mode: null, hostKey: null, requesterHost: null, transport: "none", forwards: null, bundle: null, placementReason: null, considered: null };
   incidentBox.execution = placement;
   const closeTunnel = async () => {
     if (!tunnel) return;
@@ -2995,6 +3029,9 @@ async function runStackLifecycleOnce(opts, childArgv, adapters, incidentBox) {
     placement.mode = request.data.execution_mode ?? null;
     placement.hostKey = request.data.host_key ?? null;
     placement.requesterHost = request.data.requester_host ?? null;
+    // BOT-2207: why the server placed (or queued) it there, and every host it weighed.
+    placement.placementReason = request.data.placement_reason ?? null;
+    placement.considered = Array.isArray(request.data.considered) ? request.data.considered : null;
     if (executionRequest === "remote" && !remoteLease) {
       const cleanup = await requestCleanup();
       return {
@@ -3045,6 +3082,23 @@ async function runStackLifecycleOnce(opts, childArgv, adapters, incidentBox) {
       }
       placement.bundle = { sha256: bundle.sha256, bytes: bundle.size };
       stderrLine(`stack: lease ${leaseId} is remote on ${placement.hostKey ?? "?"} — uploaded the ${bundle.size}-byte stack bundle (sha256 ${bundle.sha256.slice(0, 12)}…)`);
+    } else if (bundle && state === "queued" && request.data.bundle_upload_url) {
+      // BOT-2207: the lease queued HERE but may still move: every minute the control plane
+      // re-offers it to the owner's other hosts, and it can only move with its bundle in
+      // storage. Upload now. A failed upload is not fatal — the lease just stays queued here.
+      activeWaitAbort = new AbortController();
+      const uploaded = await uploadBundle(request.data.bundle_upload_url, bundle, { signal: activeWaitAbort.signal });
+      activeWaitAbort = null;
+      if (receivedSignal) {
+        const cleanup = await requestCleanup();
+        return { exitCode: SIGNAL_EXIT[receivedSignal], outcome: "interrupted", leaseId, cleanup };
+      }
+      if (uploaded?.ok) {
+        placement.bundle = { sha256: bundle.sha256, bytes: bundle.size };
+        stderrLine(`stack: lease ${leaseId} queued on ${placement.hostKey ?? "?"} — uploaded the ${bundle.size}-byte stack bundle so it can move to another owned host that admits first`);
+      } else {
+        stderrLine(`${yellow("⚠")} stack: could not upload the stack bundle (${uploaded?.error || "upload failed"}); lease ${leaseId} stays queued on ${placement.hostKey ?? "this host"} and cannot move to another host.`);
+      }
     }
     if (receivedSignal) {
       const cleanup = await requestCleanup();
@@ -3054,6 +3108,7 @@ async function runStackLifecycleOnce(opts, childArgv, adapters, incidentBox) {
       // 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}`);
       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;
@@ -3123,8 +3178,20 @@ async function runStackLifecycleOnce(opts, childArgv, adapters, incidentBox) {
 
     placement.hostKey = current.data.host_key ?? placement.hostKey;
     placement.mode = current.data.execution_mode ?? placement.mode ?? (remoteLease ? "remote" : null);
+    placement.placementReason = current.data.placement_reason ?? placement.placementReason;
+    if (Array.isArray(current.data.considered)) placement.considered = current.data.considered;
+    // BOT-2207: a queued auto lease may have been MOVED to another owned host while it waited.
+    // Follow it exactly like a first-time remote placement: forward to the NEW host's ssh_target.
+    const servedRemote = remoteLease || current.data.execution_mode === "remote";
+    if (servedRemote && !remoteLease) {
+      stderrLine(`stack: lease ${leaseId} moved to ${placement.hostKey ?? "another host"} while queued (${placement.placementReason ?? "moved"}) — forwarding to it`);
+      if (opts.callbackPort != null) {
+        const cleanup = await requestCleanup();
+        return { exitCode: EXIT.INVALID, outcome: "error", code: CALLBACK_PORT_UNSUPPORTED_REMOTE, leaseId, cleanup, error: CALLBACK_PORT_REMOTE_REFUSAL };
+      }
+    }
     let childConnection = current.data.connection;
-    if (remoteLease) {
+    if (servedRemote) {
       // BOT-2142: forward every stack port over ONE ssh and hand the child the local ports.
       sshTarget = current.data.connection?.ssh_target ?? current.data.ssh_target ?? sshTarget;
       try {
@@ -3162,7 +3229,7 @@ async function runStackLifecycleOnce(opts, childArgv, adapters, incidentBox) {
       BOTBUDDY_STACK_CONNECTION_FILE: connectionFile,
       // BOT-2142: lets a lane's own checks (e.g. the port-owner preflight) know the
       // listeners are SSH forwards to another host, not this machine's Docker.
-      BOTBUDDY_STACK_EXECUTION_MODE: remoteLease ? "remote" : (placement.mode ?? "local"),
+      BOTBUDDY_STACK_EXECUTION_MODE: servedRemote ? "remote" : (placement.mode ?? "local"),
       BOTBUDDY_STACK_TRANSPORT: placement.transport,
       ...(leasedTestConfig ? {
         BB_INTEGRATION_ENV_FILE: leasedTestConfig.envFile,
@@ -3262,6 +3329,9 @@ async function cmdRun(opts, childArgv) {
     transport: result.execution?.transport ?? "none",
     ...(result.execution?.forwards ? { forwards: result.execution.forwards } : {}),
     ...(result.execution?.bundle ? { bundle: result.execution.bundle } : {}),
+    // BOT-2207: why it ran where it did (e.g. moved_remote_on_requeue) and every host weighed.
+    ...(result.execution?.placementReason ? { placement_reason: result.execution.placementReason } : {}),
+    ...(result.execution?.considered ? { considered: result.execution.considered } : {}),
     fenced: result.fenced ?? false, error: result.error ?? result.cleanup?.error ?? null,
     // BOT-2099: a platform auth/availability blip during the park is reported as an
     // incident (reason, window, attempts, recovered) — never as the lease's outcome.