@botbuddy/cli 1.25.0 → 1.27.0

package/src/commands.mjs

@@ -14,17 +14,20 @@ import { cmdTest } from "./test-lane.mjs";
 import { runWait } from "./wait.mjs";
 import { green, red, cyan, dim, bold, die } from "./utils.mjs";
 import { VERSION } from "./version.mjs";
-import { bootstrapProfile, ProfileBootstrapError, profileBootstrapRecovery, profileShellRefresh } from "./profile-bootstrap.mjs";
 import { setupMcpKey, revokeMcpKey, resolveMcpConfigKey, resolveEnvVarName, DEFAULT_MCP_ENV_VAR, McpKeyError, McpKeyStoreError } from "./mcp-key.mjs";
+import { readAgentBinding } from "./wait-profile.mjs";
 import { runPw } from "./pw/run.mjs";
 import { maybeWarnStale, cmdUpdate } from "./update-check.mjs";
+import { createTelemetryOutbox } from "./telemetry-outbox.mjs";
+import { attestTelemetryCredential, loadTelemetryIdentity, loadTelemetryLocation } from "./telemetry-config.mjs";
+import { deliverExecutionEvent } from "./telemetry-delivery.mjs";
 
 // BOT-1566 D2: the stale-CLI check runs for every command EXCEPT `wait` and any
 // invocation carrying `--json` — those are hot paths whose receipts (BOT-1229)
 // must not pay for a registry round-trip.
 export function shouldCheckForUpdates(argv) {
   const [command] = argv;
-  if (command === "wait") return false;
+  if (command === "wait" || command === "telemetry") return false;
   if (argv.includes("--json")) return false;
   return true;
 }
@@ -53,11 +56,10 @@ export async function run(argv, {
     case "stack": return cmdStack(args);
     case "docker": return cmdDocker(args);
     case "run": return cmdRun(args);
+    case "telemetry": return cmdTelemetry(args);
     case "test": return cmdTest(args);
     case "wait": return runWait(args);
     case "pw": return runPw(args);
-    case "profile": return cmdProfile(args);
-    case "carrier": return cmdCarrier(args);
     case "mcp": return cmdMcp(args);
     case "resources": return callTool("list_resources");
     case "agents": return callTool("list_agents");
@@ -82,6 +84,36 @@ export async function run(argv, {
   }
 }
 
+async function cmdTelemetry(args) {
+  const subcommand = args[0] ?? "help";
+  if (!new Set(["status", "replay", "doctor", "help", "--help"]).has(subcommand) || args.length > 1) {
+    die("Usage: botbuddy telemetry <status|replay|doctor>");
+  }
+  if (subcommand === "help" || subcommand === "--help") {
+    console.log("botbuddy telemetry status\nbotbuddy telemetry replay\nbotbuddy telemetry doctor");
+    return;
+  }
+  let location;
+  try { location = await loadTelemetryLocation(process.cwd()); }
+  catch (error) { console.error(`telemetry: ${error?.message ?? error}`); return 4; }
+  const outbox = await createTelemetryOutbox({ tenant: location.tenant, repository: location.repository, producerVersion: VERSION });
+  if (subcommand === "replay") {
+    let identity;
+    try {
+      identity = await loadTelemetryIdentity(process.cwd());
+      await attestTelemetryCredential(identity, outbox);
+    } catch (error) { console.error(`telemetry: ${error?.message ?? error}`); return 4; }
+    await outbox.importLegacyTestRunReceipts(".botbuddy/test-runs");
+    const receipt = await outbox.replay((event) => deliverExecutionEvent(event, { credential: identity.credential }));
+    console.log(JSON.stringify(receipt));
+    return receipt.remaining === 0 ? 0 : 5;
+  }
+  const status = await outbox.status();
+  console.log(JSON.stringify(status));
+  if (subcommand === "doctor") return status.queued_count === 0 && !status.last_error_class ? 0 : 5;
+  return 0;
+}
+
 function cmdHelp() {
   console.log(`${bold("bb")} ${dim(`v${VERSION}`)} — Swarm coordination CLI
 
@@ -102,8 +134,6 @@ ${bold("AUTH")}
                              Authenticate via OAuth (opens browser + localhost callback)
   logout                     Remove saved credentials
   status                     Show current auth status (local metadata + server check)
-  carrier setup <profile>    CI hosts only: store an unattended tenant-bound carrier key
-                             (interactive operators use ${cyan("login")} — it installs the client key)
 
 ${bold("MCP CONFIG KEY")}
   mcp setup [--env <NAME>] [--tenant <slug>] [--label <l>] [--expiry-days <n>]
@@ -111,6 +141,7 @@ ${bold("MCP CONFIG KEY")}
                              revocable; stored under ${dim("BOTBUDDY_MCP_KEY")})
   mcp revoke <agent_id>      Revoke only that MCP key (login + sessions unaffected)
   mcp status                 Which env var holds the MCP key (never prints it)
+  mcp env                    Print the shell loader for the MCP key ($BOTBUDDY_MCP_KEY)
 
 ${bold("TOOLS")}
   help --tools               List every BotBuddy tool
@@ -135,6 +166,10 @@ ${bold("DOCKER HYGIENE")}
 ${bold("DURABLE WORKLOADS")}
   run --session-id <id> --environment <env> -- <command>
                               Launch a receipt-bearing command under a detached owner
+  run --foreground --kind <kind> --environment <env> -- <command>
+                              Run locally with a durable lifecycle outbox
+  telemetry <status|replay|doctor>
+                              Inspect, replay, or gate durable lifecycle delivery
 
 ${bold("AGENT WAITS")}
   wait [--any] <condition>... [options]
@@ -301,8 +336,9 @@ ${bold("TOKEN SCOPE")}
   By default login installs this machine's ${bold("client key (bb_cli_)")}: a user
   token that is not bound to a tenant and reaches every tenant you belong to —
   each request pins one. ONE login serves ALL tenants; ${cyan("register_agent")} then
-  exchanges it for a per-session agent token. No per-tenant ${cyan("profile setup")} is
-  needed (that path is now CI-carrier only).
+  exchanges it for a per-session agent token. No per-tenant credential is needed
+  for normal use — mint a ${bold("bb_mcp_")} key per tenant (${cyan("botbuddy mcp setup")}) only
+  when a repo binds a distinct ${dim("mcp_env")}.
   ${cyan("--tenant <slug>")} instead mints a ${bold("tenant token")} sealed to that one
   tenant (the MCP-session model); use it only when you want that guarantee.
 
@@ -353,7 +389,8 @@ ${bold("NOTES")}
 
 ${bold("RECOVERY")}
   If ${cyan("botbuddy status")} shows no client key, run ${cyan("botbuddy login")}. For an
-  unattended CI host (no browser), use ${cyan("botbuddy carrier setup <profile>")}.`);
+  unattended CI host (no browser), mint a key on a machine with a browser
+  (${cyan("botbuddy mcp setup")}) and export it as ${cyan("$BOTBUDDY_MCP_KEY")} on the CI host.`);
 }
 
 async function cmdStart(args) {
@@ -556,143 +593,14 @@ async function cmdLogout() {
   console.log(`${green("✓")} Logged out. Credentials removed.`);
 }
 
-async function cmdAgentAuth(args) {
-  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
-    console.log(`Usage: botbuddy auth <login|status|logout> [--profile <name>] [--token <key>]
-
-  auth login    Store a tenant-bound agent credential in the OS keyring. On macOS,
-                it imports the existing launchd credential once when no --token or
-                profile-specific environment key is supplied.
-  auth status   Show whether the profile has a stored key (never prints it).
-  auth logout   Remove the profile's stored key.`);
-    return;
-  }
-  let options;
-  try {
-    options = parseAgentAuthArgs(args);
-  } catch (error) {
-    die(error.message);
-  }
-  const profile = options.profile || await findProfileName(process.cwd());
-  if (!profile || !getProfileDefinition(profile)) {
-    die("No supported BotBuddy agent profile found. Add .botbuddy-agent.json or pass --profile <name>.");
-  }
-  if (options.action === "login") {
-    const token = await resolveLoginToken({ profile, explicitToken: options.token });
-    const result = await loginAgentCredential({ profile, token });
-    console.log(`${green("✓")} Stored ${result.profile} (${result.tenant}) agent credential in the OS keyring.`);
-    return;
-  }
-  if (options.action === "status") {
-    const result = await getAgentAuthStatus({ profile });
-    console.log(result.authenticated
-      ? `${green("✓")} ${result.profile} (${result.tenant}) machine credential is stored in the OS keyring.`
-      : `${red("✗")} ${result.profile} (${result.tenant}) has no stored machine credential.`);
-    return;
-  }
-  const result = await logoutAgentCredential({ profile });
-  console.log(`${green("✓")} ${result.profile} (${result.tenant}) machine credential ${result.removed ? "removed" : "was not present"}.`);
-}
-
 function cmdHeartbeat(args) {
   return args[0] ? callTool("heartbeat", { current_task: args[0] }) : callTool("heartbeat");
 }
 
-// BOT-1574 AC6: the carrier bootstrap that `profile setup --unattended` and
-// `carrier setup` share. Never gated on a TTY — the caller decides whether the
-// interactive guard applies before reaching here.
-async function runCarrierSetup(profile, { log, setExitCode, bootstrap }) {
-  try {
-    const receipt = await bootstrap(profile, { call: callToolJson });
-    log(JSON.stringify(receipt));
-  } catch (error) {
-    const code = error instanceof ProfileBootstrapError ? error.code : "profile_agent_required";
-    log(JSON.stringify({
-      schema_version: 1,
-      outcome: "error",
-      error: code,
-      recovery: profileBootstrapRecovery(code, profile),
-    }));
-    setExitCode(3);
-  }
-}
-
-export async function cmdProfile(args, {
-  isTTY = Boolean(process.stdout.isTTY),
-  log = (line) => console.log(line),
-  setExitCode = (n) => { process.exitCode = n; },
-  bootstrap = bootstrapProfile,
-} = {}) {
-  if (args[0] === "--help" || args[0] === "-h") {
-    console.log(`Usage: botbuddy profile <setup|env> <botbuddy-dev|supplyguard-dev> [--unattended]
-
-  setup <profile>   Carrier-only (CI): mint/reconnect and store a tenant-bound
-                    carrier key. Retired for interactive use — run ${cyan("botbuddy login")}
-                    on a workstation. On a TTY this refuses unless --unattended.
-  env <profile>     Print shell exports that load the stored carrier key
-
-Interactive operators: ${cyan("botbuddy login")} installs the per-machine client key.
-CI hosts: ${cyan("botbuddy carrier setup <profile>")} (alias of setup --unattended).`);
-    return;
-  }
-  if (args[0] === "env" && args[1] && args.length === 2) {
-    try {
-      log(profileShellRefresh(args[1]));
-      return;
-    } catch {
-      die("Usage: botbuddy profile env <botbuddy-dev|supplyguard-dev>");
-    }
-  }
-  const unattended = args.includes("--unattended");
-  const positionals = args.filter((a) => !a.startsWith("-"));
-  if (positionals[0] !== "setup" || !positionals[1] || positionals.length > 2) {
-    die("Usage: botbuddy profile <setup|env> <botbuddy-dev|supplyguard-dev> [--unattended]");
-  }
-  const profile = positionals[1];
-  // BOT-1574 AC6: interactive setup is retired. A human on a TTY who did not ask
-  // for the unattended carrier path is redirected to `botbuddy login` (which
-  // installs the machine client key) instead of minting a per-tenant slot. A
-  // non-TTY caller (CI) or an explicit --unattended keeps the carrier path.
-  if (isTTY && !unattended) {
-    log(JSON.stringify({
-      schema_version: 1,
-      outcome: "error",
-      error: "interactive_use_retired",
-      recovery: `Interactive profile setup is retired. Run \`botbuddy login\` to install this machine's client key (bb_cli_) — it reaches every tenant you belong to, no per-tenant slot needed. For an unattended CI carrier, re-run with --unattended or use \`botbuddy carrier setup ${profile}\`.`,
-    }));
-    setExitCode(4);
-    return;
-  }
-  await runCarrierSetup(profile, { log, setExitCode, bootstrap });
-}
-
-// BOT-1574 AC6: `botbuddy carrier setup <profile>` — the explicit CI-carrier
-// alias of `profile setup --unattended`. Being the named carrier command, it is
-// never subject to the interactive-TTY guard.
-export async function cmdCarrier(args, {
-  log = (line) => console.log(line),
-  setExitCode = (n) => { process.exitCode = n; },
-  bootstrap = bootstrapProfile,
-} = {}) {
-  if (args[0] === "--help" || args[0] === "-h" || args.length === 0) {
-    console.log(`Usage: botbuddy carrier setup <botbuddy-dev|supplyguard-dev>
-
-  Mint/reconnect and store an unattended CI carrier key (alias of
-  ${cyan("botbuddy profile setup <profile> --unattended")}). Interactive operators use
-  ${cyan("botbuddy login")} instead.`);
-    return;
-  }
-  const positionals = args.filter((a) => !a.startsWith("-"));
-  if (positionals[0] !== "setup" || !positionals[1] || positionals.length > 2) {
-    die("Usage: botbuddy carrier setup <botbuddy-dev|supplyguard-dev>");
-  }
-  await runCarrierSetup(positionals[1], { log, setExitCode, bootstrap });
-}
-
 // ─── BOT-1607: `botbuddy mcp` — the tier-2 bb_mcp_ config key ────────────────
 
 function mcpHelp(log) {
-  log(`Usage: botbuddy mcp <setup|revoke|status> [options]
+  log(`Usage: botbuddy mcp <setup|revoke|status|env> [options]
 
   setup [--env <NAME>] [--tenant <slug>] [--label <label>] [--expiry-days <n>] [--force]
                     Mint a bb_mcp_ MCP config key (authenticated by your
@@ -711,6 +619,10 @@ function mcpHelp(log) {
                     Report which env var holds the MCP config key (never prints
                     the secret). ${dim("BOTBUDDY_BB_AGENT_KEY")} is honoured as a deprecated
                     alias for one release.
+  env [--env <NAME>]
+                    Print the shell loader that reads the key from the Keychain
+                    into ${dim("$BOTBUDDY_MCP_KEY")}: eval "$(botbuddy mcp env)" in a shell,
+                    or in the desktop LaunchAgent env-install recipe.
 
 Present the key from .mcp.json instead of reusing an agent session token — it is
 independently revocable, so a leaked config credential rotates without a re-login.`);
@@ -821,11 +733,34 @@ export async function cmdMcp(args, {
   revoke = revokeMcpKey,
   resolveConfigKey = resolveMcpConfigKey,
   env = process.env,
+  cwd = process.cwd(),
+  readBinding = readAgentBinding,
 } = {}) {
   if (args[0] === "--help" || args[0] === "-h") return mcpHelp(log);
   const sub = args.find((a) => !a.startsWith("-"));
   if (!sub) return mcpHelp(log);
 
+  // BOT-1608 Codex P2: `mcp status`/`mcp env` with no explicit --env must report
+  // and export the var the committed .botbuddy-agent.json actually binds (e.g.
+  // BOTBUDDY_MCP_KEY_SG), not the hard-coded default — otherwise the MCP client's
+  // configured slot is left unset and auth fails unless --env is redundantly
+  // passed. An explicit --env still wins; a malformed binding falls back to the
+  // default var (status/env are diagnostics, not the fail-closed wait path).
+  const resolveRequestedEnv = async (requested) => {
+    if (requested.explicit) return requested;
+    try {
+      const binding = await readBinding(cwd);
+      // A binding that names a NON-default var is an explicit selection of that
+      // var (declared in the file rather than on the flag) — so status inspects
+      // exactly it. A binding naming the default var stays non-explicit so the
+      // deprecated-alias fallback still applies.
+      if (binding?.mcpEnv && binding.mcpEnv !== DEFAULT_MCP_ENV_VAR) {
+        return { envVar: binding.mcpEnv, explicit: true };
+      }
+    } catch { /* malformed binding: keep the default var for diagnostics */ }
+    return requested;
+  };
+
   if (sub === "setup") {
     try {
       // Parse inside the try so a bad --env (missing value / reserved name) becomes
@@ -890,7 +825,7 @@ export async function cmdMcp(args, {
   if (sub === "status") {
     let requested;
     try {
-      requested = parseMcpStatusEnv(args);
+      requested = await resolveRequestedEnv(parseMcpStatusEnv(args));
     } catch (error) {
       const code = error instanceof McpKeyError ? error.code : "invalid_env_var";
       log(JSON.stringify({ schema_version: 1, outcome: "error", error: code, recovery: mcpRecovery(code) }));
@@ -913,6 +848,25 @@ export async function cmdMcp(args, {
     return;
   }
 
+  if (sub === "env") {
+    // BOT-1608 (AC4): the "export the key" job folded out of the retired
+    // `profile env`. Prints the shell loader that reads the MCP key from the
+    // Keychain into $envVar so `eval "$(botbuddy mcp env)"` (and the desktop
+    // LaunchAgent recipe) load the credential the MCP client / bb-wait consume.
+    let requested;
+    try {
+      requested = await resolveRequestedEnv(parseMcpStatusEnv(args));
+    } catch (error) {
+      const code = error instanceof McpKeyError ? error.code : "invalid_env_var";
+      log(JSON.stringify({ schema_version: 1, outcome: "error", error: code, recovery: mcpRecovery(code) }));
+      setExitCode(3);
+      return;
+    }
+    const envVar = requested.envVar;
+    log(`export ${envVar}="$(security find-generic-password -w -a "$USER" -s ${envVar})"`);
+    return;
+  }
+
   die(`Unknown mcp subcommand: ${sub}. Run ${cyan("botbuddy mcp --help")}.`);
 }
 

package/src/config.mjs

@@ -65,7 +65,7 @@ export async function loadConfig({ platform = process.platform, warn = (m) => co
       warn(
         migrated
           ? "✓ Migrated the owner token from ~/.botbuddy/config.json into the macOS Keychain."
-          : "⚠ Removed a legacy plaintext credential from ~/.botbuddy/config.json. Run `botbuddy login` (and `botbuddy profile setup <profile>` for agents) to re-establish credentials in the Keychain.",
+          : "⚠ Removed a legacy plaintext credential from ~/.botbuddy/config.json. Run `botbuddy login` (and `botbuddy mcp setup` for agents) to re-establish credentials in the Keychain.",
       );
     }
   }

package/src/mcp-key.mjs

@@ -1,8 +1,8 @@
 // BOT-1607 — `botbuddy mcp`: mint / revoke the tier-2 `bb_mcp_` MCP config key.
 //
 // A `.mcp.json` should present its OWN independently-revocable key, not the
-// reused `bb_agent_` session token `profile setup` planted in
-// BOTBUDDY_BB_AGENT_KEY. `botbuddy mcp setup` mints a `bb_mcp_` key —
+// reused `bb_agent_` session token the retired `profile setup` planted in
+// BOTBUDDY_BB_AGENT_KEY (BOT-1608). `botbuddy mcp setup` mints a `bb_mcp_` key —
 // authenticated by the tier-1 owner/client credential (resolveCallAuth: the
 // owner OAuth/client key from `botbuddy login`) — stores it in the Keychain
 // under a default-or-`--env` service, and prints the `.mcp.json` /
@@ -11,24 +11,25 @@
 // re-login or agent disruption.
 //
 // The mint/revoke calls are the server tools mint_mcp_key / revoke_mcp_key
-// (owner/client-gated). This module mirrors profile-bootstrap.mjs's dependency
-// injection so the whole flow is unit-testable with an injected call / auth /
-// keychain.
+// (owner/client-gated). This module uses dependency injection throughout so the
+// whole flow is unit-testable with an injected call / auth / keychain.
 
-import { keychainAvailable, readKeychainSecret, writeKeychainSecret } from "./agent-credential-store.mjs";
+import {
+  keychainAvailable,
+  readKeychainSecret,
+  writeKeychainSecret,
+  DEFAULT_MCP_ENV_VAR,
+  LEGACY_MCP_ENV_VAR,
+} from "./agent-credential-store.mjs";
 import { callToolJson, resolveCallAuth } from "./api.mjs";
 import { SERVER_URL } from "./config.mjs";
 
-// The default env/Keychain var a `.mcp.json` references (BOT-1108 canonical set,
-// aligned with src/components/credentials/SetupSnippet.tsx). `--env <NAME>`
-// overrides it.
-export const DEFAULT_MCP_ENV_VAR = "BOTBUDDY_MCP_KEY";
-
-// BOT-1607 AC5: the pre-1607 var `profile setup` wrote the reused bb_agent_ session token into.
-// A `.mcp.json` still referencing it keeps authenticating for one release (the
-// server authenticates by hash regardless of which env var carried the key); the
-// CLI recognises it as a DEPRECATED alias and tells the operator to migrate.
-export const LEGACY_MCP_ENV_VAR = "BOTBUDDY_BB_AGENT_KEY";
+// The canonical MCP env/Keychain var names live in agent-credential-store.mjs
+// (the one module wait-profile.mjs and this file both import — no cycle). Re-export
+// them so existing importers (commands.mjs) keep resolving them from here.
+//   DEFAULT_MCP_ENV_VAR  — what `.mcp.json` references (BOT-1108 canonical set).
+//   LEGACY_MCP_ENV_VAR   — the pre-1607/1608 var; a DEPRECATED read alias one release.
+export { DEFAULT_MCP_ENV_VAR, LEGACY_MCP_ENV_VAR };
 
 // A valid shell env-var / Keychain service name.
 const ENV_VAR_RE = /^[A-Z][A-Z0-9_]*$/;
@@ -45,14 +46,14 @@ const RESERVED_ENV_VARS = new Set([
   "BOTBUDDY_CI_KEY",         // bb_ci_ — CI key
   "BOTBUDDY_TOKEN",          // PAT / OAuth owner token
   "BOTBUDDY_TEST_RUN_TOKEN", // publishable test-run token
-  "BOTBUDDY_SG_AGENT_KEY",   // Supply Guard profile Keychain slot (profileCredentialEnvironment) — never an MCP var
+  "BOTBUDDY_SG_AGENT_KEY",   // retired Supply Guard profile slot — never an MCP var
 ]);
 
-// BOTBUDDY_BB_AGENT_KEY is dual-purpose: the deprecated MCP READ alias AND the
-// botbuddy profile Keychain slot (agent-credential-store profileCredentialEnvironment).
-// A `mcp status` (read-only) may name it, but `mcp setup`/`revoke` must NOT write
-// or delete it — that would clobber/destroy the profile client credential (Codex P2).
-// It is not in RESERVED_ENV_VARS so status can still resolve the legacy alias.
+// BOTBUDDY_BB_AGENT_KEY is the deprecated MCP READ alias (LEGACY_MCP_ENV_VAR). It
+// was also the retired botbuddy profile Keychain slot, so `mcp status`/`env`
+// (read-only) may still name it, but `mcp setup`/`revoke` must NOT write or delete
+// it — an operator mid-migration may still have a live value there (Codex P2). It
+// is not in RESERVED_ENV_VARS so status/env can still resolve the legacy alias.
 
 export class McpKeyError extends Error {
   constructor(code, { detail = null } = {}) {

package/src/pw/coordinator.mjs

@@ -23,8 +23,3 @@ export function createSessionTokenCoordinator({ token, fetchImpl = fetch } = {})
   if (!token) return { kind: "unverified" };
   return laneCoordinator("session_token", mcpCaller({ "x-agent-api-key": token }, fetchImpl), null);
 }
-
-export function createProfileCoordinator({ profile, identity, fetchImpl = fetch } = {}) {
-  if (!profile?.token || !identity?.agentId || identity.tenant !== profile.tenant) return { kind: "unverified" };
-  return laneCoordinator("profile", mcpCaller({ "x-agent-api-key": profile.token }, fetchImpl), identity.agentId);
-}

package/src/pw/run.mjs

@@ -2,18 +2,17 @@ import os from "node:os";
 import { planInvocation } from "./args.mjs";
 import { actionTypeFromMethod, NAV } from "./readiness.mjs";
 import { isStaleRefError, staleRefRemediation } from "./targets.mjs";
-import { createProfileCoordinator, createSessionTokenCoordinator } from "./coordinator.mjs";
+import { createSessionTokenCoordinator } from "./coordinator.mjs";
 import { canonicalizeHostString } from "./host.mjs";
-import { resolveAgentProfile } from "../wait-profile.mjs";
-import { readProfileIdentity } from "../agent-credential-store.mjs";
+import { resolveAgentBinding } from "../wait-profile.mjs";
 import { loadConfig, getConfig } from "../config.mjs";
 import { VERSION } from "../version.mjs";
-import { readAgentKeyEnv } from "../agent-key.mjs";
+import { readAgentKeyEnv, AGENT_KEY_RE } from "../agent-key.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: pw [--profile <name>] [--session-id <id>] <lane> <verb> [args…]\n\nAliases: bb-pw <lane> <verb> [args…]   ·   botbuddy pw <lane> <verb> [args…]\n         (all three drive the same lock-gated Playwright lane)\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 help(out) { out.write("Usage: pw [--tenant <slug>] [--session-id <id>] <lane> <verb> [args…]\n\nAliases: bb-pw <lane> <verb> [args…]   ·   botbuddy pw <lane> <verb> [args…]\n         (all three drive the same lock-gated Playwright lane)\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--tenant <slug>    override the worktree .botbuddy-agent.json tenant when falling\n                   back to the .mcp.json ($BOTBUDDY_MCP_KEY) credential.\n"); }
 function redact(value, secretValues = []) { return secretValues.reduce((text, secret) => secret ? text.split(secret).join("[redacted]") : text, String(value ?? "")); }
 // BOT-1488: the register_agent identity for this machine, persisted by
 // `botbuddy register` into ~/.botbuddy/config.json. This is the SESSION agent
@@ -25,37 +24,38 @@ async function readRegisteredAgentId() { try { await loadConfig(); const id = ge
 async function gate({ env, host, lane, deps }) {
   if (env.BB_PW_NO_LOCK === "1") return { allowed: true };
   // BOT-1572/1582: a per-session `bb_agent_` token authenticates lock verification
-  // AS the session agent — no machine profile needed. It takes precedence over the
-  // profile path; holder matching then rides on the server's owner_is_caller
-  // (plus any local session/registered agent id). The profile path stays intact
-  // for a session that has not adopted the token. $BOTBUDDY_AGENT_KEY is the norm
-  // ($BOTBUDDY_SESSION_TOKEN still accepted for one release).
+  // AS the session agent — the server resolves it, holder matching rides on
+  // owner_is_caller (plus any local session/registered agent id). $BOTBUDDY_AGENT_KEY
+  // is the norm ($BOTBUDDY_SESSION_TOKEN still accepted for one release).
+  //
+  // BOT-1608: the retired profile-identity path is gone (its `agent-profiles.json`
+  // store no longer exists). When no session token is exported, fall back to the
+  // worktree binding's mcp_env credential (the `bb_mcp_` key from `.mcp.json`) —
+  // it authenticates the status call the same way and matching still rides on the
+  // server's owner_is_caller.
   const sessionToken = deps.sessionToken ?? readAgentKeyEnv(env);
+  if (sessionToken && !AGENT_KEY_RE.test(sessionToken)) {
+    return { allowed: false, message: "bb-pw: $BOTBUDDY_AGENT_KEY is malformed (expected bb_agent_<64 hex>). Re-register the agent, or set BB_PW_NO_LOCK=1 for local-only work." };
+  }
   const sessionAgentId = deps.sessionId ?? env.BOTBUDDY_SESSION_ID ?? null;
   const registeredAgentId = await (deps.readSessionAgentId ?? readRegisteredAgentId)();
-  let coordinator, selfAgentIds, callerId;
-  if (sessionToken) {
-    coordinator = deps.coordinator ?? createSessionTokenCoordinator({ token: sessionToken, fetchImpl: deps.fetch });
-    if (coordinator.kind === "unverified") return { allowed: false, message: "bb-pw: $BOTBUDDY_AGENT_KEY is malformed. Re-register the agent, or set BB_PW_NO_LOCK=1 for local-only work." };
-    selfAgentIds = new Set([sessionAgentId, registeredAgentId, coordinator.agentId].filter(Boolean));
-    callerId = coordinator.agentId ?? sessionAgentId ?? "session-token";
-  } else {
-    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.` };
+  let coordinator = deps.coordinator ?? null;
+  if (!coordinator) {
+    let token = sessionToken;
+    if (!token) {
+      try {
+        const binding = await (deps.resolveBinding ?? resolveAgentBinding)({ cwd: deps.cwd ?? process.cwd(), env, explicitTenant: deps.tenant ?? null });
+        token = binding.token ?? null;
+      } catch { token = null; }
+    }
+    if (!token) {
+      return { allowed: false, message: "bb-pw: no BotBuddy credential — export $BOTBUDDY_AGENT_KEY (from register_agent) or your .mcp.json key ($BOTBUDDY_MCP_KEY), or set BB_PW_NO_LOCK=1 for local-only work." };
     }
-    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." };
-    // The operator's own holder identities: the tenant-bound profile agent OR the
-    // arming session agent (--session-id / $BOTBUDDY_SESSION_ID / local register_agent
-    // id). A foreign operator's agent is in none of these, so the gate stays a real
-    // refusal (AC-3).
-    selfAgentIds = new Set([identity.agentId, sessionAgentId, registeredAgentId].filter(Boolean));
-    callerId = identity.agentId;
+    coordinator = createSessionTokenCoordinator({ token, fetchImpl: deps.fetch });
   }
+  if (coordinator.kind === "unverified") return { allowed: false, message: "bb-pw: BotBuddy credential is unusable. Re-register the agent, or set BB_PW_NO_LOCK=1 for local-only work." };
+  const selfAgentIds = new Set([sessionAgentId, registeredAgentId, coordinator.agentId].filter(Boolean));
+  const callerId = coordinator.agentId ?? sessionAgentId ?? registeredAgentId ?? "botbuddy";
   const laneName = `playwright_lane:${host}:${lane}`;
   try {
     const status = await coordinator.status({ host, slot: lane });
@@ -105,7 +105,7 @@ async function runPwInner(argv, deps = {}) {
   // session identity alongside --session-id, so a token-armed session need not
   // pass an id. Holder matching still rides on the server's owner_is_caller and
   // the resolved agent ids (gate()).
-  while (args[0] === "--profile" || args[0] === "--session-id" || args[0] === "--session-token") { 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] } : flag === "--session-token" ? { ...deps, sessionToken: args[1] } : { ...deps, sessionId: args[1] }; args = args.slice(2); }
+  while (args[0] === "--tenant" || args[0] === "--session-id" || args[0] === "--session-token") { const flag = args[0]; if (!args[1]) { stderr.write(`bb-pw: ${flag} needs a value\n`); return 2; } deps = flag === "--tenant" ? { ...deps, tenant: args[1] } : flag === "--session-token" ? { ...deps, sessionToken: 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); }