@botbuddy/cli 1.64.12 → 1.64.13

package/daemon-release/darwin-arm64.json

@@ -1,7 +1,7 @@
 {
-  "release_version": "1.64.12",
-  "source_commit": "ac15a977c04652b558eb4353f232ba4e26c87740",
-  "source_sha256": "6eadb8a389e466c1de0b4e3ad98a4978482eef4ae4afa59013f367efdd9b8805",
+  "release_version": "1.64.13",
+  "source_commit": "db2f7f45e8e0444857a2046c18481e107e3ebf58",
+  "source_sha256": "1533000de11720445186669ac3bf3eb7c663962f809b4035a52fa4de9c368213",
   "target": "darwin-arm64",
-  "sha256": "50423b55ca6646d05cc79d73f3eac4ecc55f0d7bbed05f288e8b297c2a5b3cec"
+  "sha256": "8c2dd7c45a7e1c697fa47e5044a1b1cd6703efbb7fc648e1042a104c784094bb"
 }

package/daemon-release/linux-x64.json

@@ -1,7 +1,7 @@
 {
-  "release_version": "1.64.12",
-  "source_commit": "ac15a977c04652b558eb4353f232ba4e26c87740",
-  "source_sha256": "6eadb8a389e466c1de0b4e3ad98a4978482eef4ae4afa59013f367efdd9b8805",
+  "release_version": "1.64.13",
+  "source_commit": "db2f7f45e8e0444857a2046c18481e107e3ebf58",
+  "source_sha256": "1533000de11720445186669ac3bf3eb7c663962f809b4035a52fa4de9c368213",
   "target": "linux-x64",
-  "sha256": "851f72b5be98d48eb631ea5dac259e0be32bcc1cf218c53e666bcdcc0bd02e6d"
+  "sha256": "81345fbe3fde99c1b41f7d1738f00ef2bf4be9de12fe39e0755f23546ed4ed3f"
 }

package/daemon-release/manifest.json

@@ -1,21 +1,21 @@
 {
   "schema_version": 1,
-  "release_version": "1.64.12",
-  "source_commit": "ac15a977c04652b558eb4353f232ba4e26c87740",
-  "source_sha256": "6eadb8a389e466c1de0b4e3ad98a4978482eef4ae4afa59013f367efdd9b8805",
+  "release_version": "1.64.13",
+  "source_commit": "db2f7f45e8e0444857a2046c18481e107e3ebf58",
+  "source_sha256": "1533000de11720445186669ac3bf3eb7c663962f809b4035a52fa4de9c368213",
   "targets": {
     "darwin-arm64": {
       "goos": "darwin",
       "goarch": "arm64",
       "binary": "daemon/bin/darwin-arm64/botbuddy-daemon",
-      "sha256": "50423b55ca6646d05cc79d73f3eac4ecc55f0d7bbed05f288e8b297c2a5b3cec",
+      "sha256": "8c2dd7c45a7e1c697fa47e5044a1b1cd6703efbb7fc648e1042a104c784094bb",
       "mode": "0755"
     },
     "linux-x64": {
       "goos": "linux",
       "goarch": "amd64",
       "binary": "daemon/bin/linux-x64/botbuddy-daemon",
-      "sha256": "851f72b5be98d48eb631ea5dac259e0be32bcc1cf218c53e666bcdcc0bd02e6d",
+      "sha256": "81345fbe3fde99c1b41f7d1738f00ef2bf4be9de12fe39e0755f23546ed4ed3f",
       "mode": "0755"
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbuddy/cli",
-  "version": "1.64.12",
+  "version": "1.64.13",
   "description": "BotBuddy \u2014 Swarm coordination CLI for multi-agent workflows",
   "type": "module",
   "bin": {

package/src/commands.mjs

@@ -10,7 +10,7 @@ import { bootstrapHarnessSession, clearHarnessSession, doctorBootstrapState, for
 import { loadConfig, getConfig, clearConfig, getConfigPath, SERVER_URL } from "./config.mjs";
 import { resolveOwnerToken, resolveAgentKey, clearOwnerToken } from "./cli-credentials.mjs";
 import { agentProfileKeyLabel } from "./credential-kinds.mjs";
-import { buildAcquireResourcesPayload, LocksUsageError } from "./locks.mjs";
+import { buildAcquireResourcesPayload, LocksUsageError, classifyLockResponse, lockOutcomeLines, unlockOutcomeLines, UNLOCK_QUEUED_USAGE } from "./locks.mjs";
 import { CallUsageError, discoveryUrlFor, formatDiscovery, parseCallArgs } from "./discovery.mjs";
 import { cmdStack } from "./stack.mjs";
 import { cmdManagedAllocation } from "./managed-allocation.mjs";
@@ -302,7 +302,14 @@ ${bold("STAGING SIGN-IN")} (BOT-2084)
 ${bold("LOCKS")}
   locks -m [--host name]     Reserve typed local resources, including Playwright MCP lanes
   lock <resource_name> <type>  Acquire one named lock (acquire_lock)
-  unlock <resource_name>     Release one named lock (release_lock)
+                             locks/lock: exit 0 acquired · 2 queued · 1 refused.
+                             Use a resource only after exit 0; queued means another
+                             agent holds it and you are in line for it.
+  unlock <resource_name>     Release one named lock you hold (release_lock); it
+                             does not withdraw a queued request
+  unlock --queued <resource_id> <resource_lock_id>
+                             Withdraw your queued request (ids from the queued
+                             lock result; retire_queued_lock_attempt)
 
 ${bold("DURABLE WORKLOADS")}  (${cyan("bb help run")})
   run --session-id <id> --environment <env> -- <command>
@@ -1713,23 +1720,41 @@ export async function cmdMcp(args, {
   die(`Unknown mcp subcommand: ${sub}. Run ${cyan("botbuddy mcp --help")}.`);
 }
 
-function cmdLock(args) {
+// BOT-2994: each lock command returns its exit code (0 acquired · 2 queued ·
+// 1 refused; auth 3 / transport 5 unchanged) and says on stderr what the caller
+// holds. stdout keeps the server's result exactly as before.
+async function finishLock(response, lines) {
+  const outcome = classifyLockResponse(response);
+  for (const line of lines(outcome)) console.error(line);
+  return outcome.exit;
+}
+
+async function cmdLock(args) {
   if (args.length < 2) die("Usage: botbuddy lock <resource_name> <type>");
-  return callTool("acquire_lock", { resource_name: args[0], resource_type: args[1] });
+  return finishLock(await callTool("acquire_lock", { resource_name: args[0], resource_type: args[1] }), lockOutcomeLines);
 }
 
-function cmdLocks(args) {
+async function cmdLocks(args) {
+  let payload;
   try {
-    return callTool("acquire_resources", buildAcquireResourcesPayload(args));
+    payload = buildAcquireResourcesPayload(args);
   } catch (error) {
     if (error instanceof LocksUsageError) die(error.message);
     throw error;
   }
+  return finishLock(await callTool("acquire_resources", payload), lockOutcomeLines);
 }
 
-function cmdUnlock(args) {
+async function cmdUnlock(args) {
+  // BOT-2994: release_lock only releases a lock you HOLD; a queued request is
+  // withdrawn by its exact resource + queued-ledger ids (retire_queued_lock_attempt).
+  if (args[0] === "--queued") {
+    if (args.length !== 3 || !args[1] || !args[2] || args[1].startsWith("-") || args[2].startsWith("-")) die(UNLOCK_QUEUED_USAGE);
+    const response = await callTool("retire_queued_lock_attempt", { resource_id: args[1], resource_lock_id: args[2] });
+    return finishLock(response, (outcome) => unlockOutcomeLines(outcome, { queued: true }));
+  }
   if (!args[0]) die("Usage: botbuddy unlock <resource_name>");
-  return callTool("release_lock", { resource_name: args[0] });
+  return finishLock(await callTool("release_lock", { resource_name: args[0] }), (outcome) => unlockOutcomeLines(outcome));
 }
 
 function cmdTask(args) {

package/src/locks.mjs

@@ -152,3 +152,108 @@ export function buildAcquireResourcesPayload(args, options = {}) {
     ...(environment ? { environment } : {}),
   };
 }
+
+// BOT-2994: `bb lock`, `bb locks` and `bb unlock` exit by what the server did, not
+// by whether it answered. Before this every one of them exited 0, so a shell loop
+// that trusted the exit code drove another agent's Playwright lane (ENT-6416).
+// 0 = acquired (or released / withdrawn); 2 = queued behind a holder (you hold
+// nothing yet; wait for the grant or withdraw); 1 = refused or not understood.
+// Auth (3) and transport (5) exits from callTool pass through unchanged.
+export const LOCK_EXIT = Object.freeze({ ACQUIRED: 0, REFUSED: 1, QUEUED: 2 });
+
+function parseJson(text) {
+  try { return JSON.parse(text); } catch { return undefined; }
+}
+
+function toolText(response) {
+  const content = response?.result?.content;
+  if (!Array.isArray(content)) return null;
+  const text = content.map((part) => part?.text ?? "").join("\n");
+  return text || null;
+}
+
+/**
+ * Classify a lock tool response (acquire_lock, acquire_resources, release_lock,
+ * retire_queued_lock_attempt) as returned by callTool: the JSON-RPC body, or a
+ * numeric exit when callTool already classified an auth/transport failure.
+ * Fails closed: an error flag, `success: false`, or an unreadable result is
+ * never "acquired".
+ */
+export function classifyLockResponse(response) {
+  if (typeof response === "number") return { exit: response, results: [] };
+  const isError = response?.result?.isError === true;
+  const text = toolText(response);
+  if (text === null) return { exit: LOCK_EXIT.REFUSED, results: [] };
+  const parsed = parseJson(text);
+  let results;
+  if (parsed && Array.isArray(parsed.results)) {
+    results = parsed.results.map((r) => ({ ...r, success: r?.success === true }));
+  } else if (parsed && typeof parsed === "object" && "success" in parsed) {
+    results = [{ ...parsed, resource_name: parsed.resource_name ?? parsed.resource, success: parsed.success === true && !isError }];
+  } else {
+    // The human success string (acquire_lock / release_lock) or a plain error text.
+    results = [{ success: !isError, message: text }];
+  }
+  const failed = results.filter((r) => !r.success);
+  let exit = LOCK_EXIT.ACQUIRED;
+  if (failed.some((r) => r.queued !== true)) exit = LOCK_EXIT.REFUSED;
+  else if (failed.length) exit = LOCK_EXIT.QUEUED;
+  else if (isError || !results.length) exit = LOCK_EXIT.REFUSED;
+  return { exit, results };
+}
+
+function holderLabel(holder) {
+  if (!holder || typeof holder !== "object") return null;
+  const who = holder.agent ?? holder.agent_name ?? holder.name ?? null;
+  if (!who) return null;
+  const ticket = holder.ticket_id ? `, ${holder.ticket_id}` : "";
+  return `${who}${ticket}`;
+}
+
+// `bb wait 'lock:…,claim=true'` only addresses typed resources
+// (`<subtype>:<host>:<slot>`); an untyped name gets no wait line.
+function claimWaitFor(name) {
+  const parts = typeof name === "string" ? name.split(":") : [];
+  if (parts.length !== 3 || parts.some((p) => !p)) return null;
+  const [subtype, host, slot] = parts;
+  return `bb wait 'lock:subtype=${subtype},host=${host},slot=${slot},claim=true' --heartbeat`;
+}
+
+/** The stderr lines that tell the caller what it holds and what to do next. */
+export function lockOutcomeLines({ exit, results }) {
+  if (exit === LOCK_EXIT.ACQUIRED || exit > LOCK_EXIT.QUEUED) return [];
+  const lines = [`✗ Lock not acquired (exit ${exit}: ${exit === LOCK_EXIT.QUEUED ? "queued" : "refused"}). Do not use ${results.length > 1 ? "these resources" : "this resource"} until a lock command exits 0.`];
+  for (const r of results.filter((x) => !x.success)) {
+    const name = r.resource_name ?? r.resource ?? "resource";
+    const holder = holderLabel(r.holder);
+    if (r.queued === true) {
+      lines.push(`  ${name}: queued${holder ? ` behind ${holder}` : ""}${r.queue_depth != null ? ` (queue depth ${r.queue_depth})` : ""}.`);
+      const wait = claimWaitFor(name);
+      if (wait) lines.push(`    wait to be handed it:  ${wait}`);
+      if (r.resource_id && r.resource_lock_id) lines.push(`    or withdraw the request: bb unlock --queued ${r.resource_id} ${r.resource_lock_id}`);
+    } else {
+      lines.push(`  ${name}: refused${holder ? ` (held by ${holder})` : ""}${r.message ? ` — ${r.message}` : ""}`);
+    }
+  }
+  const held = results.filter((r) => r.success && r.resource_name);
+  if (held.length && results.length > 1) {
+    lines.push("  Acquired in this batch (release what you will not use):");
+    for (const r of held) lines.push(`    bb unlock ${r.resource_name}`);
+  }
+  return lines;
+}
+
+/** `bb unlock` refused: say how a queued caller withdraws instead. */
+export function unlockOutcomeLines({ exit, results }, { queued = false } = {}) {
+  if (exit === LOCK_EXIT.ACQUIRED || exit > LOCK_EXIT.QUEUED) return [];
+  // The first line is the server's reason; later lines are generic guidance.
+  const why = results.find((r) => r.message)?.message?.split("\n")[0];
+  if (queued) return [`✗ Queued request not withdrawn${why ? `: ${why}` : ""}.`];
+  return [
+    `✗ Lock not released${why ? `: ${why}` : ""}.`,
+    "  bb unlock <name> releases a lock you hold; it does not withdraw a queued request.",
+    "  To withdraw one, use the ids from the queued lock result: bb unlock --queued <resource_id> <resource_lock_id>",
+  ];
+}
+
+export const UNLOCK_QUEUED_USAGE = "Usage: botbuddy unlock --queued <resource_id> <resource_lock_id>";

package/src/pw/run.mjs

@@ -92,7 +92,7 @@ async function gate({ env, host, lane, deps }) {
     // callerIds/holder let staging-auth cleanup touch only what this caller installed.
     const callerIds = [...selfAgentIds];
     if (status.held && selfAgentIds.has(status.heldBy)) return { allowed: true, coordinator, canonicalHost, holderMatch: "self", holder: status.heldBy, callerIds };
-    if (status.held && status.ownerIsCaller === true) return { allowed: true, coordinator, canonicalHost, holderMatch: "owner", holder: status.heldBy ?? null, callerIds };
+    if (status.held && status.ownerIsCaller === true) return { allowed: true, coordinator, canonicalHost, holderMatch: "owner", holder: status.heldBy ?? null, holderName: status.heldByName ?? null, callerIds };
     // Distinguish an expired/free lane from one another operator holds so the
     // operator knows whether to re-acquire vs. wait for a handover (BOT-660). Name it
     // by the server's canonical host so a not-held message matches the dashboard even
@@ -296,6 +296,23 @@ async function runPwInner(argv, deps = {}) {
   // Report the host the lock service actually stored (alias-collapsed), so the
   // status view and lane telemetry match the server, not the local string (AC-4).
   const effHost = auth.canonicalHost ?? host;
+  // BOT-2994: a lane is driven only by the agent that holds it. The gate also
+  // passes a same-owner holder (BOT-1490 owner_is_caller), and every agent one
+  // person runs shares that owner, so an agent whose `bb lock` had only queued
+  // drove another agent's browser (ENT-6416, 2026-11-03). Resolve an owner-only
+  // match to the exact agent once (server whoami); only read-only `status` may
+  // proceed without it. `auth` keeps its own staging refusal receipt below.
+  let holderMatch = auth.holderMatch;
+  if (holderMatch === "owner" && auth.holder && authCtx.resolveCallerId) {
+    const me = await authCtx.resolveCallerId().catch(() => null);
+    if (me && me === auth.holder) { holderMatch = "self"; authCtx.callerIds = [...authCtx.callerIds, me]; }
+  }
+  if (holderMatch === "owner" && plan.mode !== "status" && plan.mode !== "auth") {
+    const lane = `playwright_lane:${effHost}:${plan.lane}`;
+    const who = `${auth.holder ?? "unknown"}${auth.holderName ? ` (${auth.holderName})` : ""}`;
+    stderr.write(`bb-pw: lane lock ${lane} is held by ${who}, another agent session of your owner, not this agent session. A lane is driven only by the agent that holds it. Claim a lane from this session with bb locks -m --lane <n> --ticket <ticket> and use it only after that exits 0, or wait to be handed this one: bb wait 'lock:subtype=playwright_lane,host=${effHost},slot=${plan.lane},claim=true' --heartbeat\n`);
+    return 3;
+  }
   // BOT-1318: resolve the lane's browser-acceptance tracker AFTER the gate (a
   // refused/unverified lane writes no lifecycle) and never for unlocked local mode.
   let tracker = null;
@@ -312,11 +329,6 @@ async function runPwInner(argv, deps = {}) {
   if (tracker && envResolution.error) { stderr.write(`${envResolution.error}\n`); return 2; }
   const environment = envResolution.environment ?? null;
   if (plan.mode === "auth") {
-    let holderMatch = auth.holderMatch;
-    if (holderMatch === "owner" && auth.holder && authCtx.resolveCallerId) {
-      const me = await authCtx.resolveCallerId().catch(() => null);
-      if (me && me === auth.holder) { holderMatch = "self"; authCtx.callerIds = [...authCtx.callerIds, me]; }
-    }
     if (holderMatch !== "self") return stagingAuth.refuse({ stdout, stderr }, "exact_lane_holder_required", 3, {}, authVars(plan, deps));
     if (tracker) {
       const browserSession = await tracker.status();