claude-mission-control 1.5.0

package/lib/transcript-view.js

@@ -0,0 +1,117 @@
+'use strict';
+// Full transcript of one session, parsed into displayable turns.
+// Cursor-based: pass back `nextOffset` to read only what was appended since —
+// that's what powers live-follow in the UI.
+const fsp = require('fs/promises');
+
+const MAX_EVENTS = 1200; // initial load keeps the newest N turns
+const USER_CAP = 4000;
+const ASSISTANT_CAP = 8000;
+const TOOL_INPUT_CAP = 240;
+
+function toolInputSummary(input) {
+  if (!input || typeof input !== 'object') return '';
+  // The most readable single field wins; else compact JSON.
+  for (const key of ['command', 'description', 'file_path', 'prompt', 'query', 'url', 'skill']) {
+    if (typeof input[key] === 'string' && input[key].trim()) {
+      return input[key].replace(/\s+/g, ' ').slice(0, TOOL_INPUT_CAP);
+    }
+  }
+  try {
+    return JSON.stringify(input).slice(0, TOOL_INPUT_CAP);
+  } catch {
+    return '';
+  }
+}
+
+function userText(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return null;
+  const parts = [];
+  for (const p of content) {
+    if (p && p.type === 'text' && typeof p.text === 'string') parts.push(p.text);
+  }
+  return parts.length ? parts.join('\n') : null;
+}
+
+function isHarnessNoise(text) {
+  const t = text.trimStart();
+  return (
+    t.startsWith('<system-reminder>') ||
+    t.startsWith('<local-command') ||
+    t.startsWith('<command-') ||
+    t.startsWith('[SYSTEM NOTIFICATION') ||
+    t.startsWith('<task-notification>') ||
+    t.startsWith('Base directory for this skill')
+  );
+}
+
+function parseLine(line, events) {
+  if (!line.trim()) return;
+  let rec;
+  try {
+    rec = JSON.parse(line);
+  } catch {
+    return;
+  }
+  const ts = rec.timestamp ? Date.parse(rec.timestamp) : null;
+
+  if (rec.type === 'user' && rec.message && !rec.isSidechain) {
+    const text = userText(rec.message.content);
+    if (text && text.trim() && !isHarnessNoise(text)) {
+      events.push({ kind: 'user', text: text.slice(0, USER_CAP), truncated: text.length > USER_CAP, ts });
+    }
+    return;
+  }
+
+  if (rec.type === 'assistant' && rec.message && Array.isArray(rec.message.content) && !rec.isSidechain) {
+    for (const part of rec.message.content) {
+      if (!part) continue;
+      if (part.type === 'text' && part.text && part.text.trim()) {
+        events.push({ kind: 'assistant', text: part.text.slice(0, ASSISTANT_CAP), truncated: part.text.length > ASSISTANT_CAP, ts });
+      } else if (part.type === 'tool_use') {
+        events.push({ kind: 'tool', name: part.name || 'tool', input: toolInputSummary(part.input), ts });
+      }
+    }
+    return;
+  }
+
+  if (rec.type === 'system' && rec.subtype === 'away_summary' && rec.content) {
+    events.push({ kind: 'note', text: String(rec.content).slice(0, ASSISTANT_CAP), ts });
+  }
+}
+
+// Read complete lines from `fromOffset` to EOF; a trailing partial line is
+// left for the next call.
+async function readNewLines(file, fromOffset) {
+  const st = await fsp.stat(file);
+  if (st.size <= fromOffset) return { lines: [], nextOffset: fromOffset };
+  const fh = await fsp.open(file, 'r');
+  try {
+    const len = st.size - fromOffset;
+    const buf = Buffer.alloc(len);
+    await fh.read(buf, 0, len, fromOffset);
+    const lastNl = buf.lastIndexOf(0x0a);
+    if (lastNl === -1) return { lines: [], nextOffset: fromOffset };
+    return {
+      lines: buf.subarray(0, lastNl + 1).toString('utf8').split('\n'),
+      nextOffset: fromOffset + lastNl + 1,
+    };
+  } finally {
+    await fh.close();
+  }
+}
+
+async function sessionTranscript(file, fromOffset = 0) {
+  const { lines, nextOffset } = await readNewLines(file, fromOffset);
+  const events = [];
+  for (const line of lines) parseLine(line, events);
+  let truncatedTurns = 0;
+  if (fromOffset === 0 && events.length > MAX_EVENTS) {
+    truncatedTurns = events.length - MAX_EVENTS;
+    events.splice(0, truncatedTurns);
+  }
+  return { events, truncatedTurns, nextOffset };
+}
+
+module.exports = { sessionTranscript };

package/lib/transcripts.js

@@ -0,0 +1,390 @@
+'use strict';
+// Session transcript metadata from ~/.claude/projects/<enc>/<sessionId>.jsonl.
+// Files reach 14MB; never full-parse. Read head (cwd/branch/first prompt),
+// tail (last-prompt / away_summary), and one streaming substring pass for the
+// last ai-title. Cached by (mtime, size).
+const fsp = require('fs/promises');
+const path = require('path');
+const { CLAUDE_DIR, worktreeRoot } = require('./paths');
+const { estimateCost, totalTokens } = require('./pricing');
+
+const PROJECTS_DIR = path.join(CLAUDE_DIR, 'projects');
+const HEAD_BYTES = 64 * 1024;
+const TAIL_BYTES = 16 * 1024;
+
+// absPath -> { mtimeMs, size, meta }
+const cache = new Map();
+
+async function scanAllTranscripts() {
+  let dirs;
+  try {
+    dirs = await fsp.readdir(PROJECTS_DIR);
+  } catch {
+    return [];
+  }
+  const sessions = [];
+  for (const dir of dirs) {
+    const dirPath = path.join(PROJECTS_DIR, dir);
+    let files;
+    try {
+      files = await fsp.readdir(dirPath);
+    } catch {
+      continue;
+    }
+    for (const f of files) {
+      if (!f.endsWith('.jsonl')) continue;
+      const abs = path.join(dirPath, f);
+      const sessionId = f.replace(/\.jsonl$/, '');
+      try {
+        const meta = await scanFile(abs, sessionId);
+        if (meta) {
+          const sub = await scanSubagents(path.join(dirPath, sessionId, 'subagents'));
+          meta.subagentUsage = sub && sub.usage;
+          meta.subagentDays = sub && sub.days;
+          meta.subagentCount = sub ? sub.count : 0;
+          sessions.push(meta);
+        }
+      } catch {
+        /* unreadable file: skip */
+      }
+    }
+  }
+  return sessions;
+}
+
+async function scanFile(abs, sessionIdFromName) {
+  const st = await fsp.stat(abs);
+  const hit = cache.get(abs);
+  if (hit && hit.mtimeMs === st.mtimeMs && hit.size === st.size) return hit.meta;
+  // Incremental scan state survives across rescans of a growing file.
+  const scan = hit && hit.scan && st.size >= hit.scan.offset
+    ? hit.scan
+    : { offset: 0, aiTitle: null, usage: {}, days: {}, lastMsgId: null, lastModel: null };
+
+  const fh = await fsp.open(abs, 'r');
+  let head, tail;
+  try {
+    const headLen = Math.min(HEAD_BYTES, st.size);
+    const headBuf = Buffer.alloc(headLen);
+    await fh.read(headBuf, 0, headLen, 0);
+    head = headBuf.toString('utf8');
+
+    const tailLen = Math.min(TAIL_BYTES, st.size);
+    const tailBuf = Buffer.alloc(tailLen);
+    await fh.read(tailBuf, 0, tailLen, st.size - tailLen);
+    tail = tailBuf.toString('utf8');
+  } finally {
+    await fh.close();
+  }
+
+  const meta = {
+    sessionId: sessionIdFromName,
+    file: abs,
+    cwd: null,
+    gitBranch: null,
+    startedAt: null,
+    lastActivityAt: st.mtimeMs,
+    firstUserPrompt: null,
+    lastPrompt: null,
+    awaySummary: null,
+    awaySummaryAt: null,
+    aiTitle: null,
+  };
+
+  // Head: first ~40 lines; the first line can be queue-operation without cwd.
+  const headLines = head.split('\n').slice(0, 40);
+  for (const line of headLines) {
+    if (!line.trim()) continue;
+    let rec;
+    try {
+      rec = JSON.parse(line);
+    } catch {
+      continue; // possibly truncated final head line
+    }
+    if (meta.cwd === null && typeof rec.cwd === 'string') {
+      meta.cwd = rec.cwd;
+      meta.gitBranch = rec.gitBranch || null;
+    }
+    if (meta.startedAt === null && rec.timestamp) {
+      const t = Date.parse(rec.timestamp);
+      if (!Number.isNaN(t)) meta.startedAt = t;
+    }
+    if (meta.firstUserPrompt === null) {
+      const text = extractUserText(rec);
+      if (text) meta.firstUserPrompt = text.slice(0, 120);
+    }
+    if (meta.cwd && meta.startedAt && meta.firstUserPrompt) break;
+  }
+
+  // Tail: last complete lines carry last-prompt / away_summary.
+  const tailLines = tail.split('\n').filter((l) => l.trim());
+  for (let i = tailLines.length - 1; i >= 0; i--) {
+    let rec;
+    try {
+      rec = JSON.parse(tailLines[i]);
+    } catch {
+      continue; // first tail line is usually a partial record
+    }
+    if (meta.lastPrompt === null && rec.type === 'last-prompt' && rec.lastPrompt) {
+      meta.lastPrompt = String(rec.lastPrompt).slice(0, 200);
+    }
+    if (meta.awaySummary === null && rec.type === 'system' && rec.subtype === 'away_summary' && rec.content) {
+      meta.awaySummary = String(rec.content).slice(0, 800);
+      const t = rec.timestamp ? Date.parse(rec.timestamp) : NaN;
+      meta.awaySummaryAt = Number.isNaN(t) ? null : t;
+    }
+  }
+
+  await incrementalScan(abs, st.size, scan);
+  meta.aiTitle = scan.aiTitle;
+  meta.usage = scan.usage;
+  meta.days = scan.days;
+  meta.waits = scan.waits || null;
+  meta.model = scan.lastModel || null;
+
+  cache.set(abs, { mtimeMs: st.mtimeMs, size: st.size, meta, scan });
+  return meta;
+}
+
+// Reads only the bytes appended since the last scan, up to the last complete
+// line. Accumulates the latest ai-title and per-model token usage. Usage is
+// deduped by message id — one API response spans several assistant records
+// that all carry the same usage object.
+async function incrementalScan(abs, size, scan) {
+  if (size <= scan.offset) return;
+  const fh = await fsp.open(abs, 'r');
+  try {
+    const len = size - scan.offset;
+    const buf = Buffer.alloc(len);
+    await fh.read(buf, 0, len, scan.offset);
+    const lastNl = buf.lastIndexOf(0x0a);
+    if (lastNl === -1) return; // no complete new line yet
+    scan.offset += lastNl + 1;
+    for (const line of buf.subarray(0, lastNl + 1).toString('utf8').split('\n')) {
+      scanLine(line, scan);
+    }
+  } finally {
+    await fh.close();
+  }
+}
+
+function scanLine(line, scan) {
+  if (line.includes('"type":"ai-title"')) {
+    try {
+      const rec = JSON.parse(line);
+      if (rec.aiTitle) scan.aiTitle = rec.aiTitle;
+    } catch {
+      /* ignore */
+    }
+  } else if (line.includes('"type":"assistant"') && line.includes('"usage"')) {
+    try {
+      const rec = JSON.parse(line);
+      const m = rec.message;
+      if (!m || !m.usage) return;
+      if ((m.model || '').startsWith('<')) return; // '<synthetic>' harness records
+      if (m.id && m.id === scan.lastMsgId) return;
+      scan.lastMsgId = m.id || null;
+      const model = m.model || 'unknown';
+      scan.lastModel = model; // most recent real model = the session's model
+      addUsage(scan.usage, model, m.usage);
+      const t = rec.timestamp ? Date.parse(rec.timestamp) : NaN;
+      if (!Number.isNaN(t)) {
+        scan.lastAssistantTs = t;
+        const days = scan.days || (scan.days = {});
+        const day = days[dayKey(t)] || (days[dayKey(t)] = {});
+        addUsage(day, model, m.usage);
+      }
+    } catch {
+      /* ignore */
+    }
+  } else if (scan.lastAssistantTs && line.includes('"type":"user"') && !line.includes('"tool_use_id"')) {
+    // Your next real prompt after assistant output: bucket the gap.
+    // <5s is automation, >30min you were away — neither says anything
+    // about response time, but both consume the pending assistant mark.
+    try {
+      const rec = JSON.parse(line);
+      if (!extractUserText(rec)) return;
+      const t = rec.timestamp ? Date.parse(rec.timestamp) : NaN;
+      if (Number.isNaN(t)) return;
+      const gap = t - scan.lastAssistantTs;
+      scan.lastAssistantTs = null;
+      if (gap < 5000 || gap > 30 * 60000) return;
+      const waits = scan.waits || (scan.waits = [0, 0, 0, 0]);
+      waits[gap < 30000 ? 0 : gap < 120000 ? 1 : gap < 600000 ? 2 : 3]++;
+    } catch {
+      /* ignore */
+    }
+  }
+}
+
+function addUsage(byModel, model, usage) {
+  const u = byModel[model] || (byModel[model] = { input: 0, output: 0, cacheRead: 0, cacheCreation: 0 });
+  u.input += usage.input_tokens || 0;
+  u.output += usage.output_tokens || 0;
+  u.cacheRead += usage.cache_read_input_tokens || 0;
+  u.cacheCreation += usage.cache_creation_input_tokens || 0;
+}
+
+// Local-time day bucket key, e.g. '2026-08-10'.
+function dayKey(ms) {
+  const d = new Date(ms);
+  const p = (n) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
+}
+
+function extractUserText(rec) {
+  if (rec.type !== 'user' || !rec.message) return null;
+  const c = rec.message.content;
+  if (typeof c === 'string') return cleanPrompt(c);
+  if (Array.isArray(c)) {
+    for (const part of c) {
+      if (part && part.type === 'text' && part.text) return cleanPrompt(part.text);
+    }
+  }
+  return null;
+}
+
+const NOISE_PREFIXES = [
+  '[SYSTEM NOTIFICATION',
+  'Base directory for this skill',
+  'Caveat: The messages below',
+  'This session is being continued from',
+];
+
+function cleanPrompt(s) {
+  const t = s.trim();
+  // Anything tag-shaped is harness plumbing (<system-reminder>, <command-*>,
+  // <local-command-caveat>, <task-notification>, ...), not a human prompt.
+  if (!t || t.startsWith('<') || NOISE_PREFIXES.some((p) => t.startsWith(p))) return null;
+  return t.replace(/\s+/g, ' ');
+}
+
+// Subagent transcripts live beside the main file; their tokens are real
+// spend too. Same incremental scan, usage only.
+const subCache = new Map(); // absPath -> { mtimeMs, size, scan }
+
+async function scanSubagents(dir) {
+  let files;
+  try {
+    files = await fsp.readdir(dir);
+  } catch {
+    return null;
+  }
+  const total = {};
+  const totalDays = {};
+  let count = 0;
+  for (const f of files) {
+    if (!f.endsWith('.jsonl')) continue;
+    count++;
+    const abs = path.join(dir, f);
+    try {
+      const st = await fsp.stat(abs);
+      let entry = subCache.get(abs);
+      if (!entry || entry.mtimeMs !== st.mtimeMs || entry.size !== st.size) {
+        const scan = entry && entry.scan && st.size >= entry.scan.offset
+          ? entry.scan
+          : { offset: 0, aiTitle: null, usage: {}, days: {}, lastMsgId: null };
+        await incrementalScan(abs, st.size, scan);
+        entry = { mtimeMs: st.mtimeMs, size: st.size, scan };
+        subCache.set(abs, entry);
+      }
+      mergeUsage(total, entry.scan.usage);
+      mergeDays(totalDays, entry.scan.days);
+    } catch {
+      /* skip */
+    }
+  }
+  return count ? { usage: total, days: totalDays, count } : null;
+}
+
+// Compact live-board summary; tokens rounded to 0.1M so the state
+// fingerprint stays stable between scans.
+function subagentSummary(meta) {
+  if (!meta.subagentCount) return null;
+  return {
+    count: meta.subagentCount,
+    mtok: Math.round(totalTokens(meta.subagentUsage) / 100000) / 10,
+  };
+}
+
+function mergeUsage(target, src) {
+  for (const [model, u] of Object.entries(src || {})) {
+    const t = target[model] || (target[model] = { input: 0, output: 0, cacheRead: 0, cacheCreation: 0 });
+    t.input += u.input || 0;
+    t.output += u.output || 0;
+    t.cacheRead += u.cacheRead || 0;
+    t.cacheCreation += u.cacheCreation || 0;
+  }
+  return target;
+}
+
+// Main-loop usage plus subagent usage, merged.
+function combinedUsage(meta) {
+  if (!meta.subagentUsage) return meta.usage || {};
+  return mergeUsage(mergeUsage({}, meta.usage), meta.subagentUsage);
+}
+
+function mergeDays(target, src) {
+  for (const [day, byModel] of Object.entries(src || {})) {
+    target[day] = mergeUsage(target[day] || {}, byModel);
+  }
+  return target;
+}
+
+// Main-loop day buckets plus subagent day buckets, merged.
+function combinedDays(meta) {
+  if (!meta.subagentDays) return meta.days || {};
+  return mergeDays(mergeDays({}, meta.days), meta.subagentDays);
+}
+
+// Sum per-session day buckets into a chartable series: one entry per local
+// day for the trailing numDays window ending today, zero-filled.
+function dailyCostSeries(daysList, numDays, today = Date.now()) {
+  const merged = {};
+  for (const d of daysList) mergeDays(merged, d);
+  const now = new Date(today);
+  const series = [];
+  for (let i = numDays - 1; i >= 0; i--) {
+    const d = new Date(now.getFullYear(), now.getMonth(), now.getDate() - i);
+    const usage = merged[dayKey(d.getTime())] || {};
+    series.push({
+      t: d.getTime(),
+      cost: Math.round(estimateCost(usage) * 100) / 100,
+      tokens: totalTokens(usage),
+    });
+  }
+  return series;
+}
+
+// Best display title for a session, with its provenance.
+function sessionTitle(meta) {
+  if (meta.aiTitle) return { title: meta.aiTitle, source: 'ai-title' };
+  if (meta.firstUserPrompt) return { title: meta.firstUserPrompt, source: 'first-prompt' };
+  if (meta.lastPrompt) return { title: meta.lastPrompt, source: 'last-prompt' };
+  return { title: meta.sessionId.slice(0, 8), source: 'session-id' };
+}
+
+// Group scanned sessions by canonical project root (worktrees fold in).
+function groupByProject(sessions) {
+  const byProject = new Map(); // lowercase root -> { path, sessions: [] }
+  for (const meta of sessions) {
+    if (!meta.cwd) continue; // can't place it without a real path
+    const { root, worktree } = worktreeRoot(meta.cwd);
+    const key = root.toLowerCase();
+    let e = byProject.get(key);
+    if (!e) {
+      e = { path: root, sessions: [] };
+      byProject.set(key, e);
+    }
+    e.sessions.push({ ...meta, worktree, projectPath: root });
+  }
+  for (const e of byProject.values()) {
+    e.sessions.sort((a, b) => b.lastActivityAt - a.lastActivityAt);
+  }
+  return byProject;
+}
+
+module.exports = {
+  scanAllTranscripts, groupByProject, sessionTitle, combinedUsage, mergeUsage,
+  scanLine, mergeDays, combinedDays, dailyCostSeries, subagentSummary, dayKey,
+};

package/lib/usage.js

@@ -0,0 +1,116 @@
+'use strict';
+// Usage meters via Anthropic's OAuth usage endpoint, authenticated with the
+// same Keychain credentials Claude Code itself uses. The token lives in
+// memory only — never written, never logged. macOS only (Keychain); other
+// platforms fall back to the statusline cache in quota.js.
+//
+// This is the dashboard's one automatic network call, to Anthropic only,
+// for the account's own usage numbers. Toggle: config.usageApi.
+const { execFile } = require('child_process');
+const { readConfig } = require('./config');
+
+const ENDPOINT = 'https://api.anthropic.com/api/oauth/usage';
+const FETCH_TTL_MS = 5 * 60 * 1000; // be polite: at most one call per 5 min
+
+let tokenCache = { token: null, expiresAt: 0 };
+let usageCache = { at: 0, quota: null };
+
+function readKeychainToken() {
+  return new Promise((resolve) => {
+    execFile(
+      'security',
+      ['find-generic-password', '-s', 'Claude Code-credentials', '-w'],
+      { timeout: 5000 },
+      (err, stdout) => {
+        if (err) return resolve(null);
+        try {
+          const oauth = JSON.parse(stdout).claudeAiOauth;
+          if (oauth && oauth.accessToken) {
+            resolve({ token: oauth.accessToken, expiresAt: oauth.expiresAt || 0 });
+            return;
+          }
+        } catch { /* fall through */ }
+        resolve(null);
+      }
+    );
+  });
+}
+
+async function getToken(forceReread) {
+  const now = Date.now();
+  // Claude Code refreshes the Keychain item as it runs; re-read when ours
+  // is missing, near expiry, or a request just got a 401.
+  if (forceReread || !tokenCache.token || now > tokenCache.expiresAt - 60_000) {
+    const fresh = await readKeychainToken();
+    if (fresh) tokenCache = fresh;
+    else if (forceReread) tokenCache = { token: null, expiresAt: 0 };
+  }
+  return tokenCache.token;
+}
+
+function normalize(body) {
+  const five = body.five_hour || {};
+  const week = body.seven_day || {};
+  const extra = body.extra_usage || {};
+  const scale = Math.pow(10, extra.decimal_places ?? 2);
+  return {
+    utilization: typeof five.utilization === 'number' ? five.utilization : null,
+    weeklyUtilization: typeof week.utilization === 'number' ? week.utilization : null,
+    resetsAt: five.resets_at || null,
+    weeklyResetsAt: week.resets_at || null,
+    costUsed: typeof extra.used_credits === 'number' ? extra.used_credits / scale : null,
+    costLimit: typeof extra.monthly_limit === 'number' ? extra.monthly_limit / scale : null,
+    currency: extra.currency || 'USD',
+    extraUsageEnabled: extra.is_enabled === true,
+    stale: false,
+    source: 'api',
+  };
+}
+
+async function requestUsage(token) {
+  const r = await fetch(ENDPOINT, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'anthropic-beta': 'oauth-2025-04-20',
+      'User-Agent': 'claude-dashboard',
+    },
+  });
+  if (!r.ok) {
+    const e = new Error(`usage endpoint ${r.status}`);
+    e.status = r.status;
+    throw e;
+  }
+  return normalize(await r.json());
+}
+
+// Returns a quota object, or null (caller falls back to the file cache).
+async function fetchOauthUsage() {
+  if (process.platform !== 'darwin') return null;
+  if (readConfig().usageApi === false) return null;
+  const now = Date.now();
+  if (usageCache.quota && now - usageCache.at < FETCH_TTL_MS) return usageCache.quota;
+
+  try {
+    let token = await getToken(false);
+    if (!token) return null;
+    let quota;
+    try {
+      quota = await requestUsage(token);
+    } catch (e) {
+      if (e.status !== 401) throw e;
+      token = await getToken(true); // stale token — re-read Keychain once
+      if (!token) return null;
+      quota = await requestUsage(token);
+    }
+    usageCache = { at: now, quota };
+    return quota;
+  } catch {
+    // Keep serving the last good numbers briefly; mark stale past the TTL.
+    if (usageCache.quota && now - usageCache.at < 3 * FETCH_TTL_MS) {
+      return { ...usageCache.quota, stale: true };
+    }
+    return null;
+  }
+}
+
+module.exports = { fetchOauthUsage };

package/menubar/claude-dash.15s.sh

@@ -0,0 +1,82 @@
+#!/bin/bash
+# SwiftBar plugin for the Claude Dashboard. Refreshes every 15s (filename).
+# <swiftbar.title>Claude Dashboard</swiftbar.title>
+# <swiftbar.hideAbout>true</swiftbar.hideAbout>
+# <swiftbar.hideRunInTerminal>true</swiftbar.hideRunInTerminal>
+# <swiftbar.hideDisablePlugin>true</swiftbar.hideDisablePlugin>
+
+PORT="${CLAUDE_DASH_PORT:-4517}"
+STATE=$(curl -sf --max-time 3 "http://127.0.0.1:$PORT/api/state" 2>/dev/null)
+
+if [ -z "$STATE" ]; then
+  echo "❯ · | color=gray"
+  echo "---"
+  echo "Dashboard server offline"
+  echo "Open dashboard | href=http://127.0.0.1:$PORT"
+  exit 0
+fi
+
+echo "$STATE" | /usr/bin/python3 -c '
+import json, sys, time
+
+s = json.load(sys.stdin)
+live = s.get("liveSessions", [])
+projects = s.get("projects", [])
+waiting = [l for l in live if l.get("status") == "waiting"]
+quiet = [l for l in live if l.get("quietMin")]
+
+# Menu bar title: attention states change the glyph so it reads at a glance.
+if waiting:
+    print(f"❯ {len(waiting)}⚠ | color=#e0a63a")
+elif quiet:
+    print(f"❯ {len(live)}?")
+elif live:
+    print(f"❯ {len(live)}")
+else:
+    print("❯ | color=gray")
+
+print("---")
+
+def elapsed(ms):
+    if not ms: return ""
+    m = int((time.time() * 1000 - ms) / 60000)
+    return f"{m//60}h {m%60}m" if m >= 60 else f"{m}m"
+
+if live:
+    for l in live:
+        name = l.get("projectName", "?")
+        if l.get("status") == "waiting":
+            what = l.get("waitingFor") or "waiting"
+            print(f"{name} — {what} | color=#e0a63a")
+        elif l.get("quietMin"):
+            qm = l.get("quietMin")
+            print(f"{name} — busy, quiet {qm}m | color=#e0a63a")
+        else:
+            task = (l.get("currentTask") or {}).get("activeForm") or "busy"
+            age = elapsed(l.get("startedAt"))
+            print(f"{name} — {task} ({age})")
+else:
+    print("No sessions running | color=gray")
+
+attn = []
+for p in projects:
+    g = p.get("git") or {}
+    if not g.get("isRepo"): continue
+    changes = (g.get("dirty") or 0) + (g.get("untracked") or 0)
+    ahead = g.get("ahead") or 0
+    if changes or ahead:
+        bits = (f"●{changes}" if changes else "") + (f" ↑{ahead}" if ahead else "")
+        pname = p.get("name")
+        attn.append(f"{pname} {bits.strip()}")
+if attn:
+    print("---")
+    print(f"Unpushed work — {len(attn)} repos | color=gray")
+    for a in attn[:8]:
+        print(a)
+
+spend = sum(p.get("spend7d") or 0 for p in projects)
+print("---")
+if spend >= 0.005:
+    print(f"7d est. value ≈${spend:.0f} | color=gray")
+print("Open dashboard | href=http://127.0.0.1:'"$PORT"'")
+'