mixdog 0.7.18 → 0.8.0

package/src/status/aggregator.mjs

@@ -1,584 +0,0 @@
-/**
- * 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;
-  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 (!matchesOwnerSession(s, ownerSessionId)) return false;
-    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 — user workers scoped by clientHostPid only
-// (ownerSessionId is volatile across daemon restarts; clientHostPid is per-terminal SSOT).
-function isIdleWorkerSession(s, { ownerSessionId, clientHostPid }) {
-  if (s.owner !== 'bridge') 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(' · ');
-}