@botbuddy/cli 1.69.6 → 1.69.8

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 1.69.8
+
+- The bb-status band's context row is simpler: just `Context 45%`, right-aligned, without the token counts. It turns amber above 30% context use and red above 50%, on every surface, so a session running low on context stands out. The colour is judged on the rounded percent the row shows. The band's plugin version moves to 1.1.1, so `bb update` re-installs it.
+
 ## 1.69.6
 
 - A new Claude Code session in a reused worktree binds its bb-status band even when the worktree's BotBuddy session was started by an earlier Claude session that has since gone. Before, the band said "BB identity belongs to another session" for as long as that BB session stayed live, and other sessions' `bb` commands in the worktree kept renewing it. The band now judges the holder by its Claude session: when the holder's transcript has been silent for 30 minutes, the band moves its cache aside to `.botbuddy/agent-state.superseded-<id>.json` and binds this session. The old BB session is not closed, so waits still running on it carry on, and it expires on its own. A holder whose Claude session is active is never replaced.

package/claude-plugin/.claude-plugin/marketplace.json

@@ -11,7 +11,7 @@
       "name": "bb-status",
       "source": "./bb-status",
       "description": "BB session status above the prompt: tickets, PRs with review counts, epic and staging, for BotBuddy and Supply Guard sessions",
-      "version": "1.1.0"
+      "version": "1.1.1"
     }
   ]
 }

package/claude-plugin/bb-status/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "bb-status",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "BB session status above the prompt: tickets, PRs with review counts, epic, staging and context use, live only while the session is on screen.",
   "author": {
     "name": "BotBuddy"

package/claude-plugin/bb-status/README.md

@@ -32,12 +32,15 @@ session. Once a surface draws the session again, the 5 s display tick does one
 read and re-arms the relay.
 
 **BOT-3211 context row.** The last row shows the session's context use as
-Claude Code's status line has it, for example `Context 62% · 124k of 200k`. The
+Claude Code's status line has it, right-aligned, for example `Context 62%`
+(BOT-3217 dropped the token counts). The
 mod reads it once with the free `$.session.usage()` (no `breakdown`) at
 session start and resume, then only from the `session.measure` event the
 engine pushes after each main-thread turn: no timer reads it. The row is hidden
 while the runtime has no fill figure (a fresh or just-compacted session before
-its next response), never shown as 0%.
+its next response), never shown as 0%. It is dim up to 30%, amber (`warning`)
+above 30% and red (`error`) above 50% (BOT-3217), judged on the rounded percent
+it shows.
 
 ## Install
 

package/claude-plugin/bb-status/hooks/register.js

@@ -696,33 +696,31 @@ function bandLine(el, spec, widths, right) {
   // Top-aligned: with a wrapped title, the id and status sit on its first line.
   return el.Box({ key: spec.key, flexDirection: "row", alignItems: "flex-start", columnGap: 1, children });
 }
-// BOT-3211: 124000 → "124k", 1000000 → "1M".
-function tokens(n) {
-  if (n >= 999500) return String(Math.round(n / 100000) / 10).replace(/\.0$/, "") + "M";
-  if (n >= 1000) return Math.round(n / 1000) + "k";
-  return String(n);
-}
-// The row's text, or null when the runtime has no fill figure (a fresh or
-// just-compacted session): hidden, never "0%".
+// BOT-3211/BOT-3217: "Context 62%", or null when the runtime has no fill
+// figure (a fresh or just-compacted session): hidden, never "0%".
 function contextText(c) {
-  if (
-    !c ||
-    !Number.isFinite(c.percent) ||
-    c.percent < 0 ||
-    c.percent > 100 ||
-    !Number.isSafeInteger(c.window) ||
-    c.window <= 0
-  )
-    return null;
-  const pct = "Context " + Math.round(c.percent) + "%";
-  return Number.isSafeInteger(c.tokens) && c.tokens >= 0
-    ? pct + " · " + tokens(c.tokens) + " of " + tokens(c.window)
-    : pct + " of " + tokens(c.window);
+  if (!c || !Number.isFinite(c.percent) || c.percent < 0 || c.percent > 100) return null;
+  return "Context " + Math.round(c.percent) + "%";
+}
+// BOT-3217: amber above 30%, red above 50%, judged on the rounded percent the
+// row shows, so the colour always matches the number.
+function contextColor(c) {
+  const pct = Math.round(c.percent);
+  if (pct > 50) return "error";
+  if (pct > 30) return "warning";
+  return null;
 }
 function contextLine(el, key) {
   const text = contextText(context);
   if (!text) return null;
-  return el.Box({ key, flexDirection: "row", children: [dim(el, text)] });
+  const color = contextColor(context);
+  // Right-aligned on its own row (Jono, BOT-3217).
+  return el.Box({
+    key,
+    flexDirection: "row",
+    justifyContent: "flex-end",
+    children: [color ? el.Text({ color, children: [text] }) : dim(el, text)],
+  });
 }
 async function readContext($) {
   try {

package/daemon-release/darwin-arm64.json

@@ -1,7 +1,7 @@
 {
-  "release_version": "1.69.6",
-  "source_commit": "e5336acb5374af61493aefb780b8b0a7b1406061",
-  "source_sha256": "ea92e88589a6d17292724108fbd7b67e532c3b0792eac919a21156884dd094dd",
+  "release_version": "1.69.8",
+  "source_commit": "704da4fe10bcbc13f1ca3abc6b0d47d2260e2c62",
+  "source_sha256": "2465657c2fe4fa188d73f3b7efda0f608144afcfd8d7eba465ece55ccb1204f3",
   "target": "darwin-arm64",
-  "sha256": "169410c528299ec39f546c7690b9496830ceab6eab4a8e4c5f86105b4da69cd2"
+  "sha256": "865f29aebd07e09de6c5b77fd5297db5a568c30843c4395e8ae4e927b0d4e7ad"
 }

package/daemon-release/linux-x64.json

@@ -1,7 +1,7 @@
 {
-  "release_version": "1.69.6",
-  "source_commit": "e5336acb5374af61493aefb780b8b0a7b1406061",
-  "source_sha256": "ea92e88589a6d17292724108fbd7b67e532c3b0792eac919a21156884dd094dd",
+  "release_version": "1.69.8",
+  "source_commit": "704da4fe10bcbc13f1ca3abc6b0d47d2260e2c62",
+  "source_sha256": "2465657c2fe4fa188d73f3b7efda0f608144afcfd8d7eba465ece55ccb1204f3",
   "target": "linux-x64",
-  "sha256": "51f601dcf602265d404836a0989faef813fbd310386cf0be0c31f3821e8e6f53"
+  "sha256": "6ad28e621587a5a697621c54c5a9b09f90c79b0687a4ae1f25f380ef02843d4b"
 }

package/daemon-release/manifest.json

@@ -1,21 +1,21 @@
 {
   "schema_version": 1,
-  "release_version": "1.69.6",
-  "source_commit": "e5336acb5374af61493aefb780b8b0a7b1406061",
-  "source_sha256": "ea92e88589a6d17292724108fbd7b67e532c3b0792eac919a21156884dd094dd",
+  "release_version": "1.69.8",
+  "source_commit": "704da4fe10bcbc13f1ca3abc6b0d47d2260e2c62",
+  "source_sha256": "2465657c2fe4fa188d73f3b7efda0f608144afcfd8d7eba465ece55ccb1204f3",
   "targets": {
     "darwin-arm64": {
       "goos": "darwin",
       "goarch": "arm64",
       "binary": "daemon/bin/darwin-arm64/botbuddy-daemon",
-      "sha256": "169410c528299ec39f546c7690b9496830ceab6eab4a8e4c5f86105b4da69cd2",
+      "sha256": "865f29aebd07e09de6c5b77fd5297db5a568c30843c4395e8ae4e927b0d4e7ad",
       "mode": "0755"
     },
     "linux-x64": {
       "goos": "linux",
       "goarch": "amd64",
       "binary": "daemon/bin/linux-x64/botbuddy-daemon",
-      "sha256": "51f601dcf602265d404836a0989faef813fbd310386cf0be0c31f3821e8e6f53",
+      "sha256": "6ad28e621587a5a697621c54c5a9b09f90c79b0687a4ae1f25f380ef02843d4b",
       "mode": "0755"
     }
   }

package/package.json

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

package/src/wait-core.mjs

@@ -39,6 +39,11 @@ export const EXIT = Object.freeze({
   // BOT-2783: a Codex review was still not complete at its intervention deadline. The
   // receipt's `error` carries the provenance (limit, its source, window, reason).
   REVIEW_TIMEOUT: 13,
+  // BOT-3189: a staging incident ended this wait early (the server marked it abandoned
+  // and emitted a sequenced `wait_preempted` signal for it). The condition did NOT
+  // fire: the receipt carries the incident and the caller's role; re-arm from
+  // next_cursor (the wait's cursor_start) after acting on the incident.
+  PREEMPTED: 14,
 });
 
 // BOT-2013: the uuid spellings Postgres accepts for a lease id (uuid_in), mirrored by the SQL
@@ -91,6 +96,11 @@ 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";
+// BOT-3189: the CONTROL signal a staging incident emits to end the suspect agent's armed
+// waits early (exit 14). Like wait_superseded it targets one wait_session_id, is
+// recipient-scoped at the relay, and is NOT in SIGNAL_TYPES, so it can never be armed
+// through the raw `event:` escape hatch.
+export const WAIT_PREEMPTED_SIGNAL_TYPE = "wait_preempted";
 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
@@ -1029,6 +1039,21 @@ function compactCleanupState(state) {
  * pointer (the `seq`, plus a `payload_truncated` marker); the caller re-fetches
  * detail with the existing get_* tools if it needs the body.
  */
+function compactPreemptedState(state) {
+  const st = state && typeof state === "object" ? state : {};
+  const inc = st.incident && typeof st.incident === "object" ? st.incident : {};
+  return {
+    preempted: true, reason: st.reason ?? null, event: st.event ?? null, role: st.role ?? null,
+    rm_seat_open: st.rm_seat_open ?? null,
+    incident: {
+      id: inc.id ?? null,
+      repo: typeof inc.repo === "string" ? inc.repo.slice(0, 100) : null,
+      suspect_pr_number: inc.suspect_pr_number ?? null,
+    },
+    truncated: true,
+  };
+}
+
 export function truncateReceipt(receipt, maxBytes = 10240) {
   if (Buffer.byteLength(JSON.stringify(receipt)) <= maxBytes) return receipt;
   const clone = JSON.parse(JSON.stringify(receipt));
@@ -1043,8 +1068,11 @@ export function truncateReceipt(receipt, maxBytes = 10240) {
   // fields, so it is kept compact instead (BOT-2013, Codex #1017 P2).
   const leaseLostState = clone.outcome === "lease_lost" ? compactLeaseLostState(clone.state) : null;
   const cleanupState = ["matched", "error"].includes(clone.outcome) ? compactCleanupState(clone.state) : null;
+  // BOT-3189: a preempted receipt's state IS the instruction (role, seat, which incident);
+  // keep it compact rather than dropping it. next_cursor is never touched here.
+  const preemptedState = clone.outcome === "preempted" ? compactPreemptedState(clone.state) : null;
   if (Buffer.byteLength(JSON.stringify(clone)) > maxBytes) {
-    clone.state = leaseLostState ?? cleanupState ?? { truncated: true };
+    clone.state = leaseLostState ?? cleanupState ?? preemptedState ?? { truncated: true };
   }
   // A matched signal's subject key can be caller-controlled through the raw
   // event escape hatch. Keep the durable sequence pointer, but not an
@@ -1123,6 +1151,35 @@ export function truncateReceipt(receipt, maxBytes = 10240) {
     }
     return base;
   }
+  if (Buffer.byteLength(JSON.stringify(clone)) > maxBytes && clone.outcome === "preempted") {
+    // BOT-3189: the bounded fallback keeps what the agent must act on (role, seat, which
+    // incident) and the re-arm cursor, which makes the re-armed wait loss-free; optional
+    // metadata (principal, client, web_url, repo) is added back only while it fits.
+    const st = clone.state && typeof clone.state === "object" ? clone.state : {};
+    const inc = st.incident && typeof st.incident === "object" ? st.incident : {};
+    const base = {
+      schema_version: clone.schema_version,
+      outcome: "preempted",
+      matched: [],
+      state: {
+        preempted: true, event: st.event ?? null, role: st.role ?? null, rm_seat_open: st.rm_seat_open ?? null,
+        incident: { id: inc.id ?? null, suspect_pr_number: inc.suspect_pr_number ?? null },
+        truncated: true,
+      },
+      truncated: true,
+      ...(clone.next_cursor != null ? { next_cursor: clone.next_cursor } : {}),
+    };
+    if (typeof inc.repo === "string") {
+      const candidate = { ...base, state: { ...base.state, incident: { ...base.state.incident, repo: inc.repo.slice(0, 100) } } };
+      if (Buffer.byteLength(JSON.stringify(candidate)) <= maxBytes) base.state = candidate.state;
+    }
+    for (const key of ["wait_session_id", "client", "web_url", "principal"]) {
+      if (clone[key] == null) continue;
+      const candidate = { ...base, [key]: clone[key] };
+      if (Buffer.byteLength(JSON.stringify(candidate)) <= maxBytes) base[key] = clone[key];
+    }
+    return base;
+  }
   if (Buffer.byteLength(JSON.stringify(clone)) > maxBytes && clone.outcome === "review_timeout" &&
       clone.error && typeof clone.error === "object") {
     // BOT-2783: keep the actionable provenance (limit, its source, why, which
@@ -1927,6 +1984,25 @@ export async function runWaitLoop({
     });
   };
 
+  const finalizePreempted = async (signal) => {
+    // Re-arm from cursor_start, exactly like a supersession: anything that matched this
+    // wait's conditions after it armed is replayed by the re-armed wait.
+    const p = signal.payload ?? {};
+    const cs = p.cursor_start;
+    if (cs != null && /^\d+$/.test(String(cs))) cursor = String(cs);
+    return finalize("preempted", {
+      exitCode: EXIT.PREEMPTED,
+      state: {
+        preempted: true,
+        reason: typeof p.reason === "string" ? p.reason : null,
+        event: typeof p.event === "string" ? p.event : null,
+        role: typeof p.role === "string" ? p.role : null,
+        rm_seat_open: typeof p.rm_seat_open === "boolean" ? p.rm_seat_open : null,
+        incident: p.incident && typeof p.incident === "object" ? p.incident : null,
+      },
+    });
+  };
+
   // Fold the timer conditions and the --timeout cap into one earliest alarm.
   // A timer condition firing is a MATCH (exit 0); the --timeout cap is a
   // TIMEOUT (exit 2). With --any the earliest of the two always wins.
@@ -2233,6 +2309,13 @@ export async function runWaitLoop({
         // BOT-2360: the relay refuses a stream bound to a wait the server already ended
         // (prod a0cd7b11 parked 54 min on one). Never reconnect to it: exit typed, with the
         // confirmed cursor so a re-arm replays everything after it.
+        // BOT-3189: the relay's rollout-compat frame for a preempted wait. Pre-1.69.1
+        // clients exit 11 on it; this client acts on the seq-bearing wait_preempted signal
+        // (exit 14, incident in the receipt) that the relay sends next, so ignore it.
+        if (parsed.error === "wait_abandoned" && parsed.reason === "preempted" &&
+            (parsed.wait_session_id == null || parsed.wait_session_id === waitSessionId)) {
+          continue;
+        }
         if (parsed.error === "wait_abandoned") {
           return finalize("abandoned", {
             exitCode: EXIT.ABANDONED,
@@ -2292,7 +2375,11 @@ export async function runWaitLoop({
           if (restoredAlarm != null && Number.isFinite(candidateAtMs) && restoredAlarm.atMs < candidateAtMs) {
             return fireAlarm(restoredAlarm);
           }
-          if (replayCandidate.kind === "superseded") return finalizeSuperseded(replayCandidate.signal);
+          if (replayCandidate.kind === "superseded") {
+            return replayCandidate.signal.signal_type === WAIT_PREEMPTED_SIGNAL_TYPE
+              ? finalizePreempted(replayCandidate.signal)
+              : finalizeSuperseded(replayCandidate.signal);
+          }
           const terminal = await finalizeMatch(replayCandidate.entry, replayCandidate.signal);
           if (onFrame) {
             await onFrame(replayCandidate.signal, {
@@ -2348,7 +2435,7 @@ export async function runWaitLoop({
       // at the relay, so an agent's OTHER concurrent waits receive it too; this id check
       // is why only the intended one treats it as terminal.
       if (
-        signal.signal_type === WAIT_SUPERSEDED_SIGNAL_TYPE &&
+        (signal.signal_type === WAIT_SUPERSEDED_SIGNAL_TYPE || signal.signal_type === WAIT_PREEMPTED_SIGNAL_TYPE) &&
         waitSessionId != null &&
         signal.payload && signal.payload.wait_session_id === waitSessionId
       ) {
@@ -2356,7 +2443,8 @@ export async function runWaitLoop({
           if (beforeReplayDeadline) pendingReplaySupersession ??= { signal, seqKey };
           continue;
         }
-        return finalizeSuperseded(signal);
+        // BOT-3189: a staging-incident preemption ends the wait the same way (exit 14).
+        return signal.signal_type === WAIT_PREEMPTED_SIGNAL_TYPE ? finalizePreempted(signal) : finalizeSuperseded(signal);
       }
 
       // BOT-1148/BOT-2100: every capacity frame for a pinned host participates in

package/src/wait-result.mjs

@@ -12,7 +12,7 @@ const MAX_RECEIPT_BYTES = 64 * 1024;
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const COMMAND_STATUSES = new Set(["success", "failure", "cancelled", "timed_out", "owner_lost"]);
 // BOT-2783: review_timeout is terminal (exit 13, typed REVIEW_TIMEOUT provenance).
-const TERMINAL_OUTCOMES = new Set(["matched", "timeout", "error", "superseded", "lease_lost", "abandoned", "cancelled", "review_timeout"]);
+const TERMINAL_OUTCOMES = new Set(["matched", "timeout", "error", "superseded", "lease_lost", "abandoned", "cancelled", "review_timeout", "preempted"]);
 
 // Persisted != delivered. Await the stream callback before exiting, including
 // when a bounded receipt is larger than the pipe's immediately writable space.

package/src/wait.mjs

@@ -320,7 +320,10 @@ OUTPUT
                 was parked — reaped after 180 s without a live stream,
                 or cancelled; receipt outcome abandoned +
                 state.status/reason — re-arm with --since <next_cursor>)
-                · 12 named lease cleanup failed · 13 review timeout
+                · 12 named lease cleanup failed · 14 preempted (a
+                staging incident ended this wait; its condition did NOT
+                fire — act on the incident, then re-arm with the printed
+                command) · 13 review timeout
                 (REVIEW_TIMEOUT: a Codex review still incomplete at its
                 deadline; receipt error carries minutes/source/reason —
                 use the fallback reviewer, never infer approval).
@@ -885,14 +888,78 @@ export function waitAbandonedNotice(receipt) {
     `reason=${st.reason ?? "unknown"}) — re-arm the same conditions with${since || " a fresh wait"} (exit ${EXIT.ABANDONED})`;
 }
 
-function writeLeaseLostNotice(receipt) {
-  const notice = leaseLostNotice(receipt) ?? waitAbandonedNotice(receipt) ?? reviewTimeoutNotice(receipt);
+/**
+ * BOT-3189: the stderr warning for a `preempted` receipt (null for any other outcome): what
+ * happened, the caller's role in the incident, and the exact command that re-arms the same
+ * conditions from the wait's arm cursor, so nothing that matched meanwhile is lost.
+ */
+// BOT-3189: the original `bb wait` arguments to repeat in a re-arm command. Every option
+// is kept as given (--url, --timeout, --allow-short-timeout, --heartbeat, --any, …) except
+// secrets, the old --since, and internal recovery flags; the caller appends the new cursor.
+const REARM_DROPPED_VALUE_FLAGS = new Set([
+  "--since", "--agent-session-token", "--agent-key", "--session-token", "--token", "--profile",
+  "--deadline-at", "--resume-local-wait",
+]);
+export function rearmArgs(argv = []) {
+  const out = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = String(argv[i]);
+    const eq = a.indexOf("=");
+    const flag = a.startsWith("--") && eq > 0 ? a.slice(0, eq) : a;
+    if (REARM_DROPPED_VALUE_FLAGS.has(flag)) {
+      if (flag === a) i += 1; // skip its separate value
+      continue;
+    }
+    out.push(a);
+  }
+  return out;
+}
+
+export function waitPreemptedNotice(receipt, conditionArgs = [], options = {}) {
+  if (receipt?.outcome !== "preempted") return null;
+  const st = receipt.state ?? {};
+  const inc = st.incident ?? {};
+  const quote = (a) => `'${String(a).replace(/'/g, "'\\''")}'`;
+  const since = receipt.next_cursor != null ? ` --since ${receipt.next_cursor}` : "";
+  // Keep the non-secret wait options that change behaviour: --heartbeat keeps the agent
+  // (and a release-manager lock it may now hold) alive while it waits again.
+  const timeout = Number.isFinite(options.timeout) && options.timeout > 0 ? ` --timeout ${options.timeout}` : "";
+  const heartbeat = options.heartbeat ? " --heartbeat" : "";
+  // A cap under the floor only re-arms with the same documented exemption.
+  const shortReason = typeof options.shortTimeoutReason === "string" && options.shortTimeoutReason.trim()
+    ? ` --allow-short-timeout ${quote(options.shortTimeoutReason.trim())}`
+    : "";
+  const exemption = Number.isFinite(options.timeout) && options.timeout < MIN_WAIT_TIMEOUT_SEC ? shortReason : "";
+  // With the original argv (a live wait) repeat it verbatim minus secrets; a resumed wait
+  // only knows its condition specs, so rebuild the behavioural options it does know.
+  const rearm = Array.isArray(options.argv)
+    ? `bb wait ${rearmArgs(options.argv).map(quote).join(" ")}${since}`
+    : `bb wait ${conditionArgs.map(quote).join(" ")}${since}${timeout}${exemption}${heartbeat}`;
+  const what = `staging ${inc.repo ?? "?"} is red${inc.red_sha ? ` at ${String(inc.red_sha).slice(0, 10)}` : ""}` +
+    `${inc.suspect_pr_number != null ? `, suspect PR #${inc.suspect_pr_number}` : ""}` +
+    `${inc.run_url ? ` (${inc.run_url})` : ""}`;
+  let role;
+  if (st.role === "release_manager") {
+    role = "you are now the release manager — call get_staging_gate for the next steps";
+  } else if (st.rm_seat_open) {
+    role = "the release-manager seat is OPEN — call claim_release_manager, then get_staging_gate";
+  } else {
+    role = "call get_staging_gate for your role and the next steps";
+  }
+  return `bb-wait: this wait was ended by a staging incident; its condition did not fire — re-arm it.\n` +
+    `bb-wait: ${what}; ${role}.\n` +
+    `bb-wait: re-arm (exit ${EXIT.PREEMPTED}): ${rearm}`;
+}
+
+function writeLeaseLostNotice(receipt, conditionArgs = [], options = {}) {
+  const notice = leaseLostNotice(receipt) ?? waitAbandonedNotice(receipt) ?? reviewTimeoutNotice(receipt) ??
+    waitPreemptedNotice(receipt, conditionArgs, options);
   if (notice) process.stderr.write(`${notice}\n`);
 }
 
 // BOT-1228 / BOT-2360: outcomes whose wait_session the server already ended. The client
 // never finalizes them (finalize_wait_session only transitions from active).
-const SERVER_ENDED_OUTCOMES = new Set(["superseded", "abandoned"]);
+const SERVER_ENDED_OUTCOMES = new Set(["superseded", "abandoned", "preempted"]);
 
 // Record the terminal outcome. Best-effort AND bounded: the receipt has already
 // been written to stdout before this runs, so a slow/failing finalize must never
@@ -1620,7 +1687,7 @@ async function resumeSavedWait(id) {
     } finally {
       await fence?.release();
     }
-    writeLeaseLostNotice(checkpoint.terminal_receipt);
+    writeLeaseLostNotice(checkpoint.terminal_receipt, checkpoint.condition_specs ?? []);
     await writeWaitReceipt(checkpoint.terminal_receipt);
     process.exit(Number.isInteger(checkpoint.exit_code) ? checkpoint.exit_code : EXIT.INTERNAL);
   }
@@ -1693,6 +1760,7 @@ export function recoveredExitCode(receipt) {
   if (receipt?.outcome === "timeout") return EXIT.TIMEOUT;
   if (receipt?.outcome === "superseded") return EXIT.SUPERSEDED;
   if (receipt?.outcome === "abandoned") return EXIT.ABANDONED;
+  if (receipt?.outcome === "preempted") return EXIT.PREEMPTED;
   if (receipt?.error === "cursor_expired") return EXIT.CURSOR_EXPIRED;
   if (receipt?.error === "unauthorized" || receipt?.error === "forbidden") return EXIT.AUTH;
   return EXIT.BACKEND;
@@ -1885,7 +1953,9 @@ export async function runWait(argv, { recoveryLocalWaitId = null } = {}) {
   // BOT-2013 (Codex #1017 P2): every receipt this command prints — live, recovered, or
   // replayed — carries the lease-lost stderr line when it is a lease_lost terminal.
   const emitReceipt = (receipt, options = {}) => {
-    writeLeaseLostNotice(receipt);
+    writeLeaseLostNotice(receipt, opts.conditions, {
+      heartbeat: opts.heartbeat, timeout: opts.timeout, shortTimeoutReason: opts.shortTimeoutReason, argv,
+    });
     if (receipt?.outcome === "error") writeWaitFeedbackGuidance();
     return emit(receipt, { ...options, maxBytes: opts.receiptMaxBytes });
   };