mixdog 0.7.1

package/src/status/aggregator.mjs

@@ -0,0 +1,584 @@
+/**
+ * Bridge-status aggregator.
+ *
+ * Builds the JSON / text payload consumed by statusline.sh and setup.html.
+ * Extracted from setup-server.mjs (0.1.25 and earlier) so both the setup
+ * server (on-demand, port 3458) and the MCP-embedded status server (always
+ * on, ephemeral port) can serve the same response without drifting.
+ *
+ * All reads are best-effort; any single source failing leaves that segment
+ * empty rather than failing the whole response.
+ */
+
+import http from 'http';
+import { listSchedules } from '../shared/schedules-store.mjs';
+
+import {
+  existsSync,
+  readFileSync,
+  readdirSync,
+} from 'fs';
+import { join } from 'path';
+
+const RECENT_MS = 30 * 60 * 1000;
+const SNAPSHOT_STALE_MS = 30_000;
+
+// Negative cache for ngrok offline state. Invariant: a /api/tunnels probe
+// that fails or returns no tunnel proves ngrok is offline; re-probing
+// within NGROK_OFFLINE_CACHE_MS adds zero information but pays a ~300ms
+// HTTP timeout per statusline tick. Cache the negative result; any
+// positive result (snapshot or successful probe) bypasses the cache.
+let _ngrokOfflineUntilMs = 0;
+const NGROK_OFFLINE_CACHE_MS = 30_000;
+
+// Whole-result cache for buildBridgeStatus. statusline polls at ~1s; a
+// short TTL collapses bursts (paired GET + setup-server tick + occasional
+// duplicate frame) into one IO pass. Sidecar files / sessions scan don't
+// change meaningfully within 800ms, so callers see consistent state.
+// Any caller that needs strictly-fresh data should pass options.noCache.
+const _buildCache = new Map();
+const BUILD_CACHE_MS = 800;
+const TWELVE_H = 12 * 60 * 60 * 1000;
+
+// Sessions directory scan cache. statusline polls aggregator at a tight
+// cadence (≤1s); without memoisation the readdirSync + per-file readFileSync +
+// JSON.parse pass burns a single core when sessions/ accumulates hundreds of
+// closed-session JSONs. TTL aligned with statusline polling cadence so the
+// CLOSED_GRACE_MS jitter window below is visible without strobing.
+const SESSIONS_CACHE_TTL_MS = 1_000;
+// Ephemeral maintenance roles (cycle1-agent, cycle2-agent, etc.) close
+// inside ~15-20s, faster than two statusline ticks can render. Keeping a
+// closed bridge session visible for this grace window past its terminal
+// updatedAt smooths the badge so short-lived workers don't strobe in and
+// out invisibly. STREAM_FRESH_MS still drops genuinely stalled sessions.
+const CLOSED_GRACE_MS = 5_000;
+let _sessionsCache = null;
+let _sessionsCacheAt = 0;
+
+function readSessionsScan(sessionsDir, now) {
+  if (_sessionsCache && (now - _sessionsCacheAt) < SESSIONS_CACHE_TTL_MS) {
+    return _sessionsCache;
+  }
+  const allSessions = [];
+  const hbMap = new Map();
+  let files = [];
+  try {
+    files = readdirSync(sessionsDir);
+  } catch {
+    // ENOENT (fresh install, no sessions/ yet) / EACCES (locked dir) ->
+    // empty scan; caller treats as no sessions. Avoids the check-then-
+    // readdir race where existsSync says yes but the dir vanishes before
+    // readdir, propagating an error into statusline.
+    files = [];
+  }
+  for (const f of files) {
+    if (f.endsWith('.json')) {
+      try {
+        const parsed = JSON.parse(readFileSync(join(sessionsDir, f), 'utf-8'));
+        // Reject non-plain-object payloads (null, arrays, strings, numbers).
+        // isSessionRunning + downstream consumers do bare property access
+        // (s.owner, s.closed, s.id) which throws on null and misbehaves on
+        // arrays/primitives — a single malformed file would otherwise sink
+        // the whole status build.
+        if (parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)) {
+          allSessions.push(parsed);
+        }
+      }
+      catch { /* skip corrupt */ }
+    } else if (f.endsWith('.hb')) {
+      const id = f.slice(0, -3);
+      try {
+        const ts = parseInt(readFileSync(join(sessionsDir, f), 'utf-8').trim(), 10);
+        if (Number.isFinite(ts)) hbMap.set(id, ts);
+      } catch { /* skip */ }
+    }
+  }
+  _sessionsCache = { allSessions, hbMap };
+  _sessionsCacheAt = now;
+  return _sessionsCache;
+}
+
+function normalizeTimestamp(value) {
+  if (value === null || value === undefined || value === '') return null;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+
+function buildRecapSegment(recap = {}) {
+  const validStates = new Set(['idle', 'running', 'injected', 'empty', 'error']);
+  const rawState = typeof recap.state === 'string' && validStates.has(recap.state) ? recap.state : 'idle';
+  return {
+    state: rawState,
+    running: recap.running === true,
+    startedAt: normalizeTimestamp(recap.startedAt),
+    lastCompletedAt: normalizeTimestamp(recap.lastCompletedAt),
+    updatedAt: normalizeTimestamp(recap.updatedAt),
+    errorMessage: typeof recap.errorMessage === 'string' ? recap.errorMessage.slice(0, 200) : null,
+  };
+}
+
+// Hidden maintenance roles (see defaults/hidden-roles.json kind="maintenance").
+// Plugin-internal background workers without per-terminal ownership: cycle1/2/3,
+// scheduler-task, webhook-handler. Spawned via
+// callBridgeLlm WITHOUT an explicit ownerSessionId, so the session-builder
+// fallback inherits the spawning instance's MIXDOG_OWNER_SESSION_ID rather
+// than leaving it null. The set is still used by the closed-grace / last-
+// completed visibility gates below; owner-scoping (matchesOwnerSession) now
+// keeps each terminal's statusline limited to the workers it actually spawned.
+const SHARED_BACKGROUND_ROLES = new Set([
+  'cycle1-agent',
+  'cycle2-agent',
+  'cycle3-agent',
+  'scheduler-task',
+  'webhook-handler',
+]);
+
+function matchesOwnerSession(session, ownerSessionId) {
+  if (!ownerSessionId) return true;
+  return session?.ownerSessionId === ownerSessionId;
+}
+
+function matchesClientHostPid(session, clientHostPid) {
+  if (!clientHostPid) return true;
+  return session?.clientHostPid === clientHostPid;
+}
+
+function keepClosedSessionVisible(session) {
+  // Only grace a genuine just-finished close. idle-sweep / abort batch-closes
+  // bump updatedAt on many stale tombstones at once; without this reason gate
+  // they all re-enter the 5s closed-grace simultaneously and strobe the badge
+  // (the SHARED_BACKGROUND_ROLES "phantom flash" at idle). Genuine completions
+  // (e.g. ephemeral-done) are not suppressed, so real finishes still show.
+  return session?.role
+    && SHARED_BACKGROUND_ROLES.has(session.role)
+    && shouldShowLastCompleted(session);
+}
+
+const SUPPRESSED_LAST_COMPLETED_REASONS = new Set([
+  'manual',
+  'request-abort',
+  'request-aborted',
+  'retry-replaced',
+  'idle-sweep',
+]);
+
+function shouldShowLastCompleted(session) {
+  const reason = session?.closedReason ? String(session.closedReason) : '';
+  return !SUPPRESSED_LAST_COMPLETED_REASONS.has(reason);
+}
+
+// Active-session filter anchored on stream-recency via the heartbeat
+// file. .hb is the single source of truth — no disk session.status /
+// lastStreamDeltaAt fallback. The 5min window keeps the badge alive
+// across long reasoning blocks (xhigh effort, deep tool chains) where
+// the gap between SSE chunks routinely exceeds 30s. Genuine stalls
+// eventually trip the bridge-stall-watchdog or the RUNNING_STALL_MS
+// sweep at 10min; closed:true plants land on disk synchronously so the
+// badge drops immediately on real completion.
+const STREAM_FRESH_MS = 5 * 60 * 1000;
+
+// Mirror of the store-side running-stall window (store.mjs:489). A not-yet-
+// closed session whose heartbeat lapsed during a long non-streaming tool call
+// stays visible until this window — matching when the store sweep would
+// actually close it — so deep tool chains don't blink out mid-run.
+const RUNNING_STALL_MS = 10 * 60 * 1000;
+
+// Shared running-session predicate used by both the full and compact
+// builders. Multi-CC isolation: owner-scoped status servers must not
+// show bridge sessions from another terminal — untagged legacy
+// sessions are hidden once the request is owner-scoped. Heartbeat-less
+// grace is reserved for shared background roles; user worker sessions
+// must have a fresh heartbeat, otherwise stale tombstones can flash in
+// unrelated statuslines during spawn/claim races.
+function isSessionRunning(s, { hbMap, now, ownerSessionId, clientHostPid, ownerHostPid, includeClosedGrace = true }) {
+  if (s.owner !== 'bridge') return false;
+  if (!matchesOwnerSession(s, ownerSessionId)) return false;
+  const isSharedBackground = s.role && SHARED_BACKGROUND_ROLES.has(s.role);
+  // Scoping unit differs by role kind (invariant, not a fallback):
+  //   - Maintenance/background roles (cycle1/2/3-agent, scheduler-task,
+  //     webhook-handler) are spawned by the memory daemon via
+  //     callBridgeLlm WITHOUT a clientHostPid, so their session JSON has
+  //     none. They belong to the ACTIVE OWNER TERMINAL (owner = one live
+  //     session, NOT the daemon): on a shared daemon every attached
+  //     terminal carries the same ownerSessionId, so owner-scoping alone
+  //     would leak maintenance chips onto EVERY terminal. Gate them
+  //     on the requesting terminal being the active-instance owner —
+  //     clientHostPid === ownerHostPid (active-instance.json SSOT). When
+  //     ownerHostPid or the request clientHostPid is absent (legacy /
+  //     single-instance), fall through to owner-scoping unchanged.
+  //   - User worker sessions (worker/reviewer/debugger/tester) carry a
+  //     per-terminal clientHostPid and stay strictly isolated to the
+  //     terminal that spawned them.
+  if (isSharedBackground) {
+    if (ownerHostPid && clientHostPid && clientHostPid !== ownerHostPid) return false;
+  } else if (!matchesClientHostPid(s, clientHostPid)) {
+    return false;
+  }
+  if (s.closed === true) {
+    if (!includeClosedGrace) return false;
+    return keepClosedSessionVisible(s) && (now - (s.updatedAt || 0)) <= CLOSED_GRACE_MS;
+  }
+  const hb = hbMap.get(s.id);
+  if (hb && (now - hb) <= STREAM_FRESH_MS) return true;
+  if (s.status && s.status !== 'running') return false;
+  const statusIsRunning = s.status === 'running';
+  // Heartbeat-less grace is only for plugin-owned background work. Public
+  // worker/reviewer/debugger sessions clear their heartbeat on completion but
+  // may remain on disk as idle tombstones, so treating updatedAt as liveness
+  // makes finished workers linger in L2 and leak across terminals.
+  if (isSharedBackground && statusIsRunning && (now - (s.updatedAt || 0)) <= RUNNING_STALL_MS) return true;
+  return false;
+}
+
+// Idle bridge-worker predicate. A worker that has finished its turn clears
+// its heartbeat (so isSessionRunning is false) but may remain on disk as an
+// idle tombstone until the store reaps it. Reaped sessions are deleted from
+// sessions/ entirely, so they fall out of allSessions and vanish from L2 with
+// no extra logic here. We surface the surviving idle workers (greyed) so the
+// user can see a worker is parked-but-present, distinct from RUNNING.
+// Maintenance/background roles are excluded — only owner-scoped user workers.
+function isIdleWorkerSession(s, { ownerSessionId, clientHostPid }) {
+  if (s.owner !== 'bridge') return false;
+  if (!matchesOwnerSession(s, ownerSessionId)) return false;
+  if (!matchesClientHostPid(s, clientHostPid)) return false;
+  if (s.closed === true) return false; // closed → handled by closed-grace / lastCompleted
+  if (s.role && SHARED_BACKGROUND_ROLES.has(s.role)) return false; // maintenance, not a user worker
+  return true; // on-disk, not running (callers exclude running ids), not closed → idle
+}
+
+// Build the unified worker list consumed by L2: running workers carry
+// status 'running', surviving idle tombstones carry 'idle'. Each entry keeps
+// its bridgeTag so the statusline can render tag + status. This is the single
+// thread that carries running/idle status from aggregator → statusline-lib.
+function buildWorkerList(running, idle) {
+  return [
+    ...running.map((s) => ({ tag: s.bridgeTag || s.role || 'agent', status: 'running' })),
+    ...idle.map((s) => ({ tag: s.bridgeTag || s.role || 'agent', status: 'idle' })),
+  ].filter((w) => w.tag);
+}
+
+// Snapshot → nextSchedule parser. Used by both builders. Returns null
+// when the snapshot has no schedules.next entry or the fireAt is not a
+// finite number; otherwise returns { name, fireAt }.
+function parseNextScheduleFromSnap(snap) {
+  if (!snap?.schedules?.next) return null;
+  const fireAt = Number(snap.schedules.next.fireAt);
+  if (!Number.isFinite(fireAt)) return null;
+  // ECMAScript caps valid Date instants at ±8.64e15 ms from epoch; finite
+  // numbers outside that range yield an Invalid Date whose toISOString()
+  // throws RangeError. Treat out-of-range snapshots as best-effort-absent
+  // so a malformed schedules.next does not sink buildBridgeStatus.
+  if (Math.abs(fireAt) > 8.64e15) return null;
+  return { name: snap.schedules.next.name, fireAt };
+}
+
+export async function buildBridgeStatus(dataDir, options = {}) {
+  const now = Date.now();
+  // Short-TTL whole-result cache. statusline tick is ~1s, so an 800ms TTL
+  // turns repeated GETs (paired status + setup duplicate) into zero-cost
+  // returns while keeping per-tick freshness for the user.
+  const _cacheKey = `${options.ownerSessionId || ''}|${options.clientHostPid ?? ''}`;
+  if (!options.noCache) {
+    const _cached = _buildCache.get(_cacheKey);
+    if (_cached && now - _cached.at < BUILD_CACHE_MS) return _cached.result;
+  }
+
+  const SESSIONS_DIR = join(dataDir, 'sessions');
+  const STATUS_SNAPSHOT_PATH = join(dataDir, 'channels', 'status-snapshot.json');
+  const JOBS_STATE_PATH = join(dataDir, 'jobs', 'state.json');
+  const CACHE_STATS_PATH = join(dataDir, 'cache-stats.json');
+
+  // ── 1. Active + recently-completed bridge sessions ────────────────
+  // Single readdir over sessions/ separates `<id>.json` (full session
+  // payload) from `<id>.hb` (lightweight heartbeat published by
+  // markSessionStreamDelta on a ≤5s self-throttle). The .hb file is the
+  // authoritative fresh signal because the heavy session.json save is
+  // throttled to 60s.
+  const { allSessions, hbMap } = readSessionsScan(SESSIONS_DIR, now);
+  const running = allSessions.filter(s => isSessionRunning(s, {
+    hbMap, now, ownerSessionId: options.ownerSessionId, clientHostPid: options.clientHostPid, ownerHostPid: options.ownerHostPid,
+  }));
+  const runningRoles = running.map(s => s.bridgeTag || s.role || 'agent').filter(Boolean);
+  // Surviving idle worker tombstones (running ones excluded so a session is
+  // never counted twice). Reaped sessions are gone from allSessions already.
+  const runningIds = new Set(running.map(s => s.id));
+  const idle = allSessions.filter(s => !runningIds.has(s.id)
+    && isIdleWorkerSession(s, { ownerSessionId: options.ownerSessionId, clientHostPid: options.clientHostPid }));
+  const workers = buildWorkerList(running, idle);
+
+  const recentClosed = allSessions
+    .filter(s => s.owner === 'bridge'
+      && s.closed === true
+      && shouldShowLastCompleted(s)
+      && matchesOwnerSession(s, options.ownerSessionId)
+      && matchesClientHostPid(s, options.clientHostPid)
+      && (now - (s.updatedAt || 0)) <= RECENT_MS)
+    .sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
+  const lastCompleted = recentClosed[0] || null;
+
+  // ── 2. Scheduler state ────────────────────────────────────────────
+  let scheduleActive = 0;
+  let scheduleDeferred = 0;
+  let nextSchedule = null;
+  let discordTotalUnread = null;
+  let ngrokTunnelUrl = null;
+  let snapshotFresh = false;
+  try {
+    if (existsSync(STATUS_SNAPSHOT_PATH)) {
+      const snap = JSON.parse(readFileSync(STATUS_SNAPSHOT_PATH, 'utf-8'));
+      if (snap && typeof snap.writtenAt === 'number' && (now - snap.writtenAt) <= SNAPSHOT_STALE_MS) {
+        snapshotFresh = true;
+        // Schedules truth source: `${CLAUDE_PLUGIN_DATA}/schedules/<name>/`.
+        // listSchedules() is shared with channels/lib/config.mjs and
+        // setup-server so all three see the same entry list.
+        const allSchedules = listSchedules().filter(s => s.enabled !== false && s.name);
+        scheduleActive = allSchedules.length;
+        scheduleDeferred = snap.schedules?.deferredCount ?? 0;
+        nextSchedule = parseNextScheduleFromSnap(snap);
+        if (typeof snap.discord?.totalUnread === 'number') {
+          discordTotalUnread = snap.discord.totalUnread;
+        }
+        if (snap.ngrok?.tunnelUrl) {
+          ngrokTunnelUrl = snap.ngrok.tunnelUrl;
+        }
+      }
+    }
+  } catch { /* snapshot unreadable */ }
+
+  if (!snapshotFresh) {
+    try {
+      const allSchedules = listSchedules().filter(s => s.enabled !== false && s.name);
+      scheduleActive = allSchedules.length;
+
+      const candidates = [];
+      for (const s of allSchedules) {
+        if (!s.time || !/^\d{2}:\d{2}$/.test(s.time)) continue;
+        // Skip entries the snapshot-less fallback cannot faithfully
+        // evaluate: cron expressions, non-local timezones, day-of-week
+        // restrictions, and any deferrals (only carried in the snapshot).
+        // Emitting a falsely-imminent upcoming entry is worse than
+        // showing none — the statusline simply omits the badge.
+        if (s.cron) continue;
+        if (s.timezone) continue;
+        if (Array.isArray(s.days) && s.days.length > 0) continue;
+        const [hh, mm] = s.time.split(':').map(Number);
+        for (const offsetDays of [0, 1]) {
+          const candidate = new Date(now);
+          candidate.setDate(candidate.getDate() + offsetDays);
+          candidate.setHours(hh, mm, 0, 0);
+          const diff = candidate.getTime() - now;
+          if (diff > 0 && diff <= TWELVE_H) {
+            candidates.push({ name: s.name, fireAt: candidate.getTime(), diff });
+          }
+        }
+      }
+      candidates.sort((a, b) => a.diff - b.diff);
+      if (candidates.length > 0) nextSchedule = candidates[0];
+    } catch { /* config unreadable */ }
+  }
+
+  // ── 3. Jobs count ────────────────────────────────────────────────
+  let jobsCount = 0;
+  if (existsSync(JOBS_STATE_PATH)) {
+    try {
+      const jobsState = JSON.parse(readFileSync(JOBS_STATE_PATH, 'utf-8'));
+      if (Array.isArray(jobsState)) {
+        jobsCount = jobsState.filter(j => j.status === 'running').length;
+      }
+    } catch { /* unreadable */ }
+  }
+
+  // ── 5. Ngrok online ──────────────────────────────────────────────
+  let ngrokOnline = false;
+  if (ngrokTunnelUrl) {
+    ngrokOnline = true;
+    _ngrokOfflineUntilMs = 0; // positive evidence resets negative cache
+  } else if (Date.now() < _ngrokOfflineUntilMs) {
+    // Negative cache hit — skip the ~300ms HTTP probe.
+    ngrokOnline = false;
+  } else {
+    await new Promise((resolve) => {
+      const timer = setTimeout(() => { try { req_ng && req_ng.destroy(); } catch {} resolve(); }, 300);
+      let req_ng;
+      try {
+        req_ng = http.get('http://127.0.0.1:4040/api/tunnels', (r) => {
+          clearTimeout(timer);
+          let body = '';
+          r.on('data', d => { body += d; });
+          r.on('end', () => {
+            try {
+              const parsed = JSON.parse(body);
+              const tunnel = (parsed.tunnels || []).find(t => t.public_url);
+              if (tunnel) {
+                ngrokOnline = true;
+                ngrokTunnelUrl = tunnel.public_url;
+              }
+            } catch { /* ignore */ }
+            resolve();
+          });
+        });
+        req_ng.on('error', () => { clearTimeout(timer); resolve(); });
+        req_ng.setTimeout(300, () => { clearTimeout(timer); try { req_ng.destroy(); } catch {} resolve(); });
+      } catch { clearTimeout(timer); resolve(); }
+    });
+    if (ngrokOnline) {
+      _ngrokOfflineUntilMs = 0;
+    } else {
+      _ngrokOfflineUntilMs = Date.now() + NGROK_OFFLINE_CACHE_MS;
+    }
+  }
+
+  // ── Assemble payload ─────────────────────────────────────────────
+  const sessionSegment = running.length > 0
+    ? { active: running.length, roles: runningRoles, workers }
+    : { active: 0, roles: [], workers };
+
+  let lastCompletedSegment = null;
+  if (lastCompleted) {
+    const ageMs = now - (lastCompleted.updatedAt || 0);
+    lastCompletedSegment = {
+      role: lastCompleted.role || 'agent',
+      agoMinutes: Math.round(ageMs / 60000),
+    };
+  }
+
+  const scheduleSegment = {
+    active: scheduleActive,
+    deferred: scheduleDeferred,
+    next: nextSchedule ? {
+      name: nextSchedule.name,
+      fireAt: nextSchedule.fireAt,
+      fireAtISO: new Date(nextSchedule.fireAt).toISOString(),
+    } : null,
+  };
+  const recapSegment = buildRecapSegment(options.recap);
+
+  // ── 6. Cache stats ───────────────────────────────────────────────
+  let cacheStats = null;
+  if (existsSync(CACHE_STATS_PATH)) {
+    try {
+      const raw = JSON.parse(readFileSync(CACHE_STATS_PATH, 'utf-8'));
+      if (raw && typeof raw.writtenAt === 'number' && typeof raw.totals === 'object') {
+        const t = raw.totals;
+        cacheStats = {
+          writtenAt: raw.writtenAt,
+          totals: {
+            sets: t.sets ?? 0,
+            hits: t.hits ?? 0,
+            misses: t.misses ?? 0,
+            clears: t.clears ?? 0,
+          },
+          perSession: Array.isArray(raw.perSession) ? raw.perSession : [],
+        };
+      }
+    } catch (e) { try { process.stderr.write(`[status-aggregator] partial-fetch swallow: ${e?.message ?? e}\n`); } catch {} }
+  }
+
+  const _result = {
+    sessions: sessionSegment,
+    lastCompleted: lastCompletedSegment,
+    schedule: scheduleSegment,
+    jobs: { count: jobsCount },
+    recap: recapSegment,
+    ngrok: { online: ngrokOnline, tunnelUrl: ngrokTunnelUrl ?? undefined },
+    ...(discordTotalUnread !== null ? { discord: { totalUnread: discordTotalUnread } } : {}),
+    ...(cacheStats !== null ? { cacheStats } : {}),
+    snapshotFresh,
+    generatedAt: new Date(now).toISOString(),
+  };
+  if (!options.noCache) {
+    _buildCache.set(_cacheKey, { result: _result, at: now });
+  }
+  return _result;
+}
+
+// Compact payload for the statusline 1-5 s polling cadence. Builds only
+// the fields bin/statusline.mjs actually consumes (sessions.roles +
+// schedule.next.{name,fireAt}); skips ngrok probe (~300 ms IO),
+// cache-stats, lastCompleted, jobs.count, discord, recap. Reuses the
+// 1 s readSessionsScan cache so repeated ticks see one disk scan
+// amortised across all statusline-json polls within the window. Compact L2
+// intentionally excludes closed-grace workers; completed work belongs in the
+// full `lastCompleted` segment, not the running badge.
+export async function buildBridgeStatusCompact(dataDir, options = {}) {
+  const now = Date.now();
+  const SESSIONS_DIR = join(dataDir, 'sessions');
+  const STATUS_SNAPSHOT_PATH = join(dataDir, 'channels', 'status-snapshot.json');
+
+  const { allSessions, hbMap } = readSessionsScan(SESSIONS_DIR, now);
+  const running = allSessions.filter((s) => isSessionRunning(s, {
+    hbMap,
+    now,
+    ownerSessionId: options.ownerSessionId,
+    clientHostPid: options.clientHostPid,
+    ownerHostPid: options.ownerHostPid,
+    includeClosedGrace: false,
+  }));
+  const runningRoles = running.map((s) => s.bridgeTag || s.role || 'agent').filter(Boolean);
+  // Mirror buildBridgeStatus: surface surviving idle worker tombstones too.
+  // Note compact deliberately excludes closed-grace from `running`; idle here
+  // means on-disk, not running, not closed — reaped sessions are already gone.
+  const runningIds = new Set(running.map((s) => s.id));
+  const idle = allSessions.filter((s) => !runningIds.has(s.id)
+    && isIdleWorkerSession(s, { ownerSessionId: options.ownerSessionId, clientHostPid: options.clientHostPid }));
+  const workers = buildWorkerList(running, idle);
+
+  let nextSchedule = null;
+  try {
+    if (existsSync(STATUS_SNAPSHOT_PATH)) {
+      const snap = JSON.parse(readFileSync(STATUS_SNAPSHOT_PATH, 'utf-8'));
+      if (snap && typeof snap.writtenAt === 'number' && (now - snap.writtenAt) <= SNAPSHOT_STALE_MS) {
+        nextSchedule = parseNextScheduleFromSnap(snap);
+      }
+    }
+  } catch { /* snapshot unreadable */ }
+
+  return {
+    sessions: { active: running.length, roles: runningRoles, workers },
+    schedule: { next: nextSchedule },
+  };
+}
+
+export function renderBridgeStatusText(payload) {
+  const parts = [];
+  const running = payload.sessions?.active || 0;
+  const roles = payload.sessions?.roles || [];
+
+  if (running > 0) {
+    const roleList = [...new Set(roles)].join(',');
+    parts.push(`⚙ ${running} running (${roleList})`);
+  } else {
+    parts.push('idle');
+  }
+
+  if (payload.lastCompleted) {
+    const ageMins = payload.lastCompleted.agoMinutes || 0;
+    const timeAgo = ageMins <= 0 ? 'just now' : `${ageMins}m`;
+    parts.push(`✓ ${payload.lastCompleted.role} ${timeAgo}`);
+  }
+
+  if (payload.schedule?.next) {
+    const d = new Date(payload.schedule.next.fireAt);
+    const hh = String(d.getHours()).padStart(2, '0');
+    const mm = String(d.getMinutes()).padStart(2, '0');
+    parts.push(`⏰ ${hh}:${mm} ${payload.schedule.next.name}`);
+  }
+
+  if (payload.schedule?.active > 0) {
+    const def = payload.schedule.deferred || 0;
+    parts.push(def > 0
+      ? `📋 ${payload.schedule.active}/${def}def`
+      : `📋 ${payload.schedule.active}`);
+  }
+
+  if (payload.cacheStats?.totals) {
+    const { hits, misses } = payload.cacheStats.totals;
+    const total = hits + misses;
+    if (total >= 1) {
+      const rate = Math.round((hits / total) * 100);
+      parts.push(`cache ${hits}/${total} (${rate}%)`);
+    }
+  }
+
+  return parts.join(' · ');
+}