@botbuddy/cli 1.34.1 → 1.34.3

package/package.json

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

package/src/stack.mjs

@@ -699,7 +699,8 @@ export function leaseRefusalExit(code) {
   // BOT-1896: an auth-class refusal (scope_denied, a tenant mismatch, …) is the
   // server refusing the credential — never BACKEND, which a gate reads as "down".
   if (CALL_AUTH_ERROR_CODES.has(code)) return EXIT.AUTH;
-  return code === STACK_PATH_ROOT_REFUSED_CODE ? EXIT.INVALID : EXIT.BACKEND;
+  // BOT-1926: a reused lease requested in the other execution mode is fixable by the caller.
+  return code === STACK_PATH_ROOT_REFUSED_CODE || code === "STACK_EXECUTION_MODE_MISMATCH" ? EXIT.INVALID : EXIT.BACKEND;
 }
 
 /** The refusal text for a receipt: the server's message, else its code. */
@@ -1372,6 +1373,10 @@ export async function cmdUp(opts, {
     stack_path: execution.stackPath,
     worktree_root: execution.worktreeRoot,
     machine_uuid: hardwareUuid,
+    // BOT-1926: fence the provision job from the Helper server-side. Without it a
+    // polling Helper wins the request→reserve race, provisions the stack itself and
+    // records a targetless connection that `done --local-exec` cannot release.
+    ...(opts.localExec ? { local_exec: true } : {}),
   };
   let req = await call("request_stack_lease", leaseArgs);
   if (!req.ok && req.auth) {
@@ -1627,6 +1632,10 @@ export async function cmdDone(leaseId, opts, {
   let legacyTargetProof = null;
   let teardownDir = process.cwd();
   let leaseBefore = null;
+  // BOT-1926: a lease the Helper provisioned (it won the provision-job race, or the
+  // server predates the local-exec fence) is torn down BY the Helper from its own
+  // manifest. Locally it is not ours to stop: release it and let the reap job run.
+  let helperTeardown = false;
   if (opts.localExec) {
     // BOT-1887: the disposition picks the local teardown (destroy deletes the project's
     // volumes); refuse an unknown one BEFORE the lease is released into `reaping`.
@@ -1640,10 +1649,23 @@ export async function cmdDone(leaseId, opts, {
         error: current.error || current.data?.code || "could not verify the lease Docker target" }), opts,
       current.auth ? EXIT.AUTH : EXIT.BACKEND);
     }
+    leaseBefore = current.data;
+    if (current.data.provisioner === "helper_provisioning") {
+      // Codex #984 P1: the Helper has claimed but not finished provisioning; its manifest
+      // is stored only by its receipt. Releasing now would strand that stack — stay fenced.
+      return emitResult(buildReceipt({ command: "done", outcome: "refused", lease_id: leaseId,
+        error: "the Helper is still provisioning this lease; retry `stack done` once it is active. Lease and slot remain fenced." }), opts, EXIT.LEASE_FAILED);
+    }
+    helperTeardown = current.data.provisioner === "helper";
+  }
+  // BOT-1926: an already-reaped lease has nothing left to tear down locally (only a
+  // `reaping` release runs the local stop), so its target guards cannot protect anything.
+  // Refusing it only kept the hermetic orphan sweep retrying a finished lease forever.
+  if (opts.localExec && !helperTeardown && leaseBefore.state !== "reaped") {
+    const current = { data: leaseBefore };
     // BOT-1711: tear down in the directory the stack was PROVISIONED in (the lease's
     // recorded worktree_root/stack_path), not the invoking cwd — otherwise `supabase
     // stop` at the worktree root would stop the shared canonical stack.
-    leaseBefore = current.data;
     teardownDir = leaseStackDir(current.data);
     // BOT-1711 (Codex P1, R4): refuse local-exec teardown of ANY lease whose target is the
     // worktree root / default project — BEFORE branching on the persisted Docker target.
@@ -1765,7 +1787,7 @@ export async function cmdDone(leaseId, opts, {
       error: `the lease's established reap disposition ${JSON.stringify(established)} is unknown — NOT tearing down; the slot stays fenced` }), opts, EXIT.BACKEND);
   }
   const disposition = alreadyReaped ? established : (established ?? opts.disposition);
-  if (opts.localExec && state === "reaping") {
+  if (opts.localExec && !helperTeardown && state === "reaping") {
     // Only finalize once the stack is PROVABLY down. A failed `supabase stop` (Docker
     // unavailable, etc.) must NOT finalize — finalize frees the slot lock and promotes
     // the next queued lease, which would collide with containers still running on this
@@ -1782,6 +1804,7 @@ export async function cmdDone(leaseId, opts, {
     else process.stderr.write(`${yellow("⚠")} stack: finalize failed (${fin.error || fin.data?.code}); the reaper will reconcile.\n`);
   }
   return emitResult(buildReceipt({ command: "done", outcome: "released", lease_id: leaseId, state, disposition,
+    ...(helperTeardown ? { teardown: "helper" } : {}),
     ...(legacyTargetProof ? { legacy_target_proof: legacyTargetProof } : {}) }), opts, EXIT.OK);
 }