@botbuddy/cli 1.59.6 → 1.59.8

package/src/usage/codex.mjs

@@ -62,20 +62,57 @@ function deltaUsage(total, previous) {
 
 // Only derived values are kept in ctx (it is persisted in the cursor file):
 // the cwd's HMAC and the ticket key its last segment names — never the path.
-function setCwd(ctx, cwd, hmac, tenantFor, repoFor = () => null) {
+//
+// BOT-1988: the branch is the checkout's, read at SYNC time by `branchFor(cwd)`
+// (the rollout records git metadata only in session_meta, and 84 of 217 local
+// rollouts had none). It is an estimate — the checkout may have switched branch
+// since the turn ran — so a row carrying a derived or carried branch is stamped
+// attribution_confidence 'inferred'. A cwd change never nulls a known branch
+// unless the new cwd names a DIFFERENT ticket (another worktree): the resolver
+// returns null for a removed checkout, and a subdirectory of the same checkout
+// keeps its branch.
+const usableBranch = (value) => {
+  const label = safeLabel(value);
+  return label && label !== "HEAD" ? label : null;
+};
+
+function setCwd(ctx, cwd, hmac, tenantFor, repoFor = () => null, branchFor = () => null) {
   const value = str(cwd);
   if (!value) return;
   const cwdHmac = hmac(value);
-  // A later turn in ANOTHER checkout: the session_meta git metadata described
-  // the old one. Drop it (the ticket then falls back to the new cwd) and
-  // re-derive the repo from the new checkout.
-  if (ctx.cwd_hmac && ctx.cwd_hmac !== cwdHmac) {
-    ctx.git_branch = null;
+  const changed = Boolean(ctx.cwd_hmac && ctx.cwd_hmac !== cwdHmac);
+  const cwdTicket = inferTicketKey(null, value);
+  if (changed) {
+    // A later turn in ANOTHER directory: the session_meta git metadata described
+    // the old one. Re-derive the repo; the commit is unknown.
     ctx.commit_sha = null;
     ctx.repo = repoFor(value) ?? null;
+    const derived = usableBranch(branchFor(value));
+    if (derived) {
+      ctx.git_branch = derived;
+      ctx.branch_estimated = true;
+    } else if (ctx.git_branch) {
+      const carriedTicket = inferTicketKey(ctx.git_branch, null);
+      if (cwdTicket && carriedTicket && cwdTicket !== carriedTicket) {
+        ctx.git_branch = null;
+        ctx.branch_estimated = false;
+      } else {
+        ctx.branch_estimated = true;
+      }
+    }
+  } else if (!ctx.git_branch || ctx.branch_estimated) {
+    // First cwd of the thread, a cursor context an older CLI persisted with no
+    // branch, or an estimate from an earlier sync (the checkout may have switched
+    // branch since): resolve it with THIS sync's resolver, which caches per cwd.
+    // The rollout's own git branch (branch_estimated false) is never replaced.
+    const derived = usableBranch(branchFor(value));
+    if (derived) {
+      ctx.git_branch = derived;
+      ctx.branch_estimated = true;
+    }
   }
   ctx.cwd_hmac = cwdHmac;
-  ctx.cwd_ticket = inferTicketKey(null, value);
+  ctx.cwd_ticket = cwdTicket;
   ctx.cwd_tenant = tenantFor(value); // a tenant slug (or null), never the path
 }
 
@@ -86,7 +123,7 @@ const NONE = Object.freeze({ envelopes: [], refused: 0 });
  * @param {(value: string) => string} opts.hmac
  * @param {string} opts.environment
  */
-export function createCodexAdapter({ hmac, environment, tenantFor = () => null, repoFor = () => null }) {
+export function createCodexAdapter({ hmac, environment, tenantFor = () => null, repoFor = () => null, branchFor = () => null }) {
   function parseCodexRecord(record, { offset, sourceHmac, ctx }) {
     if (!record || typeof record !== "object") return NONE;
     const payload = record.payload && typeof record.payload === "object" ? record.payload : null;
@@ -101,16 +138,22 @@ export function createCodexAdapter({ hmac, environment, tenantFor = () => null,
       ctx.subagent_thread = thread && root && thread !== root ? thread
         : payload.thread_source === "subagent" && thread ? thread : null;
       if (safeLabel(payload.cli_version)) ctx.cli_version = safeLabel(payload.cli_version);
-      setCwd(ctx, payload.cwd, hmac, tenantFor, repoFor);
       const git = payload.git && typeof payload.git === "object" ? payload.git : {};
-      ctx.git_branch = safeLabel(git.branch) ?? ctx.git_branch ?? null;
+      const metaBranch = safeLabel(git.branch);
+      setCwd(ctx, payload.cwd, hmac, tenantFor, repoFor, branchFor);
+      // The rollout's own git block wins over the sync-time resolver.
+      if (metaBranch) {
+        ctx.git_branch = metaBranch;
+        ctx.branch_estimated = false;
+      }
+      ctx.git_branch = ctx.git_branch ?? null;
       ctx.commit_sha = commitSha(git.commit_hash) ?? ctx.commit_sha ?? null;
       ctx.repo = normalizeRepo(git.repository_url) ?? ctx.repo ?? null;
       return NONE;
     }
     if (record.type === "turn_context") {
       if (modelLabel(payload.model)) ctx.model = modelLabel(payload.model);
-      setCwd(ctx, payload.cwd, hmac, tenantFor, repoFor);
+      setCwd(ctx, payload.cwd, hmac, tenantFor, repoFor, branchFor);
       return NONE;
     }
     if (record.type === "response_item") {
@@ -206,7 +249,7 @@ export function createCodexAdapter({ hmac, environment, tenantFor = () => null,
       repo: ctx.repo ?? null,
       commit_sha: ctx.commit_sha ?? null,
       ticket_key_inferred: ticket,
-      attribution_confidence: ticket ? "inferred" : null,
+      attribution_confidence: ticket || (ctx.git_branch && ctx.branch_estimated) ? "inferred" : null,
       environment,
       cwd_hmac: ctx.cwd_hmac ?? null,
       source_hmac: sourceHmac,

package/src/usage/sync.mjs

@@ -164,6 +164,30 @@ export function createRepoResolver({ exec = execFileSync, env = process.env } =
   };
 }
 
+/**
+ * BOT-1988: cwd → the branch its checkout has checked out NOW (sync time), or
+ * null for a detached HEAD, a removed checkout or a non-repo directory. Codex
+ * rollouts record git metadata only in session_meta, so this is the Codex
+ * adapter's estimate for every other turn. Cached per cwd; repository-location
+ * variables stripped (a lefthook pre-push run exports the pushing repo's).
+ */
+export function createBranchResolver({ exec = execFileSync, env = process.env } = {}) {
+  const gitEnv = { ...env };
+  for (const name of GIT_REPOSITORY_ENV) delete gitEnv[name];
+  const cache = new Map();
+  return (cwd) => {
+    if (cache.has(cwd)) return cache.get(cwd);
+    let branch = null;
+    try {
+      branch = String(exec("git", ["-c", "core.fsmonitor=false", "-C", cwd, "symbolic-ref", "--quiet", "--short", "HEAD"], {
+        encoding: "utf8", timeout: 1000, stdio: ["ignore", "pipe", "ignore"], env: gitEnv,
+      })).trim() || null;
+    } catch { branch = null; }
+    cache.set(cwd, branch);
+    return branch;
+  };
+}
+
 /**
  * cwd → the tenant bound to its checkout (BOT-1902 tenant routing), or null
  * when unbound. The binding is the checkout's committed `.botbuddy-agent.json`:
@@ -346,7 +370,7 @@ export async function syncUsage(opts, deps = {}) {
   const {
     env = process.env, home = homedir(), cwd = process.cwd(), now = () => Date.now(),
     fetchImpl = fetch, resolveAuth = defaultResolveAuth, hostname = systemHostname,
-    roots = transcriptRoots(env, home), repoFor = createRepoResolver(), cliVersion = "0.0.0",
+    roots = transcriptRoots(env, home), repoFor = createRepoResolver(), branchFor = createBranchResolver({ env }), cliVersion = "0.0.0",
     tenantFor = createTenantResolver({ env }), resolveTarget = defaultResolveTarget, readLines = readCompleteLines,
     serverUrl = env.BOTBUDDY_SERVER_URL || DEFAULT_SERVER_URL, statePath = cursorPath(home),
   } = deps;
@@ -438,7 +462,7 @@ export async function syncUsage(opts, deps = {}) {
     receipt.providers.push(provider);
     receipt.files_scanned += files.length;
     const adapter = provider === "codex"
-      ? createCodexAdapter({ hmac, environment, tenantFor, repoFor })
+      ? createCodexAdapter({ hmac, environment, tenantFor, repoFor, branchFor })
       : createClaudeAdapter({ hmac, environment, repoFor, tenantFor });
     const run = {
       host: hostname(), trigger: opts.trigger, provider, cli_version: cliVersion,

package/src/wait-core.mjs

@@ -80,6 +80,7 @@ function managedAllocationFailureDetail(signal, condition) {
 // own-session terminal branch because its wait_session_id differs) would otherwise match
 // that raw event condition and exit an unrelated wait as an ordinary match (Codex P2).
 export const WAIT_SUPERSEDED_SIGNAL_TYPE = "wait_superseded";
+const HOST_APPROVAL_HOST_KEY_RE = /^bbh-[0-9a-f]{24}$/;
 
 // The USER-ARMABLE spine signal_type allowlist, for the `event:` escape hatch. The full
 // public.agent_signal_type enum is these PLUS the control types above
@@ -99,6 +100,11 @@ export const SIGNAL_TYPES = Object.freeze([
   "snapshot",
   "ticket_unblocked",
   "stack_lease",
+  // BOT-2324: emitted only once the exact public host approval predicate is
+  // true (owner-bound active settings + policy + live tenant subscription).
+  // It is intentionally consumed through the existing raw `event:` escape
+  // hatch rather than adding another parallel wait grammar.
+  "host_approval",
 ]);
 
 const LOCK_SUBTYPES = Object.freeze(["playwright_lane", "vite_port", "backend_port", "supabase_local"]);
@@ -406,7 +412,15 @@ const VALIDATORS = {
     if (!SIGNAL_TYPES.includes(p.type)) {
       throw new Error(`event type must be a known signal_type (${SIGNAL_TYPES.join(", ")})`);
     }
-    return { type: p.type, subject: p.subject !== undefined ? String(p.subject) : null };
+    const subject = p.subject !== undefined ? String(p.subject).trim() : null;
+    // BOT-2324: unlike the generic raw escape hatch, this approval condition
+    // has one narrow public identity grammar. The service independently checks
+    // it for direct JSON callers; keeping the CLI equally strict prevents an
+    // impossible-to-match wait from being armed locally.
+    if (p.type === "host_approval" && (!subject || !HOST_APPROVAL_HOST_KEY_RE.test(subject))) {
+      throw new Error("event:type=host_approval needs subject=<canonical bbh- host key>");
+    }
+    return { type: p.type, subject };
   },
 };
 
@@ -1237,10 +1251,13 @@ function conditionMatchesSignal(condition, signal, waitSessionId) {
 // wake the wrong workspace. This centralizes what BOT-1247's `unblocked` matcher did
 // per-type (that per-type check stays as belt-and-braces). Tenantless signals
 // (host-shared lock_availability/container_capacity, owner/recipient-scoped
-// chat/pr_state/test_run/guidance) are NEVER blocked — they keep today's semantics
-// for any session (AC-5). `sessionTenant === undefined` opts a caller out of the
-// central guard: a pure unit test asserting a per-type matcher in isolation. The CLI
-// always threads the server-resolved tenant, so the guard is live for every real wait.
+  // chat/pr_state/test_run/guidance) are NEVER blocked — they keep today's semantics
+  // for any session (AC-5). `host_approval` is the deliberate exception: it is
+  // owner-visible AND tenant-bound, so the relay stamps scope=owner_tenant and we
+  // retain this tenant fence after its owner gate. `sessionTenant === undefined`
+  // opts a caller out of the central guard: a pure unit test asserting a per-type
+  // matcher in isolation. The CLI always threads the server-resolved tenant, so
+  // the guard is live for every real wait.
 export function signalTenantBlocked(signal, sessionTenant) {
   if (sessionTenant === undefined) return false;
   if (signal.tenant_id == null) return false;

package/src/wait.mjs

@@ -153,7 +153,10 @@ CONDITIONS  (TYPE:key=val,key=val — repeat for several; --any wakes on the fir
                                       Wakes only after a complete non-vacuous workflow success;
                                       manual resolutions, overrides, skipped, and neutral runs do not match.
   event:type=<signal_type>[,subject=<key>]
-                                      raw signal-spine match (escape hatch)
+                                      raw signal-spine match (escape hatch). Host setup uses
+                                      event:type=host_approval,subject=bbh-<24 lowercase hex>;
+                                      it wakes only for the authenticated owner's one bound
+                                      tenant after current server-side approval revalidation.
 
 OPTIONS
   --any                 wake on the first matching condition (default; only mode in v1)