@botbuddy/cli 1.6.4 → 1.8.0

package/package.json

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

package/src/pw/coordinator.mjs

@@ -8,5 +8,5 @@ export function createProfileCoordinator({ profile, identity, fetchImpl = fetch
     const json = await response.json(); if (json.error) throw new Error(json.error.message || "BotBuddy lock verification failed");
     const text = json.result?.content?.find((item) => item.type === "text")?.text; try { return text ? JSON.parse(text) : {}; } catch { throw new Error("BotBuddy lock verification returned invalid JSON"); }
   }
-  return { kind: "profile", async status({ host, slot }) { const result = await call("list_resources", { host, subtype: "playwright_lane" }); const list = Array.isArray(result) ? result : result.resources ?? []; const resource = list.find((item) => item.name === `playwright_lane:${host}:${slot}` || String(item.slot) === String(slot)); return resource ? { held: resource.status !== "free", heldBy: resource.owner_agent_id ?? null } : { held: false, heldBy: null }; }, async emit(event) { await call("record_lane_event", event); }, agentId: identity.agentId };
+  return { kind: "profile", async status({ host, slot }) { const result = await call("list_resources", { host, subtype: "playwright_lane" }); const list = Array.isArray(result) ? result : result.resources ?? []; const resource = list.find((item) => item.name === `playwright_lane:${host}:${slot}` || String(item.slot) === String(slot)); return resource ? { held: resource.status !== "free", heldBy: resource.owner_agent_id ?? null, heldByName: resource.agents?.name ?? null } : { held: false, heldBy: null, heldByName: null }; }, async emit(event) { await call("record_lane_event", event); }, agentId: identity.agentId };
 }

package/src/pw/host.mjs

@@ -0,0 +1,17 @@
+// BOT-1488: name the Playwright lane the SAME way the lock kernel stores it.
+// `acquire_resources` canonicalizes the host server-side (normalize_host_string /
+// canonical_host in supabase/functions/_shared/state.ts), so a raw
+// `os.hostname()` like "Jonos-MBP.localdomain" never string-matches the stored
+// "jonos-mbp:<slot>" lane — the gate then refuses a lane the operator holds and
+// prints a lane name that does not exist server-side.
+//
+// This mirrors the PURE string half of the server's normalizeHostString:
+// lowercase + trim + strip a trailing `.local`/`.localdomain`. The server's
+// alias map (canonical_host) is the authority for cross-alias merges; replicating
+// that map here is out of scope for BOT-1488 (and would need invalidation to stay
+// correct), so we fold exactly the case/suffix drift that bites local runs and
+// otherwise defer to the canonical `host` field the server returns.
+export function canonicalizeHostString(host) {
+  if (host === null || host === undefined) return host ?? null;
+  return String(host).trim().toLowerCase().replace(/\.(local|localdomain)$/, "");
+}

package/src/pw/run.mjs

@@ -3,14 +3,59 @@ import { planInvocation } from "./args.mjs";
 import { actionTypeFromMethod, NAV } from "./readiness.mjs";
 import { isStaleRefError, staleRefRemediation } from "./targets.mjs";
 import { createProfileCoordinator } from "./coordinator.mjs";
+import { canonicalizeHostString } from "./host.mjs";
 import { resolveAgentProfile } from "../wait-profile.mjs";
 import { readProfileIdentity } from "../agent-credential-store.mjs";
-const hostFor = (env) => env.PLAYWRIGHT_MCP_HOST || env.HOSTNAME || os.hostname();
-function help(out) { out.write("Usage: botbuddy pw [--profile <name>] <lane> <verb> [args…]\n\nAlias: bb-pw <lane> <verb> [args…]\n"); }
+import { loadConfig, getConfig } from "../config.mjs";
+// BOT-1488: canonicalize the raw hostname the SAME way acquire_resources does
+// server-side, so the lane name bb-pw builds/matches/prints is the one the lock
+// kernel actually stored ("jonos-mbp:8", not "Jonos-MBP.localdomain:8").
+const hostFor = (env) => canonicalizeHostString(env.PLAYWRIGHT_MCP_HOST || env.HOSTNAME || os.hostname());
+function help(out) { out.write("Usage: botbuddy pw [--profile <name>] [--session-id <id>] <lane> <verb> [args…]\n\nAlias: bb-pw <lane> <verb> [args…]\n\n--session-id <id>  accept a lane held by this arming-session agent id (from\n                   register_agent); defaults to $BOTBUDDY_SESSION_ID, then the\n                   id saved by `botbuddy register`.\n"); }
 function redact(value, secretValues = []) { return secretValues.reduce((text, secret) => secret ? text.split(secret).join("[redacted]") : text, String(value ?? "")); }
-async function gate({ env, host, lane, deps }) { if (env.BB_PW_NO_LOCK === "1") return { allowed: true }; let profile, identity; try { profile = await (deps.resolveProfile ?? resolveAgentProfile)({ cwd: deps.cwd ?? process.cwd(), env, explicitProfile: deps.profile ?? null }); identity = await (deps.readIdentity ?? readProfileIdentity)(profile.name); } catch (error) { return { allowed: false, message: `bb-pw: profile verification failed (${error.message}). Run botbuddy profile setup or set BB_PW_NO_LOCK=1 for local-only work.` }; } const coordinator = deps.coordinator ?? createProfileCoordinator({ profile, identity, fetchImpl: deps.fetch }); if (!profile.token || !identity || identity.tenant !== profile.tenant || coordinator.kind !== "profile") return { allowed: false, message: "bb-pw: profile identity is missing or tenant-mismatched. Run botbuddy profile setup or set BB_PW_NO_LOCK=1 for local-only work." }; try { const status = await coordinator.status({ host, slot: lane }); return status.held && status.heldBy === identity.agentId ? { allowed: true, coordinator } : { allowed: false, message: `bb-pw: lane lock playwright_lane:${host}:${lane} must be held by this profile. Acquire it first or set BB_PW_NO_LOCK=1 for local-only work.` }; } catch (error) { return { allowed: false, message: `bb-pw: could not verify lane lock (${error.message}). Set BB_PW_NO_LOCK=1 for local-only work.` }; } }
+// BOT-1488: the register_agent identity for this machine, persisted by
+// `botbuddy register` into ~/.botbuddy/config.json. This is the SESSION agent
+// that acquire_resources binds a lane to — distinct from the tenant-bound
+// profile agent the gate historically demanded. bb-pw is not always launched
+// through the `botbuddy` entrypoint (bb-pw.mjs imports runPw directly), so load
+// the config here rather than assuming it is already in memory.
+function readRegisteredAgentId() { try { loadConfig(); const id = getConfig()?.agent_id; return typeof id === "string" && id ? id : null; } catch { return null; } }
+async function gate({ env, host, lane, deps }) {
+  if (env.BB_PW_NO_LOCK === "1") return { allowed: true };
+  let profile, identity;
+  try {
+    profile = await (deps.resolveProfile ?? resolveAgentProfile)({ cwd: deps.cwd ?? process.cwd(), env, explicitProfile: deps.profile ?? null });
+    identity = await (deps.readIdentity ?? readProfileIdentity)(profile.name);
+  } catch (error) {
+    return { allowed: false, message: `bb-pw: profile verification failed (${error.message}). Run botbuddy profile setup or set BB_PW_NO_LOCK=1 for local-only work.` };
+  }
+  const coordinator = deps.coordinator ?? createProfileCoordinator({ profile, identity, fetchImpl: deps.fetch });
+  if (!profile.token || !identity || identity.tenant !== profile.tenant || coordinator.kind !== "profile") return { allowed: false, message: "bb-pw: profile identity is missing or tenant-mismatched. Run botbuddy profile setup or set BB_PW_NO_LOCK=1 for local-only work." };
+  const laneName = `playwright_lane:${host}:${lane}`;
+  // The operator's own holder identities: the tenant-bound profile agent (today's
+  // happy path) OR the arming session agent — named explicitly with --session-id /
+  // $BOTBUDDY_SESSION_ID (BOT-1467 precedent) or read from the local register_agent
+  // identity. A foreign operator's agent is in none of these, so the gate stays a
+  // real refusal (AC-3).
+  const sessionAgentId = deps.sessionId ?? env.BOTBUDDY_SESSION_ID ?? null;
+  const registeredAgentId = (deps.readSessionAgentId ?? readRegisteredAgentId)();
+  const selfAgentIds = new Set([identity.agentId, sessionAgentId, registeredAgentId].filter(Boolean));
+  try {
+    const status = await coordinator.status({ host, slot: lane });
+    if (status.held && selfAgentIds.has(status.heldBy)) return { allowed: true, coordinator };
+    // 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).
+    if (!status.held) return { allowed: false, message: `bb-pw: lane lock ${laneName} is not held (caller ${identity.agentId}). Acquire it via BotBuddy first, or set BB_PW_NO_LOCK=1 for local-only work.` };
+    const holder = status.heldBy ?? "unknown";
+    const holderName = status.heldByName ? ` (${status.heldByName})` : "";
+    return { allowed: false, message: `bb-pw: lane lock ${laneName} is held by ${holder}${holderName}, not you (caller ${identity.agentId}). Acquire it first or set BB_PW_NO_LOCK=1 for local-only work.` };
+  } catch (error) {
+    return { allowed: false, message: `bb-pw: could not verify lane lock ${laneName} (${error.message}). Set BB_PW_NO_LOCK=1 for local-only work.` };
+  }
+}
 export async function runPw(argv, deps = {}) {
-  const env = deps.env ?? process.env, stdout = deps.stdout ?? process.stdout, stderr = deps.stderr ?? process.stderr; let args = [...argv]; if (["--help", "-h"].includes(args[0])) { help(stdout); return 0; } if (args[0] === "--profile") { if (!args[1]) { stderr.write("bb-pw: --profile needs a name\n"); return 2; } deps = { ...deps, profile: args[1] }; args = args.slice(2); }
+  const env = deps.env ?? process.env, stdout = deps.stdout ?? process.stdout, stderr = deps.stderr ?? process.stderr; let args = [...argv]; if (["--help", "-h"].includes(args[0])) { help(stdout); return 0; }
+  while (args[0] === "--profile" || args[0] === "--session-id") { const flag = args[0]; if (!args[1]) { stderr.write(`bb-pw: ${flag} needs a value\n`); return 2; } deps = flag === "--profile" ? { ...deps, profile: args[1] } : { ...deps, sessionId: args[1] }; args = args.slice(2); }
   let plan; try { plan = planInvocation(args, env); } catch (error) { stderr.write(`${error.message}\n`); return 2; }
   const { spawnExec, socketRun } = deps.daemon ?? await import("./daemon.mjs");
   if (plan.scope === "global") { if (plan.mode === "reap") { await (deps.reap ?? (await import("./reap.mjs")).reap)({ env, stdout }); return 0; } if (env.BB_PW_NO_LOCK !== "1") { stderr.write("bb-pw: close-all and kill-all require BB_PW_NO_LOCK=1 because they can affect lanes you do not own.\n"); return 3; } return spawnExec(plan, env); }

package/src/wait-profile.mjs

@@ -79,6 +79,10 @@ export function withPrincipalReceipt(receipt, profile, registration = {}) {
       profile: profile.name,
       tenant_id: registration.sessionTenant ?? profile.tenant,
       agent_id: registration.agentId ?? null,
+      // BOT-1467: the arming session's agent, when the relay attributed the wait
+      // to it instead of the profile agent (null for an ordinary profile wait).
+      session_id: registration.sessionId ?? null,
+      session_agent_id: registration.sessionAgentId ?? null,
     },
   };
 }

package/src/wait.mjs

@@ -93,6 +93,7 @@ OPTIONS
   --heartbeat           keep this agent session alive while waiting (so it is not reaped)
   --url <base>          relay base URL (default $BOTBUDDY_RELAY_URL or https://api.bot-buddy.ai/functions/v1)
   --profile <name>      tenant-bound machine profile (normally read from .botbuddy-agent.json)
+  --session-id <uuid>   attribute this wait to the arming session (the work-graph session id from register_agent); default $BOTBUDDY_SESSION_ID
   --token <key>         explicit agent key override; otherwise the profile-specific env is used
   --help                show this help
 
@@ -133,6 +134,9 @@ function parseArgv(argv) {
     url: process.env.BOTBUDDY_RELAY_URL || "https://api.bot-buddy.ai/functions/v1",
     token: null,
     profile: null,
+    // BOT-1467: attribute this wait to the arming session's agent (the id from
+    // register_agent) instead of the tenant-bound profile agent. Env fallback.
+    sessionId: process.env.BOTBUDDY_SESSION_ID || null,
     help: false,
   };
   for (let i = 0; i < argv.length; i++) {
@@ -155,6 +159,7 @@ function parseArgv(argv) {
     else if (a === "--url") opts.url = optionValue();
     else if (a === "--token") opts.token = optionValue();
     else if (a === "--profile") opts.profile = optionValue();
+    else if (a === "--session-id") opts.sessionId = optionValue();
     else if (a.startsWith("--")) opts.unknown = a;
     else opts.conditions.push(a);
   }
@@ -176,6 +181,9 @@ async function registerWait(opts, conditions, deadlineIso) {
       action: "register",
       profile: opts.agentProfile.name,
       expected_tenant: opts.agentProfile.tenant,
+      // BOT-1467: name the arming work-graph session so the relay resolves and attributes
+      // the wait to its agent (validated same-owner) instead of the profile agent.
+      ...(opts.sessionId ? { session_id: opts.sessionId } : {}),
       client_version: VERSION,
       wait_protocol_version: WAIT_PROTOCOL_VERSION,
       conditions,
@@ -224,6 +232,11 @@ async function registerWait(opts, conditions, deadlineIso) {
       // can't bind to one workspace (ci / pr-review / bare tenant-primary event). A hard
       // stop — arming it untracked would only ever park to timeout.
       "tenant_ambiguous",
+      // BOT-1467: a caller-actionable session-attribution rejection — a malformed
+      // --session-id, or one passed without a profile. Arming it untracked would
+      // only ever park to timeout, so it's a hard stop, not the live-only fallback.
+      "invalid_session_agent",
+      "session_agent_requires_profile",
     ]);
     if (INVALID_CONDITION_CODES.has(body.error)) {
       const err = new Error(body.detail || body.error);
@@ -293,6 +306,10 @@ async function registerWait(opts, conditions, deadlineIso) {
     // new relay (the deploy-skew case, acceptable because waits are short-lived).
     sessionTenant: body.session_tenant ?? null,
     agentId: body.agent_id ?? null,
+    // BOT-1467: the session agent the relay attributed the wait to, if any (it
+    // echoes session_agent_id only when it overrode the profile agent).
+    sessionId: body.session_id ?? null,
+    sessionAgentId: body.session_agent_id ?? null,
   };
 }
 
@@ -565,6 +582,9 @@ export async function runWait(argv) {
   // pre-BOT-1259 behaviour for a wait the server never scoped.
   let sessionTenant;
   let registeredAgentId = null;
+  // BOT-1467: the session agent the relay attributed the wait to (when overridden).
+  let registeredSessionAgentId = null;
+  let registeredSessionId = null;
   if (needsRelay) {
     try {
       const reg = await registerWait(opts, conditions, new Date(deadlineMs).toISOString());
@@ -572,6 +592,8 @@ export async function runWait(argv) {
       opts.waitSessionId = waitSessionId;
       sessionTenant = reg.sessionTenant;
       registeredAgentId = reg.agentId;
+      registeredSessionAgentId = reg.sessionAgentId;
+      registeredSessionId = reg.sessionId;
       // BOT-1184: adopt the server's canonical host for each lock condition so the
       // local matcher builds the same subject_key the availability/claim-grant
       // signals carry (armed under an alias like 'jono-mac', the signal uses the
@@ -709,6 +731,8 @@ export async function runWait(argv) {
       withClientIdentity(withPrincipalReceipt(receipt, opts.agentProfile, {
         sessionTenant,
         agentId: registeredAgentId,
+        sessionAgentId: registeredSessionAgentId,
+        sessionId: registeredSessionId,
       })),
       opts.receiptMaxBytes,
     );

package/src/botbuddy-release-repair.json

@@ -1 +0,0 @@
-{"schema_version":1,"source_version":"1.6.3","source_identity":"2deb439f7afdbb1918d76fe15665ed6ca14c30bcfd5d65524083695cc939814c"}