@botbuddy/cli 1.69.2 → 1.69.4

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 1.69.3
+
+- The bb-status band no longer goes dead with "BB session expired" when a Claude Code session outlives its ~8-hour BB session. Within two hours of expiry `bb status-band read` heartbeats the same session; after expiry it renews that same session in place (`renew_agent_session`), so its tickets and PRs stay on the band. `bb wait` and other CLI self-heals renew the session in place before minting a new one. A closed session is never revived: the band then names `bb doctor --fix`.
+
 ## 1.69.2
 
 - The bb-status band shows the epic for a ticket that is in a Linear project again. 1.69.1 fixed tickets with no project, but for a ticket in a project the epic read still timed out on the epic's cost totals, which the band never shows. The band now asks `get_epic_health` for the epic without cost (`include_cost: false`).

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

@@ -37,7 +37,15 @@ const ERRORS = {
     "BB identity belongs to another session. Connect BB for this Claude session.",
   session_changed: "BB session changed during refresh. Refresh again.",
   session_invalid: "BB session is invalid. Reconnect BB in this worktree.",
-  session_expired: "BB session expired. Reconnect BB in this worktree.",
+  // BOT-3206: the band renews its own session; these name the exact command
+  // when it cannot (a closed session is never revived).
+  session_expired: "BB session expired. Run `bb doctor --fix` in this worktree, then Refresh.",
+  session_closed: "BB session was closed. Run `bb doctor --fix` in this worktree, then Refresh.",
+  renewal_unauthorized:
+    "BB refused to renew the session. Run `bb doctor --fix` (or `bb mcp setup` if the MCP key is missing).",
+  session_identity_mismatch:
+    "BB session belongs to another agent. Run `bb doctor --fix` in this worktree.",
+  session_renewal_failed: "BB session renewal failed. Refresh to retry, or run `bb doctor --fix`.",
   session_file_unsafe: "BB session file must be private (mode 0600).",
   tenant_mismatch: "This repo is bound to a tenant BB status does not support.",
   agent_mismatch:
@@ -502,7 +510,7 @@ function stale() {
 }
 function staleText() {
   if (relayFault === "session_expired")
-    return "STALE · BB session expired. Reconnect BB in this worktree, then Refresh.";
+    return "STALE · BB session expired. Run `bb doctor --fix` in this worktree, then Refresh.";
   if (relayFault) return "STALE · Live updates stopped. Refresh to check current status.";
   return "STALE · Refresh to check current status";
 }

package/daemon-release/darwin-arm64.json

@@ -1,7 +1,7 @@
 {
-  "release_version": "1.69.2",
-  "source_commit": "678a0f569a975e17b60a4b4b7823e52e0419703a",
-  "source_sha256": "d5ef72c9c1f86bfdc374907b15b0b86f429270d57adbb18a3c07530a50702983",
+  "release_version": "1.69.4",
+  "source_commit": "fe786c6f3850ee404ab213075e8445a0af0ac2ec",
+  "source_sha256": "d26c4fbae9682e5da62ba9cfd5e0be1e8f580098e9439bcc6111e0a9d4b0d22b",
   "target": "darwin-arm64",
-  "sha256": "fb43e38890d45d1b59a13b8a02da4daeaa7caaf7f18c7c9f8447bf6e8268ddad"
+  "sha256": "45eb395a0b0a1b7f4a5d69257475947a766c8875a51a97d7d523ecdb3dc95c22"
 }

package/daemon-release/linux-x64.json

@@ -1,7 +1,7 @@
 {
-  "release_version": "1.69.2",
-  "source_commit": "678a0f569a975e17b60a4b4b7823e52e0419703a",
-  "source_sha256": "d5ef72c9c1f86bfdc374907b15b0b86f429270d57adbb18a3c07530a50702983",
+  "release_version": "1.69.4",
+  "source_commit": "fe786c6f3850ee404ab213075e8445a0af0ac2ec",
+  "source_sha256": "d26c4fbae9682e5da62ba9cfd5e0be1e8f580098e9439bcc6111e0a9d4b0d22b",
   "target": "linux-x64",
-  "sha256": "b7f92d406a550252d34903215d332dcd0f6471462649bc44d974a08eddc80aec"
+  "sha256": "cb1ce9a04c0a82d89e8fbe1fa4ced2f909905b7177b9dd384942041e09056955"
 }

package/daemon-release/manifest.json

@@ -1,21 +1,21 @@
 {
   "schema_version": 1,
-  "release_version": "1.69.2",
-  "source_commit": "678a0f569a975e17b60a4b4b7823e52e0419703a",
-  "source_sha256": "d5ef72c9c1f86bfdc374907b15b0b86f429270d57adbb18a3c07530a50702983",
+  "release_version": "1.69.4",
+  "source_commit": "fe786c6f3850ee404ab213075e8445a0af0ac2ec",
+  "source_sha256": "d26c4fbae9682e5da62ba9cfd5e0be1e8f580098e9439bcc6111e0a9d4b0d22b",
   "targets": {
     "darwin-arm64": {
       "goos": "darwin",
       "goarch": "arm64",
       "binary": "daemon/bin/darwin-arm64/botbuddy-daemon",
-      "sha256": "fb43e38890d45d1b59a13b8a02da4daeaa7caaf7f18c7c9f8447bf6e8268ddad",
+      "sha256": "45eb395a0b0a1b7f4a5d69257475947a766c8875a51a97d7d523ecdb3dc95c22",
       "mode": "0755"
     },
     "linux-x64": {
       "goos": "linux",
       "goarch": "amd64",
       "binary": "daemon/bin/linux-x64/botbuddy-daemon",
-      "sha256": "b7f92d406a550252d34903215d332dcd0f6471462649bc44d974a08eddc80aec",
+      "sha256": "cb1ce9a04c0a82d89e8fbe1fa4ced2f909905b7177b9dd384942041e09056955",
       "mode": "0755"
     }
   }

package/package.json

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

package/src/agent-session.mjs

@@ -315,6 +315,36 @@ export async function selfHealAgentSession({
     // The tier-2 key is sent the way every MCP-key call is (resolveCallAuth's
     // `mcp_key` source): x-agent-api-key, pinned to the binding's tenant.
     const auth = mcpKey ? { "x-agent-api-key": mcpKey } : { Authorization: `Bearer ${owner.token}` };
+    // BOT-3206: this harness session's own lapsed session is renewed IN PLACE
+    // (same session_id, so its ticket/PR edges keep feeding the bb-status band)
+    // before falling back to a new mint, which would start an unlinked session.
+    // A closed session, another harness's cache, or any renewal failure keeps the
+    // existing mint path. `force` (doctor --fix) still re-registers to re-attest.
+    if (!force && current && ownCache && current.session_id && current.agent_id && (renewal || !isFresh(current, now()))) {
+      const { renewHarnessSession } = await import("./session-bootstrap.mjs");
+      const renewedState = await renewHarnessSession({
+        cwd,
+        harnessSessionId: current.harness_session_id,
+        call,
+        callOptions: { auth },
+        now: () => now().getTime(),
+        readState,
+        writeState,
+        // Already inside this worktree's state lock.
+        transaction: (_options, operation) => operation(cwd),
+      }).catch(() => null);
+      if (renewedState?.agent_session_token && (!renewal || renewedState.agent_session_token !== rejectedCredential.token)) {
+        return withIdentity({
+          token: renewedState.agent_session_token,
+          sessionId: sessionId ?? renewedState.session_id,
+          agentId: renewedState.agent_id,
+          source: "renewed",
+          mintedWith,
+          ticketSignals: null,
+          stackLeaseCapability: null,
+        }, renewedState);
+      }
+    }
     const currentBranch = await branch();
     const resolvedMachineId = await machineId();
     const resolvedHardwareId = await hardwareId();

package/src/api.mjs

@@ -373,6 +373,7 @@ export async function resolveCallAuth({
 export const SESSION_TOKEN_DENIED_TOOLS = new Set([
   "register_agent",
   "bootstrap_agent_session",
+  "renew_agent_session",
   "create_service_account",
   "mint_mcp_key",
   "revoke_mcp_key",

package/src/session-bootstrap.mjs

@@ -4,6 +4,7 @@
 import os from "node:os";
 import { callToolJson } from "./api.mjs";
 import { readAgentState, touchAgentStateExpiry, withStateLock, worktreeRoot, writeAgentState } from "./agent-state.mjs";
+import { AGENT_KEY_RE } from "./agent-key.mjs";
 import { clearAgentSessionIfMatches, drainPendingCleanup, recordPendingCleanup } from "./agent-cleanup.mjs";
 import { readAgentBinding } from "./wait-profile.mjs";
 import { resolveAgentKey, resolveOwnerToken } from "./cli-credentials.mjs";
@@ -160,6 +161,74 @@ export async function heartbeatHarnessSession({
   return response.data;
 }
 
+// BOT-3206: renew THIS harness session's own lapsed BB session in place. The
+// server re-issues a bearer for the exact session row the cache names, so the
+// session_id and its ticket/PR edges survive; a bootstrap or self-heal mint
+// would start a new, unlinked session instead. Only the cache's own harness may
+// renew it, a closed session is refused (`session_closed`), and the durable
+// credential (client key or tenant MCP key) is the only authority: a missing or
+// revoked one fails closed as `renewal_unauthorized`.
+function renewalError(code, message) {
+  return Object.assign(new Error(code), { code, detail: message });
+}
+
+export async function renewHarnessSession({
+  cwd = process.cwd(),
+  harnessSessionId,
+  call = callToolJson,
+  callOptions = {},
+  now = () => Date.now(),
+  readState = readAgentState,
+  writeState = writeAgentState,
+  transaction = withHarnessBootstrapLock,
+} = {}) {
+  if (typeof harnessSessionId !== "string" || !harnessSessionId) {
+    throw renewalError("session_identity_mismatch", "renewal requires this harness session's id");
+  }
+  const harness = harnessSessionId.toLowerCase();
+  return transaction({ cwd }, async (root) => {
+    // Re-read inside the lock: another process may already have renewed it.
+    const cached = await readState(root);
+    if (!cached?.session_id || !cached?.agent_id) throw renewalError("session_identity_mismatch", "no cached session to renew");
+    if (String(cached.harness_session_id ?? "").toLowerCase() !== harness) {
+      throw renewalError("session_identity_mismatch", "the cached session belongs to another harness session");
+    }
+    if (Date.parse(cached.expires_at) > now()) return cached;
+    const response = await call("renew_agent_session", {
+      session_id: cached.session_id,
+      agent_id: cached.agent_id,
+      harness_session_id: harness,
+    }, { ...callOptions, ...(cached.tenant ? { tenant: cached.tenant } : {}) });
+    if (!response?.ok || response.isError) {
+      if (response?.auth) throw renewalError("renewal_unauthorized", "run `bb doctor --fix`, or `bb mcp setup` if the MCP key is missing");
+      const code = response?.code ?? response?.data?.code ?? response?.data?.error;
+      throw renewalError(
+        ["session_closed", "session_identity_mismatch"].includes(code) ? code : "session_renewal_failed",
+        response?.error ?? response?.data?.message ?? "renew_agent_session failed",
+      );
+    }
+    const data = response.data ?? {};
+    // The renewal must be the SAME session, agent and tenant, with a usable bearer.
+    if (data.session_id !== cached.session_id || data.agent_id !== cached.agent_id
+      || (cached.tenant && data.tenant_id !== cached.tenant)
+      || typeof data.session_token !== "string" || !AGENT_KEY_RE.test(data.session_token)
+      || !(Date.parse(data.expires_at) > now())) {
+      throw renewalError("session_renewal_failed", "renew_agent_session returned a different or unusable session");
+    }
+    const state = {
+      ...cached,
+      agent_session_token: data.session_token,
+      minted_at: new Date(now()).toISOString(),
+      expires_at: new Date(Date.parse(data.expires_at)).toISOString(),
+      ...(typeof data.session_token_generation === "string" && data.session_token_generation
+        ? { session_token_generation: data.session_token_generation }
+        : {}),
+    };
+    await writeState(root, state);
+    return state;
+  });
+}
+
 // BOT-1945: a worktree cache that this bootstrap path did not create — written by
 // the self-heal / `bb setup` / MCP registration path (no `harness_origin` marker),
 // or a legacy bootstrap cache with no stored generation — is not a harness

package/src/status-band-read.mjs

@@ -511,12 +511,62 @@ async function bootstrapBand({ cwd, harnessSessionId, branch }) {
   });
 }
 
+// BOT-3206: the band keeps its OWN BB session alive. Inside this window before
+// `expires_at` it heartbeats the session (the server rolls the bearer's expiry
+// and the cache mirrors it); past expiry it renews the same session row with the
+// durable credential. Neither path bootstraps: a bootstrap mints a new session
+// and the session's tickets and PRs stop feeding the band.
+const RENEW_WINDOW_MS = 2 * 60 * 60 * 1000;
+// Renewal refusals the band names itself; anything else is a failed renewal.
+const RENEW_CODES = new Set(["session_closed", "renewal_unauthorized", "session_identity_mismatch", "session_renewal_failed"]);
+async function heartbeatBand({ session, cwd }) {
+  const { heartbeatHarnessSession } = await import("./session-bootstrap.mjs");
+  await heartbeatHarnessSession({ session, cwd });
+}
+async function renewBand({ cwd, harnessSessionId }) {
+  const { renewHarnessSession } = await import("./session-bootstrap.mjs");
+  await renewHarnessSession({ cwd, harnessSessionId });
+}
+// Reads the cache through readSession (mode and size checked) only to route:
+// readStatus re-validates every field before a snapshot is built.
+async function keepSessionAlive({ cwd, harnessSessionId, now, heartbeat, renew }) {
+  let state;
+  try {
+    // The validated reader: an unsafe (group/world-readable) cache is refused
+    // here too, so its bearer is never sent or extended (readStatus reports it).
+    state = await readSession(await realpath(cwd));
+  } catch {
+    return;
+  }
+  // Another harness session's cache, or an unbound one, is never renewed or
+  // taken over here (BOT-3152 AC-5 owns those).
+  if (typeof state?.harness_session_id !== "string" || state.harness_session_id.toLowerCase() !== harnessSessionId.toLowerCase()) return;
+  const expiresAt = Date.parse(state.expires_at);
+  if (!Number.isFinite(expiresAt) || expiresAt - now() > RENEW_WINDOW_MS) return;
+  if (expiresAt > now()) {
+    // Best-effort: a refused heartbeat still leaves a valid bearer to read with,
+    // and the post-expiry renewal below covers a bearer that then lapses.
+    if (UUID.test(state.session_id ?? "") && typeof state.agent_session_token === "string") {
+      await heartbeat({ session: { session_id: state.session_id, session_token: state.agent_session_token }, cwd }).catch(() => {});
+    }
+    return;
+  }
+  try {
+    await renew({ cwd, harnessSessionId });
+  } catch (error) {
+    const code = error?.code ?? error?.message;
+    refuse(RENEW_CODES.has(code) ? code : "session_renewal_failed");
+  }
+}
+
 export async function main(args, {
   out = process.stdout,
   cwd = process.cwd(),
   env = process.env,
   read = readStatus,
   bootstrap = bootstrapBand,
+  heartbeat = heartbeatBand,
+  renew = renewBand,
   now = () => Date.now(),
 } = {}) {
   try {
@@ -530,6 +580,7 @@ export async function main(args, {
     )
       refuse("invalid_arguments");
     const request = { cwd, harnessSessionId: args[1], ticketId: args[3], linearKey: env.LINEAR_BB_API_KEY, skipEpic };
+    if (UUID.test(args[1])) await keepSessionAlive({ cwd, harnessSessionId: args[1], now, heartbeat, renew });
     let snapshot;
     try {
       snapshot = await read(request);