@botbuddy/cli 1.36.1 → 1.36.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbuddy/cli",
-  "version": "1.36.1",
+  "version": "1.36.3",
   "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

@@ -1279,21 +1279,62 @@ export const STACK_DISPOSITIONS = Object.freeze(["destroy", "stop"]);
  * the project's data volumes (`supabase_db_/storage_/edge_runtime_<project_id>`); `--workdir`
  * scopes that to the stack's own project_id, never `--all`. `stop` keeps the volumes for a
  * cheap re-provision. An unknown disposition throws before Docker is touched.
+ *
+ * BOT-2001: when `supabase stop` fails (2026-10-02: a transient exit 1 whose real error sat
+ * behind the CLI's deprecation WARN), log the tail of its output and fall back to a
+ * label-scoped teardown of exactly this project (`com.supabase.cli.project=<project_id>`),
+ * on the same validated daemon. Success requires the post-check `docker ps -a` for that
+ * label to be empty; no readable project_id → no fallback, never an unscoped `docker rm`.
  */
-export function localTeardown(stackDir, dockerTarget, disposition, spawn = spawnSync, env = process.env) {
+export function localTeardown(stackDir, dockerTarget, disposition, spawn = spawnSync, env = process.env, {
+  readProjectId = projectIdUnder, log = (line) => process.stderr.write(line),
+} = {}) {
   if (!STACK_DISPOSITIONS.includes(disposition)) {
     throw new Error(`localTeardown: unknown disposition ${JSON.stringify(disposition)} (expected one of ${STACK_DISPOSITIONS.join(", ")})`);
   }
   const args = ["stop", "--workdir", stackDir, ...(disposition === "destroy" ? ["--no-backup"] : [])];
-  process.stderr.write(`${yellow("⚠ LOCAL-EXEC FALLBACK")} — running ${bold(`supabase ${args.join(" ")}`)} (disposition ${disposition}).\n`);
-  const res = spawn("supabase", args, {
-    encoding: "utf8",
-    env: dockerEnvForTarget(dockerTarget, env),
-  });
-  if (res.status !== 0) {
-    process.stderr.write(`${yellow("⚠")} stack: supabase stop returned ${res.status}: ${(res.stderr || res.stdout || "").slice(0, 300)}\n`);
+  log(`${yellow("⚠ LOCAL-EXEC FALLBACK")} — running ${bold(`supabase ${args.join(" ")}`)} (disposition ${disposition}).\n`);
+  const dockerEnv = dockerEnvForTarget(dockerTarget, env);
+  const res = spawn("supabase", args, { encoding: "utf8", env: dockerEnv });
+  if (res.status === 0) return true;
+  // The real error is LAST (WARN/upgrade notices lead), so keep the tail, not the head.
+  const output = `${res.stderr || ""}${res.stdout || ""}`.trim();
+  log(`${yellow("⚠")} stack: supabase stop returned ${res.status}:\n${output.slice(-2000)}\n`);
+  const projectId = readProjectId(stackDir);
+  if (!projectId) {
+    log(`${yellow("⚠")} stack: no readable project_id under ${stackDir} — not attempting a label-scoped teardown.\n`);
+    return false;
+  }
+  return labelScopedTeardown(projectId, disposition, spawn, dockerEnv, log);
+}
+
+/** BOT-2001: remove exactly one Supabase project's containers, network and (for `destroy`)
+ * volumes by the CLI's project label; true iff a re-list finds NONE of the resource classes
+ * this disposition removes (Codex #1012: a busy volume or network fails closed too). */
+function labelScopedTeardown(projectId, disposition, spawn, dockerEnv, log) {
+  const filter = ["--filter", `label=com.supabase.cli.project=${projectId}`];
+  const docker = (args) => spawn("docker", args, { encoding: "utf8", env: dockerEnv });
+  const ids = (res) => (res.status === 0 ? (res.stdout || "").split(/\s+/).filter(Boolean) : null);
+  const classes = [
+    { name: "container", list: ["ps", "-aq", ...filter], remove: ["rm", "-f"] },
+    ...(disposition === "destroy" ? [{ name: "volume", list: ["volume", "ls", "-q", ...filter], remove: ["volume", "rm", "-f"] }] : []),
+    { name: "network", list: ["network", "ls", "-q", ...filter], remove: ["network", "rm"] },
+  ];
+  log(`${yellow("⚠")} stack: falling back to a label-scoped teardown of project ${bold(projectId)}.\n`);
+  for (const c of classes) {
+    const found = ids(docker(c.list));
+    if (found?.length) {
+      const rm = docker([...c.remove, ...found]);
+      if (rm.status !== 0) log(`${yellow("⚠")} stack: removing ${c.name}(s) of ${projectId} failed: ${`${rm.stderr || rm.stdout || ""}`.trim().slice(-500)}\n`);
+    }
+  }
+  const left = classes.map((c) => ({ name: c.name, ids: ids(docker(c.list)) })).filter((c) => c.ids === null || c.ids.length);
+  if (left.length) {
+    log(`${yellow("⚠")} stack: project ${projectId} still has ${left.map((c) => (c.ids === null ? `unverifiable ${c.name}s` : `${c.ids.length} ${c.name}(s)`)).join(", ")} after the fallback — the slot stays fenced.\n`);
+    return false;
   }
-  return res.status === 0;
+  log(`${yellow("⚠")} stack: label-scoped teardown of project ${projectId} succeeded.\n`);
+  return true;
 }
 
 function emit(receipt, opts, code) {

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