@botbuddy/cli 1.30.1 → 1.31.0

package/package.json

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

package/src/commands.mjs

@@ -323,8 +323,16 @@ function gitHint(cwd, args) {
   catch { return null; }
 }
 
-/** Best-effort display-only context. It is never an authorization input. */
-export function deriveCallerHint({ env = process.env, cwd = process.cwd() } = {}) {
+/**
+ * Best-effort display-only context. It is never an authorization input.
+ *
+ * `git` is injectable so a test can exercise the branch/remote parsing without
+ * depending on the ambient checkout: a detached-HEAD checkout (the npm publish
+ * lane checks out the promoted SHA, not a branch) has no branch name, which used
+ * to make the branch-recognition assertion fail only in CI (BOT-1649 publish run
+ * 35328434334). Production still defaults to the real git resolver.
+ */
+export function deriveCallerHint({ env = process.env, cwd = process.cwd(), git = gitHint } = {}) {
   let cachedAgentId = null;
   try {
     const path = join(cwd, ".botbuddy", "agent-state.json");
@@ -333,9 +341,9 @@ export function deriveCallerHint({ env = process.env, cwd = process.cwd() } = {}
       cachedAgentId = typeof parsed?.agent_id === "string" && parsed.agent_id ? parsed.agent_id : null;
     }
   } catch { /* a malformed cache is not a login failure */ }
-  const branch = gitHint(cwd, ["branch", "--show-current"]);
+  const branch = git(cwd, ["branch", "--show-current"]);
   const ticket = branch?.match(/(?:^|\/)((?:bot|ent)-\d+)(?:-|$)/i)?.[1]?.toUpperCase() ?? null;
-  const remote = gitHint(cwd, ["remote", "get-url", "origin"]);
+  const remote = git(cwd, ["remote", "get-url", "origin"]);
   const repo = remote?.match(/(?:github\.com[:/])([^/]+\/[^/.]+)(?:\.git)?$/i)?.[1] ?? null;
   const harness = env.BOTBUDDY_CALLER_HARNESS
     || (env.CLAUDE_CODE || env.CLAUDECODE ? "claude-code" : Object.keys(env).some((key) => key.startsWith("CODEX_")) ? "codex" : null);

package/src/wait-core.mjs

@@ -196,16 +196,26 @@ const VALIDATORS = {
   // BOT-1066 — ci: wake when a PR's CI reaches a terminal conclusion. Exactly one
   // selector: scope=latest (follows the PR's latest run — needs pr=), run_id=<id>
   // (pinned to one run), or sha=<sha> (pinned to a commit). repo= is always required.
-  // BOT-1507 — scope=next adds a fourth, LIVE-ONLY selector: it names no run, sha,
-  // or PR (they must all already exist at arm time) and wakes on the first terminal
-  // CI run for the repo delivered AFTER the wait was armed — the post-merge / cron
-  // train case. Optional branch=/workflow= filter that first run; both are valid
-  // ONLY with scope=next (a run_id/sha/latest wait already names its run).
+  // BOT-1507 — scope=next adds a fourth, LIVE-ONLY selector: it names no run or PR
+  // (they must already exist at arm time) and wakes on the first terminal CI run for
+  // the repo delivered AFTER the wait was armed — the post-merge / cron train case.
+  // Optional branch=/workflow= filter that first run; both are valid ONLY with
+  // scope=next (a run_id/sha/latest wait already names its run).
+  // BOT-1685 — scope=next also accepts an optional sha= FILTER (distinct from the
+  // level-triggered sha= selector): a wait armed BEFORE re-dispatching a run for a
+  // known commit then wakes on the NEXT terminal run for THAT commit, instead of
+  // replaying an earlier successful run for the same sha.
   ci(p) {
     const repo = p.repo != null ? String(p.repo).trim() : null;
     if (!repo || !repo.includes("/")) throw new Error("ci needs repo=<owner/repo>");
     const selectors = ["scope", "run_id", "sha"].filter((k) => p[k] !== undefined);
-    if (selectors.length !== 1) {
+    // BOT-1685: scope=next accepts sha= as a live FILTER (like branch=/workflow=),
+    // not as a second selector — a wait armed BEFORE re-dispatching a run for a
+    // known commit then wakes on the NEXT terminal run for that commit rather than
+    // replaying an earlier terminal run (which the level-triggered `sha=` selector
+    // does by design). Exclude that filter sha from the single-selector count.
+    const shaIsNextFilter = p.scope === "next" && p.sha !== undefined;
+    if ((shaIsNextFilter ? selectors.length - 1 : selectors.length) !== 1) {
       throw new Error("ci needs exactly one of scope=latest|next | run_id=<id> | sha=<sha>");
     }
     const hasFilter = p.branch !== undefined || p.workflow !== undefined;
@@ -229,7 +239,7 @@ const VALIDATORS = {
           if (v === "") throw new Error(`ci ${key}= must be non-empty`);
           return v;
         };
-        return { repo, scope: "next", branch: filter("branch"), workflow: filter("workflow"), pr: null };
+        return { repo, scope: "next", branch: filter("branch"), workflow: filter("workflow"), sha: filter("sha"), pr: null };
       }
       throw new Error("ci scope must be 'latest' or 'next' (or use run_id=/sha=)");
     }
@@ -804,6 +814,9 @@ function conditionMatchesSignal(condition, signal, waitSessionId) {
         // branch is exact, workflow is the GitHub display name (case/space-insensitive).
         const conclusion = signal.payload?.conclusion;
         if (typeof conclusion !== "string" || conclusion.trim() === "") return false;
+        // BOT-1685: an optional sha filter pins scope=next to a commit, so a
+        // re-dispatch wait wakes only on the terminal run for that commit.
+        if (params.sha != null && signal.payload?.head_sha !== params.sha) return false;
         if (params.branch != null && signal.payload?.head_branch !== params.branch) return false;
         if (params.workflow != null) {
           const wf = signal.payload?.workflow_name;

package/src/wait.mjs

@@ -106,15 +106,18 @@ CONDITIONS  (TYPE:key=val,key=val — repeat for several; --any wakes on the fir
                                       the others keep parking. Older servers broadcast without
                                       the ranking (first-come). Needs cli >= 1.20.0.
   ci:repo=<owner/repo>,{scope=latest,pr=<n> | run_id=<id> | sha=<sha>
-                        | scope=next[,branch=<name>][,workflow=<name>]}
+                        | scope=next[,sha=<sha>][,branch=<name>][,workflow=<name>]}
                                       a PR's CI reaching a terminal conclusion (owner-scoped);
                                       GitHub Actions or an external check_suite provider.
                                       A repo with no CI feed is rejected (no_signal_source).
                                       scope=next is LIVE-ONLY: it wakes on the first terminal
                                       run delivered AFTER arm (post-merge / cron / scheduled),
-                                      never replays a finished run, and needs no run_id/sha/pr.
-                                      Optional branch= (exact) / workflow= (GitHub workflow
-                                      DISPLAY name, case-insensitive) narrow that first run.
+                                      never replays a finished run, and needs no run_id/pr.
+                                      Optional sha= pins it to a commit (BOT-1685: arm before
+                                      re-dispatching a run for a known SHA so it wakes on the
+                                      NEW run, not an earlier terminal run for the same SHA);
+                                      branch= (exact) / workflow= (GitHub workflow DISPLAY
+                                      name, case-insensitive) narrow that first run too.
   staging-green:repo=<owner/repo>    verified automatic recovery of an enabled staging gate.
                                       Wakes only after a complete non-vacuous workflow success;
                                       manual resolutions, overrides, skipped, and neutral runs do not match.