@botbuddy/cli 1.44.0 → 1.45.0

package/package.json

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

package/src/wait-core.mjs

@@ -190,7 +190,8 @@ const VALIDATORS = {
     const id = hex ? `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}` : raw;
     return { id };
   },
-  // BOT-1064 — linear: wake on a logical state change of a named BOT-* issue.
+  // BOT-1064 / BOT-2112 — linear: wake on a logical state change of a named
+  // issue in any Linear team bound to the authenticated tenant.
   // The spine subject_key is the issue identifier as stored on the tickets
   // projection (upper-cased at write), so normalize to upper-case here too.
   linear(p) {
@@ -1276,6 +1277,10 @@ export async function runWaitLoop({
   // This prevents a terminal receipt from either skipping lower replay matches or
   // replaying its own match on a chained wait.
   const pendingReplayMatches = [];
+  // Capacity frames also carry state: a lower-sequence fresh beacon can clear a
+  // later stale confirmation. Defer their state transitions until replay_complete
+  // so they are folded in spine sequence order, just like terminal matches.
+  const pendingReplayBeaconFrames = [];
   let pendingReplaySupersession = null;
   const degraded = [];
   let reconnects = 0;
@@ -1662,6 +1667,7 @@ export async function runWaitLoop({
           // marker. Restart legacy semantics from the last confirmed cursor: do
           // not retain buffered/seen rows that would discard the replayed match.
           pendingReplayMatches.length = 0;
+          pendingReplayBeaconFrames.length = 0;
           pendingReplaySupersession = null;
           seen.clear();
           cursor = replayFrontier;
@@ -1698,18 +1704,60 @@ export async function runWaitLoop({
       if (frame.event === "replay_complete") {
         replayPending = false;
         replayFrontier = cursor;
+        let pendingBeaconExit = null;
+        // A replay terminal is a point-in-time receipt. Beacon state after an
+        // earlier match/supersession cannot affect that receipt.
+        let terminalSeq = [
+          ...pendingReplayMatches.map(({ seqKey }) => seqKey),
+          pendingReplaySupersession?.seqKey,
+        ].filter(Boolean).sort((a, b) => BigInt(a) < BigInt(b) ? -1 : BigInt(a) > BigInt(b) ? 1 : 0)[0] ?? null;
+        for (const pendingBeaconFrame of pendingReplayBeaconFrames
+          .sort((a, b) => BigInt(a.seqKey) < BigInt(b.seqKey) ? -1 : BigInt(a.seqKey) > BigInt(b.seqKey) ? 1 : 0)) {
+          if (terminalSeq != null && BigInt(pendingBeaconFrame.seqKey) >= BigInt(terminalSeq)) break;
+          // Recovery replays may contain rows created after the original deadline.
+          // They are only transport catch-up, never evidence for the terminal
+          // receipt, so they must not alter stale confirmation state either.
+          if (!pendingBeaconFrame.beforeReplayDeadline) continue;
+          const disposition = applyBeaconStale(pendingBeaconFrame.signal);
+          if (disposition === "exit") {
+            pendingBeaconExit = pendingBeaconFrame;
+            terminalSeq = pendingBeaconFrame.seqKey;
+            break;
+          }
+          if (disposition !== "fallthrough" || !pendingBeaconFrame.beforeReplayDeadline) continue;
+          if (signalTenantBlocked(pendingBeaconFrame.signal, sessionTenant)) continue;
+          const matched = matchFrame(pendingBeaconFrame.frame, conditions, waitSessionId, sessionTenant);
+          if (!matched) continue;
+          const entry = {
+            condition_id: matched.id,
+            signal_type: pendingBeaconFrame.signal.signal_type,
+            seq: pendingBeaconFrame.signal.seq,
+            subject_key: pendingBeaconFrame.signal.subject_key,
+            payload: pendingBeaconFrame.signal.payload ?? null,
+            provenance: "spine",
+          };
+          const grant = capacityGrantForReceipt(pendingBeaconFrame.signal, waitSessionId);
+          if (grant) entry.grant = grant;
+          pendingReplayMatches.push({ ...pendingBeaconFrame, entry });
+          terminalSeq = pendingBeaconFrame.seqKey;
+        }
+        pendingReplayBeaconFrames.length = 0;
         const pendingMatch = pendingReplayMatches
           .sort((a, b) => BigInt(a.seqKey) < BigInt(b.seqKey) ? -1 : BigInt(a.seqKey) > BigInt(b.seqKey) ? 1 : 0)[0];
-        const replayCandidate = pendingMatch &&
-          (!pendingReplaySupersession || BigInt(pendingMatch.seqKey) < BigInt(pendingReplaySupersession.seqKey))
-          ? { kind: "match", ...pendingMatch }
-          : pendingReplaySupersession ? { kind: "superseded", ...pendingReplaySupersession } : null;
+        const replayCandidate = [
+          pendingMatch && { kind: "match", ...pendingMatch },
+          pendingReplaySupersession && { kind: "superseded", ...pendingReplaySupersession },
+          pendingBeaconExit && { kind: "beacon_stale", ...pendingBeaconExit },
+        ].filter(Boolean).sort((a, b) => BigInt(a.seqKey) < BigInt(b.seqKey) ? -1 : BigInt(a.seqKey) > BigInt(b.seqKey) ? 1 : 0)[0] ?? null;
         if (replayCandidate) {
           const candidateAtMs = Date.parse(replayCandidate.signal.created_at);
           if (restoredAlarm != null && Number.isFinite(candidateAtMs) && restoredAlarm.atMs < candidateAtMs) {
             return fireAlarm(restoredAlarm);
           }
           if (replayCandidate.kind === "superseded") return finalizeSuperseded(replayCandidate.signal);
+          if (replayCandidate.kind === "beacon_stale") {
+            return finalize("error", { exitCode: EXIT.BACKEND, error: "capacity_source_stale" });
+          }
           const terminal = await finalizeMatch(replayCandidate.entry, replayCandidate.signal);
           if (onFrame) {
             await onFrame(replayCandidate.signal, {
@@ -1776,10 +1824,17 @@ export async function runWaitLoop({
         return finalizeSuperseded(signal);
       }
 
-      // BOT-1148: a beacon-driven capacity staleness transition is handled before the
-      // normal match — a stale signal is never itself a grant, and a fast exit / marker
-      // fold happens here (host-pinned) rather than through matchFrame.
-      if (signal.signal_type === "container_capacity" && signal.payload && "source_stale" in signal.payload) {
+      // BOT-1148/BOT-2100: every capacity frame for a pinned host participates in
+      // beacon-staleness handling. `source_stale:true` arms the fast-fail, while a
+      // later normal capacity frame proves the host is fresh again even when the
+      // server omits the redundant `source_stale:false` field. Without that latter
+      // path, an old stale transition could win its confirm timer despite fresh
+      // beacons continuing to publish capacity frames.
+      if (signal.signal_type === "container_capacity" && signal.payload) {
+        if (replayPending) {
+          pendingReplayBeaconFrames.push({ frame, signal, seqKey, beforeReplayDeadline });
+          continue;
+        }
         const disposition = applyBeaconStale(signal);
         if (disposition === "exit") {
           return finalize("error", { exitCode: EXIT.BACKEND, error: "capacity_source_stale" });

package/src/wait.mjs

@@ -108,8 +108,9 @@ CONDITIONS  (TYPE:key=val,key=val — repeat for several; --any wakes on the fir
   guidance:request=<post_id>          a command-post guidance request being answered
                                       (scoped to the asking agent; fetch the body with
                                       get_guidance_response)
-  linear:issue=<KEY>                  a BOT-* issue changing state, a new comment, or an
-                                      assignee change (e.g. issue=BOT-123; tenant-scoped).
+  linear:issue=<KEY>                  an issue in any Linear team bound to your tenant;
+                                      wakes on a state change, new comment, or assignee change (e.g.
+                                      issue=BOT-123; tenant-scoped).
                                       Flags linear_feed_lagging if the ingest feed has stalled.
   unblocked:<KEY>                     a ticket's LAST open blocker clearing (open-blocker
                                       count >0 → 0): a blocker moving to Done/Canceled/Duplicate
@@ -378,6 +379,10 @@ async function registerWait(opts, conditions, deadlineIso) {
       // wake-capable run for. The wait could only ever expire, and no amount of
       // waiting repairs a typo — a hard stop, with the server's candidates.
       "unknown_workflow",
+      // BOT-2112: these are arm-time authorization/target errors. Retrying as
+      // an untracked live-only wait would silently park on a signal it cannot
+      // receive, so preserve the relay's typed error and exit 4.
+      "linear_team_not_bound",
       // BOT-1612: a `chat:channel=<id>` wait whose bound agent is not one of the
       // channel's participants could only ever park to timeout (the emitter never
       // scopes a message to a non-participant). The relay refuses it at arm time;
@@ -395,6 +400,29 @@ async function registerWait(opts, conditions, deadlineIso) {
       throw err;
     }
   }
+  if (res.status === 404) {
+    const body = await res.json().catch(() => ({}));
+    if (body.error === "linear_issue_not_found") {
+      const err = new Error(body.detail || body.error);
+      err.invalidCondition = true;
+      err.errorCode = body.error;
+      if (Array.isArray(body.candidates)) err.candidates = body.candidates;
+      throw err;
+    }
+    // BOT-1523 retains its existing not-found contract. Keep every 404's body
+    // handling in one branch: parsing it above and falling through would consume
+    // the body before this typed unblocked refusal could see it.
+    if (body.error === "unblocked_ticket_not_found") {
+      const err = new Error(body.detail || body.error);
+      err.hydrationRegister = true;
+      err.errorCode = body.error;
+      err.ticket = body.ticket ?? null;
+      err.retryable = body.retryable ?? null;
+      err.hydration = body.hydration ?? null;
+      err.notFound = true;
+      throw err;
+    }
+  }
   if (res.status === 403) {
     const body = await res.json().catch(() => ({}));
     if (new Set(["wait_tenant_unresolved", "wait_cross_tenant", "wait_tenant_mismatch", "wait_resume_identity_mismatch"]).has(body.error)) {
@@ -427,7 +455,7 @@ async function registerWait(opts, conditions, deadlineIso) {
     err.minimumProtocol = body.minimum_wait_protocol ?? null;
     throw err;
   }
-  if (res.status === 409 || res.status === 404) {
+  if (res.status === 409) {
     // BOT-1523: `unblocked:<KEY>` hydration at registration could not arm the wait
     // truthfully. These are NOT the untracked-live-only fallback: arming a live-only
     // unblocked wait would skip the server's initial evaluation and could resume a