@botbuddy/cli 1.44.0 → 1.44.1

package/package.json

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

package/src/wait-core.mjs

@@ -1276,6 +1276,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 +1666,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 +1703,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 +1823,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" });