claude-mission-control 1.5.0 → 1.8.0

package/README.md

@@ -14,7 +14,7 @@ Everything is read from local files under `~/.claude`, and it never writes to Cl
 npx claude-mission-control
 ```
 
-That downloads nothing permanent, starts the server, and prints the URL. Like it? Install it for real below.
+That downloads nothing permanent, starts the server, and opens the dashboard in your browser (add `--no-open` to skip that). Run it again while it's already up and it just opens the tab. Like it? Install it for real below.
 
 Homebrew works too:
 
@@ -87,6 +87,7 @@ If something looks off, the log is at `~/Library/Logs/claude-dashboard.log`. To
 - **New session** — the `⊕` button on a project card opens a fresh terminal window in that project running `claude`.
 - **Cost trend** — the small bar chart in the header is estimated cost per week for the last 8 weeks (hover for numbers). Costs include subagent tokens.
 - **Models everywhere** — every session shows which model ran it (live cards, digest, session lists), and the stats view breaks down usage per model and per project.
+- **Claude.ai chats** — import the official export from claude.ai (Settings → Privacy → Export data, then feed `conversations.json` to ⚙ settings here) and your chats become browsable (`⌘K` → Claude.ai chats) and full-text searchable next to your coding sessions. Stored slimmed in your local config dir, gitignored, never uploaded anywhere.
 
 ![Stats view: activity heatmap, busiest hours, weekly rhythm, 90-day spend, and per-model cost breakdowns](docs/screenshots/stats.png)
 - **Project details** — click any project's name for a slide-over with its full session list, rendered CLAUDE.md, per-project memory files, skills/agents/commands from `.claude/`, and settings (permissions, MCP servers, allowed tools). Read-only; also a quick audit of which projects are missing instructions or memory. Esc closes.
@@ -112,6 +113,8 @@ The ⚙ gear in the header opens settings — no JSON editing required:
 - **Notifications** on/off (writes `config.json`); per-project mute lives on each project's slide-over
 - **Terminal** for open/new-session buttons: Ghostty, iTerm2, or Terminal.app, auto-detected (`config.json`)
 - **Rename any project** (writes `names.json`) or **hide it** and its whole subtree (writes `ignore.json`), with an unhide list below
+- **Theme**: Departures board (follows system light/dark), Phosphor, Amber CRT, Midnight, or Newsprint (`config.json`)
+- **Updates**: "check for updates" asks GitHub only when you click; when a new release is out, **update now** pulls it in place (git or npm installs) and service installs restart themselves on the new version
 
 Everything saves instantly; the underlying files stay hand-editable. Keyboard: `⌘K` for the palette, `/` for search, `Esc` closes anything.
 
@@ -141,6 +144,8 @@ Edit `ignore.json` — an array of absolute path prefixes. A project is hidden i
 | `CLAUDE_DASH_DEV` | unset | `1` = re-read index.html on every request |
 | `CLAUDE_DASH_NOTIFY` | unset | `0` = disable macOS notifications |
 | `CLAUDE_DASH_HOST` | `127.0.0.1` | Bind address — see below before changing |
+| `CLAUDE_DASH_DEMO` | unset | `1` = serve believable fake data (screenshots, trying it without Claude history) |
+| `CLAUDE_DASH_CONFIG_DIR` | repo dir | Where config.json/names.json/ignore.json live (auto-falls back to `~/.config/claude-dashboard`) |
 
 The server binds to `127.0.0.1` only by default.
 

package/bin/claude-dashboard.js

@@ -1,5 +1,8 @@
 #!/usr/bin/env node
 'use strict';
-// npx claude-dashboard / global install entry point. The server starts on
-// require and prints its URL.
+// npx claude-mission-control / global install entry point.
+// Starts the server and opens the dashboard in the default browser.
+// Pass --no-open to skip the browser (services use `node server.js` directly
+// and never auto-open).
+if (!process.argv.includes('--no-open')) process.env.CLAUDE_DASH_OPEN = '1';
 require('../server.js');

package/claude-dashboard.service

@@ -4,7 +4,8 @@ After=default.target
 
 [Service]
 ExecStart=__NODE_PATH__ __APP_DIR__/server.js
-Restart=on-failure
+Environment=CLAUDE_DASH_SERVICE=1
+Restart=always
 RestartSec=3
 
 [Install]

package/com.claude-dashboard.plist

@@ -14,5 +14,6 @@
   <key>StandardErrorPath</key><string>__HOME__/Library/Logs/claude-dashboard.log</string>
   <key>EnvironmentVariables</key><dict>
     <key>CLAUDE_DASH_PORT</key><string>4517</string>
+    <key>CLAUDE_DASH_SERVICE</key><string>1</string>
   </dict>
 </dict></plist>

package/lib/chats.js

@@ -0,0 +1,103 @@
+'use strict';
+// Claude.ai chats, imported from the official data export
+// (claude.ai → Settings → Privacy → Export data → conversations.json).
+// Stored normalized and slimmed in the config dir as chats.json —
+// read-only afterwards, refreshed by mtime like every other user file.
+const fs = require('fs');
+const path = require('path');
+const { configDir } = require('./config');
+
+const CHATS_FILE = path.join(configDir(), 'chats.json');
+
+// The export replaces artifacts/rich blocks with this placeholder — drop it.
+const PLACEHOLDER = /^This block is not supported on your current device yet\.?$/;
+
+function msgText(m) {
+  if (m.text && m.text.trim()) return m.text.trim();
+  const parts = (m.content || [])
+    .filter((p) => p && p.type === 'text' && p.text && p.text.trim() && !PLACEHOLDER.test(p.text.trim()))
+    .map((p) => p.text.trim());
+  return parts.join('\n\n');
+}
+
+// Raw export array -> slim [{id, name, createdAt, updatedAt, count, messages}]
+function normalizeChats(raw) {
+  const out = [];
+  for (const c of Array.isArray(raw) ? raw : []) {
+    const messages = (c.chat_messages || [])
+      .map((m) => ({
+        who: m.sender === 'human' ? 'you' : 'claude',
+        text: msgText(m),
+        ts: m.created_at ? Date.parse(m.created_at) || null : null,
+      }))
+      .filter((m) => m.text);
+    if (!messages.length) continue;
+    const name = (c.name || '').trim() || messages[0].text.slice(0, 80);
+    out.push({
+      id: c.uuid,
+      name,
+      createdAt: Date.parse(c.created_at) || null,
+      updatedAt: Date.parse(c.updated_at) || Date.parse(c.created_at) || 0,
+      count: messages.length,
+      messages,
+    });
+  }
+  out.sort((a, b) => b.updatedAt - a.updatedAt);
+  return out;
+}
+
+const MAX_RESULTS = 40;
+function searchChats(q, chats) {
+  const needle = q.toLowerCase();
+  if (!needle) return [];
+  const out = [];
+  for (const c of chats || []) {
+    if (out.length >= MAX_RESULTS) break;
+    if (c.name.toLowerCase().includes(needle)) {
+      out.push({ chatId: c.id, name: c.name, snippet: c.name, ts: c.updatedAt });
+      continue;
+    }
+    for (const m of c.messages || []) {
+      const i = m.text.toLowerCase().indexOf(needle);
+      if (i === -1) continue;
+      const start = Math.max(0, i - 60);
+      out.push({
+        chatId: c.id,
+        name: c.name,
+        snippet: (start > 0 ? '…' : '') + m.text.slice(start, i + needle.length + 140).replace(/\s+/g, ' '),
+        ts: m.ts || c.updatedAt,
+      });
+      break;
+    }
+  }
+  return out;
+}
+
+// Cached by mtime, like config.json.
+let cache = { mtimeMs: 0, chats: [] };
+function readChats() {
+  let st;
+  try {
+    st = fs.statSync(CHATS_FILE);
+  } catch {
+    return [];
+  }
+  if (st.mtimeMs !== cache.mtimeMs) {
+    try {
+      cache = { mtimeMs: st.mtimeMs, chats: JSON.parse(fs.readFileSync(CHATS_FILE, 'utf8')) };
+    } catch {
+      cache = { mtimeMs: st.mtimeMs, chats: [] };
+    }
+  }
+  return cache.chats;
+}
+
+// Normalize the raw export and persist. Returns the imported count.
+function saveChats(raw) {
+  const chats = normalizeChats(raw);
+  fs.writeFileSync(CHATS_FILE, JSON.stringify(chats));
+  cache = { mtimeMs: 0, chats: [] }; // next read picks up the new file
+  return chats.length;
+}
+
+module.exports = { normalizeChats, searchChats, readChats, saveChats };

package/lib/collector.js

@@ -35,6 +35,7 @@ class Collector {
     this.state = { generatedAt: 0, quota: null, liveSessions: [], projects: [], errors: [] };
     this.raw = { live: [], transcriptGroups: new Map(), history: new Map(), git: new Map(), quota: null };
     this.listeners = new Set();
+    this.events = []; // notification history for the catch-up bell, newest first
     this.clientCount = 0;
     this.timers = [];
     this.fingerprint = '';
@@ -100,12 +101,20 @@ class Collector {
     this.notifyTransitions(live);
   }
 
+  // Everything notification-worthy lands here too, muted or not — the bell
+  // is how you catch up on what the toasts said while you were away.
+  logEvent(kind, project, body) {
+    this.events.unshift({ at: Date.now(), kind, project, body: String(body).slice(0, 200) });
+    if (this.events.length > 50) this.events.length = 50;
+  }
+
   notifyTransitions(live) {
     const next = new Map(live.map((s) => [s.sessionId, s.status]));
     const prev = this.prevLiveStatus ?? null;
     for (const id of newlyWaiting(prev, next)) {
       const s = live.find((x) => x.sessionId === id);
       const root = worktreeRoot(s.cwd).root;
+      this.logEvent('needs you', friendlyName(root), s.waitingFor || 'Claude was waiting for your input');
       if (isProjectMuted(root, readConfig().mutedProjects)) continue;
       const project = friendlyName(root);
       sendNotification({
@@ -256,6 +265,7 @@ class Collector {
           if (q >= QUIET_FLAG_MS) quietMin = Math.floor(q / 60000);
           if (q >= QUIET_NOTIFY_MS && !this.stuckNotified.has(s.sessionId)) {
             this.stuckNotified.add(s.sessionId);
+            this.logEvent('stuck', friendlyName(root), `Busy with no output for ${quietMin} minutes`);
             if (!isProjectMuted(root, readConfig().mutedProjects)) sendNotification({
               title: `${friendlyName(root)} may be stuck`,
               body: `Busy with no output for ${quietMin} minutes — worth a look.`,
@@ -330,6 +340,7 @@ class Collector {
     const level = budgetLevel(weeklyCost[7], budgetLimit);
     if (level > (this.budgetAlerted || 0)) {
       this.budgetAlerted = level;
+      this.logEvent('budget', 'Weekly budget', `${level >= 100 ? 'Over' : `${level}% of`} your $${budgetLimit} budget (≈$${weeklyCost[7].toFixed(0)})`);
       sendNotification({
         title: 'Claude weekly budget',
         body: `7-day estimated spend ≈$${weeklyCost[7].toFixed(0)} — ${level >= 100 ? 'over' : `${level}% of`} your $${budgetLimit} budget.`,
@@ -340,7 +351,7 @@ class Collector {
     }
     const budget = budgetLimit ? { limit: budgetLimit, spent: weeklyCost[7], level } : null;
 
-    const next = { quota: this.raw.quota, plan: readPlan(), liveSessions, projects, weeklyCost, budget, pinned, errors: this.state.errors.slice(-5) };
+    const next = { quota: this.raw.quota, plan: readPlan(), theme: readConfig().theme || 'board', liveSessions, projects, weeklyCost, budget, pinned, events: this.events.slice(0, 50), errors: this.state.errors.slice(-5) };
     const fp = JSON.stringify(next);
     if (fp !== this.fingerprint) {
       this.fingerprint = fp;
@@ -411,6 +422,8 @@ class Collector {
     const sessionDays = [];
     let sessionTotal = 0;
     let costTotal = 0;
+    const dayCut = Date.now() - 24 * 3600000;
+    const timeline = [];
     const weekDayKey = dayKey(weekCut);
     let weekSessions = 0;
     let weekCost = 0;
@@ -424,6 +437,15 @@ class Collector {
       for (const m of g.sessions) {
         const mDays = combinedDays(m);
         sessionDays.push(mDays);
+        if (m.lastActivityAt >= dayCut) {
+          timeline.push({
+            project: friendlyName(g.path),
+            sessionId: m.sessionId,
+            title: sessionTitle(m).title,
+            start: Math.max(m.startedAt || m.lastActivityAt, dayCut),
+            end: m.lastActivityAt,
+          });
+        }
         if (m.lastActivityAt >= weekCut) {
           weekSessions++;
           if (m.waits) for (let i = 0; i < 4; i++) weekWaits[i] += m.waits[i];
@@ -458,6 +480,7 @@ class Collector {
       hours,
       heat: weekHourHeat(allTimestamps),
       costDays: dailyCostSeries(sessionDays, 90),
+      timeline,
       week: {
         sessions: weekSessions,
         prompts: weekPrompts,

package/lib/config.js

@@ -33,7 +33,18 @@ const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 const NAMES_FILE = path.join(CONFIG_DIR, 'names.json');
 const IGNORE_FILE = path.join(CONFIG_DIR, 'ignore.json');
 
-const DEFAULTS = { terminal: 'ghostty', notifications: true, usageApi: true, mutedProjects: [], weeklyBudget: 0, pinnedSessions: [] };
+const DEFAULTS = { terminal: 'ghostty', notifications: true, usageApi: true, mutedProjects: [], weeklyBudget: 0, pinnedSessions: [], theme: 'board' };
+
+// The one theme list: updateConfig validates against it and GET /api/config
+// serves it, so the settings dropdown can never offer a value the server
+// would drop. Adding a theme = one entry here + its CSS block in index.html.
+const THEMES = [
+  { id: 'board', label: 'Departures board' },
+  { id: 'phosphor', label: 'Phosphor' },
+  { id: 'amber', label: 'Amber CRT' },
+  { id: 'midnight', label: 'Midnight' },
+  { id: 'newsprint', label: 'Newsprint' },
+];
 
 function readJson(file, fallback) {
   try {
@@ -59,6 +70,7 @@ function updateConfig(patch) {
   if (typeof patch.weeklyBudget === 'number' && patch.weeklyBudget >= 0 && Number.isFinite(patch.weeklyBudget)) {
     next.weeklyBudget = Math.round(patch.weeklyBudget);
   }
+  if (THEMES.some((t) => t.id === patch.theme)) next.theme = patch.theme;
   writeJson(CONFIG_FILE, next);
   return next;
 }
@@ -187,7 +199,9 @@ function resolvedTerminal() {
 }
 
 module.exports = {
+  THEMES,
   readConfig,
+  configDir: () => CONFIG_DIR,
   findOnPath,
   detectClaudeApp,
   resolvedTerminal,

package/lib/demo.js

@@ -0,0 +1,148 @@
+'use strict';
+// CLAUDE_DASH_DEMO=1: serve believable fake data instead of reading ~/.claude.
+// For screenshots, demos, and trying the dashboard without any Claude history.
+// Times are computed relative to now on every call so the board looks alive.
+
+const MIN = 60000;
+const HOUR = 3600000;
+const DAY = 24 * HOUR;
+
+const S1 = 'demo1111-1111-4111-8111-111111111111';
+const S2 = 'demo2222-2222-4222-8222-222222222222';
+const S3 = 'demo3333-3333-4333-8333-333333333333';
+
+function demoState() {
+  const now = Date.now();
+  const mk = (name, path, ago, git, spark, spend) => ({
+    path,
+    name,
+    lastActivityAt: now - ago,
+    isLive: ago < 5 * MIN,
+    git,
+    spend7d: spend,
+    activity: { counts: spark },
+    sessions: [],
+  });
+  return {
+    generatedAt: now,
+    plan: { tier: 'Max 20x' },
+    quota: { utilization: 34, weeklyUtilization: 52, resetsAt: '2pm', weeklyResetsAt: 'Wed 9am' },
+    weeklyCost: [31, 48, 22, 75, 61, 90, 84, 143],
+    budget: { limit: 200, spent: 143, level: 75 },
+    pinned: [
+      { sessionId: S3, title: 'Design the onboarding flow', projectName: 'Acme Storefront', model: 'claude-opus-5', lastActivityAt: now - 3 * HOUR },
+    ],
+    events: [
+      { at: now - 4 * MIN, kind: 'needs you', project: 'Acme Storefront', body: 'Which payment provider should checkout use?' },
+      { at: now - 38 * MIN, kind: 'stuck', project: 'Data Pipeline', body: 'Busy with no output for 20 minutes' },
+      { at: now - 2 * HOUR, kind: 'budget', project: 'Weekly budget', body: '75% of your $200 budget (≈$143)' },
+    ],
+    liveSessions: [
+      {
+        sessionId: S1, pid: 1111, cwd: '/demo/acme-storefront', projectPath: '/demo/acme-storefront',
+        projectName: 'Acme Storefront', isWorktree: false, model: 'claude-opus-5',
+        title: 'Wire Stripe checkout into the cart', status: 'waiting',
+        waitingFor: 'Which payment provider should checkout use?',
+        startedAt: now - 47 * MIN, statusUpdatedAt: now - 4 * MIN, quietMin: null,
+        currentTask: null, tasksSummary: null, subagents: null, resumeCommand: 'claude --resume demo',
+      },
+      {
+        sessionId: S2, pid: 2222, cwd: '/demo/blog-engine', projectPath: '/demo/blog-engine',
+        projectName: 'Blog Engine', isWorktree: false, model: 'claude-fable-5',
+        title: 'Migrate posts to the new block format', status: 'busy',
+        waitingFor: null, startedAt: now - 3 * HOUR - 12 * MIN, statusUpdatedAt: now - MIN, quietMin: null,
+        currentTask: { activeForm: 'Converting legacy shortcodes' },
+        tasksSummary: { completed: 7, inProgress: 1, pending: 3 },
+        subagents: { count: 4, mtok: 2.3 }, resumeCommand: 'claude --resume demo',
+      },
+    ],
+    projects: [
+      mk('Acme Storefront', '/demo/acme-storefront', 2 * MIN,
+        { isRepo: true, branch: 'feature/checkout', dirty: 4, untracked: 1, ahead: 2, behind: 0 },
+        [2, 5, 3, 8, 6, 9, 4, 7, 11, 6, 8, 12, 9, 14], 89.4),
+      mk('Blog Engine', '/demo/blog-engine', 1 * MIN,
+        { isRepo: true, branch: 'main', dirty: 0, untracked: 0, ahead: 0, behind: 0 },
+        [0, 3, 1, 4, 2, 6, 3, 5, 2, 7, 4, 6, 8, 5], 31.7),
+      mk('Data Pipeline', '/demo/data-pipeline', 5 * HOUR,
+        { isRepo: true, branch: 'main', dirty: 2, untracked: 0, ahead: 1, behind: 0 },
+        [1, 0, 2, 1, 3, 0, 2, 4, 1, 3, 2, 0, 5, 2], 18.2),
+      mk('Dotfiles', '/demo/dotfiles', 3 * DAY,
+        { isRepo: true, branch: 'main', dirty: 0, untracked: 0, ahead: 0, behind: 0 },
+        [0, 0, 1, 0, 0, 2, 0, 1, 0, 0, 1, 0, 0, 1], 2.1),
+    ],
+    errors: [],
+  };
+}
+
+function demoStats() {
+  const now = Date.now();
+  const days = [];
+  const costDays = [];
+  for (let i = 181; i >= 0; i--) {
+    const t = now - i * DAY;
+    const c = Math.max(0, Math.round(6 + 6 * Math.sin(i / 3) + (i % 7 === 0 ? -6 : 0)));
+    days.push({ t, c });
+  }
+  for (let i = 89; i >= 0; i--) {
+    const t = now - i * DAY;
+    const cost = Math.max(0, Math.round((12 + 10 * Math.sin(i / 4)) * 100) / 100);
+    costDays.push({ t, cost, tokens: Math.round(cost * 800000) });
+  }
+  const hours = [0, 0, 0, 0, 0, 0, 1, 3, 8, 14, 18, 22, 19, 16, 20, 17, 12, 9, 6, 4, 3, 2, 1, 0];
+  const heat = Array.from({ length: 7 }, (_, d) =>
+    hours.map((h) => Math.max(0, Math.round(h * (d === 0 || d === 6 ? 0.3 : 1) * (0.7 + (d % 3) * 0.2)))));
+  return {
+    days,
+    hours,
+    heat,
+    costDays,
+    timeline: [
+      { project: 'Acme Storefront', sessionId: S1, title: 'Wire Stripe checkout into the cart', start: now - 47 * MIN, end: now },
+      { project: 'Blog Engine', sessionId: S2, title: 'Migrate posts to the new block format', start: now - 3 * HOUR, end: now },
+      { project: 'Data Pipeline', sessionId: S3, title: 'Backfill the analytics warehouse', start: now - 9 * HOUR, end: now - 5 * HOUR },
+    ],
+    week: {
+      sessions: 18, prompts: 84, cost: 143.2,
+      projects: [
+        { name: 'Acme Storefront', cost: 89.4 },
+        { name: 'Blog Engine', cost: 31.7 },
+        { name: 'Data Pipeline', cost: 18.2 },
+      ],
+      models: ['claude-opus-5', 'claude-fable-5', 'claude-haiku-4-5'],
+      busiestDay: 'Tuesday', busiestHour: 11,
+      waits: [22, 31, 18, 4], typicalWait: 'under 2m',
+    },
+    byModel: {
+      'claude-opus-5': { tokens: 310e6, cost: 412.5 },
+      'claude-fable-5': { tokens: 120e6, cost: 388.1 },
+      'claude-haiku-4-5': { tokens: 42e6, cost: 9.8 },
+    },
+    perProject: [
+      { name: 'Acme Storefront', total: 501.3, models: { 'claude-opus-5': 402.2, 'claude-fable-5': 99.1 } },
+      { name: 'Blog Engine', total: 214.6, models: { 'claude-fable-5': 214.6 } },
+    ],
+    totals: { sessions: 212, prompts: 1841, cost: 810.4 },
+  };
+}
+
+function demoSession() {
+  const now = Date.now();
+  return {
+    sessionId: S1,
+    title: 'Wire Stripe checkout into the cart',
+    projectName: 'Acme Storefront',
+    truncatedTurns: 0,
+    nextOffset: 0,
+    events: [
+      { kind: 'user', ts: now - 47 * MIN, text: 'Add Stripe checkout to the cart page. Keep the guest flow working.' },
+      { kind: 'assistant', ts: now - 46 * MIN, text: "I'll start with the payment intent endpoint, then wire the cart button to it." },
+      { kind: 'tool', ts: now - 45 * MIN, name: 'Read', input: 'src/cart/CartPage.tsx' },
+      { kind: 'tool', ts: now - 44 * MIN, name: 'Edit', input: 'src/api/checkout.ts' },
+      { kind: 'assistant', ts: now - 40 * MIN, text: 'Endpoint is in with tests. The cart button now creates a payment intent and redirects.' },
+      { kind: 'user', ts: now - 12 * MIN, text: 'Nice. What about Apple Pay?' },
+      { kind: 'assistant', ts: now - 5 * MIN, text: 'Two options: Stripe Payment Request Button (fastest) or a native integration. Which payment provider should checkout use for the wallet flow?' },
+    ],
+  };
+}
+
+module.exports = { demoState, demoStats, demoSession };

package/lib/gitlog.js

@@ -0,0 +1,58 @@
+'use strict';
+// Recent commits for the project drawer — read-only `git log`, execFile
+// arg arrays only (paths contain spaces).
+const { execFile } = require('child_process');
+
+// %x1e opens each record, %x1f separates fields:
+// sha, committer epoch, subject, author, Co-Authored-By trailer values.
+const FMT = '%x1e%h%x1f%ct%x1f%s%x1f%an%x1f%(trailers:key=Co-Authored-By,valueonly,separator=%x20)';
+
+function parseGitLog(raw) {
+  const out = [];
+  for (const rec of String(raw).split('\x1e')) {
+    if (!rec.trim()) continue;
+    const nl = rec.indexOf('\n');
+    const head = nl === -1 ? rec : rec.slice(0, nl);
+    const rest = nl === -1 ? '' : rec.slice(nl + 1);
+    const [sha, ct, subject, author, coauthors] = head.split('\x1f');
+    if (!sha) continue;
+    const statLine = rest
+      .split('\n')
+      .map((l) => l.trim())
+      .find((l) => /files? changed/.test(l));
+    out.push({
+      sha,
+      ts: (Number(ct) || 0) * 1000,
+      subject: subject || '',
+      author: author || '',
+      claude: /claude/i.test(coauthors || ''),
+      stat: statLine || null,
+    });
+  }
+  return out;
+}
+
+// A Claude commit made while a session was active in the same repo probably
+// came from that session — honest heuristic, windows padded 5 minutes.
+const PAD = 5 * 60000;
+function linkCommitsToSessions(commits, sessions) {
+  return commits.map((c) => {
+    const s = (sessions || []).find(
+      (x) => c.ts >= ((x.startedAt || x.lastActivityAt) - PAD) && c.ts <= (x.lastActivityAt + PAD)
+    );
+    return s ? { ...c, sessionId: s.sessionId, sessionTitle: s.title } : c;
+  });
+}
+
+function recentCommits(projectPath, limit = 30) {
+  return new Promise((resolve) => {
+    execFile(
+      'git',
+      ['-C', projectPath, 'log', `--format=${FMT}`, '--shortstat', '-n', String(limit)],
+      { timeout: 8000, maxBuffer: 1024 * 1024 },
+      (err, stdout) => resolve(err ? [] : parseGitLog(stdout))
+    );
+  });
+}
+
+module.exports = { parseGitLog, linkCommitsToSessions, recentCommits };

package/lib/update.js

@@ -0,0 +1,110 @@
+'use strict';
+// Self-update: figure out how this copy of the dashboard was installed, and
+// run the matching update command. The server never takes a path or command
+// from the client — everything derives from the app's own location.
+
+const fs = require('fs');
+const path = require('path');
+const { execFile } = require('child_process');
+const { canonicalize } = require('./paths');
+
+const PKG_NAME = require('../package.json').name;
+
+// Pure: appDir + "does .git exist there" -> 'git' | 'npm' | 'npx' | 'brew' | 'unknown'.
+// Location signals (brew Cellar, npx cache, non-npm package managers) win over
+// a .git dir: those are package-manager-owned trees we must never git-pull in.
+// pnpm/yarn/volta/bun globals also live under node_modules, but running
+// `npm install -g` there installs a second copy under npm's own prefix while
+// the running copy stays old — so they get manual instructions instead.
+function detectInstallKind(appDir, hasGitDir) {
+  const p = canonicalize(appDir).toLowerCase();
+  if (p.includes('/cellar/') || p.includes('/homebrew/')) return 'brew';
+  if (p.includes('/_npx/')) return 'npx';
+  if (['/pnpm/', '/yarn/', '/.yarn/', '/volta/', '/.volta/', '/.bun/'].some((sig) => p.includes(sig))) return 'unknown';
+  if (hasGitDir) return 'git';
+  if (p.includes('/node_modules/')) return 'npm';
+  return 'unknown';
+}
+
+// Pure: install kind -> either a fixed command to run, or instructions to
+// show. The command list is closed — nothing here ever comes from a request.
+function updatePlan(kind, pkgName) {
+  if (kind === 'git') return { type: 'run', cmd: 'git', args: ['pull', '--ff-only'] };
+  if (kind === 'npm') return { type: 'run', cmd: 'npm', args: ['install', '-g', `${pkgName}@latest`] };
+  if (kind === 'brew') return { type: 'manual', message: `Run: brew upgrade ${pkgName}` };
+  if (kind === 'npx') return { type: 'manual', message: `Quit the dashboard and re-run npx ${pkgName} — npx fetches the newest release each time.` };
+  return { type: 'manual', message: 'Update with the tool you installed with, or download from https://github.com/JonImmsWordpressDev/claude-dashboard/releases' };
+}
+
+// Pure: where npm's CLI JS lives relative to the node binary's directory —
+// the unix prefix layout and the Windows layout. Running it via our own
+// process.execPath sidesteps both the service manager's minimal PATH
+// (launchd/systemd ship no PATH, so bare 'npm' is ENOENT) and Windows,
+// where 'npm' is npm.cmd and can't be spawned without a shell.
+function npmCliCandidates(nodeDir) {
+  return [
+    path.join(nodeDir, '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+    path.join(nodeDir, 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+  ];
+}
+
+// launchd (KeepAlive) and systemd (Restart) relaunch us after an update exit;
+// a terminal-run process must not be killed. Signals, most reliable first:
+// our own service definitions set CLAUDE_DASH_SERVICE=1; systemd sets
+// INVOCATION_ID for every unit, which covers units deployed before that var
+// existed; ppid 1 on macOS covers launchd agents installed before it (kept
+// mac-only so an orphaned `dashboard &` run on Linux isn't misread).
+function serviceManaged() {
+  if (process.env.CLAUDE_DASH_SERVICE === '1') return true;
+  if (process.env.INVOCATION_ID) return true;
+  return process.platform === 'darwin' && process.ppid === 1;
+}
+
+function readPkgVersion(appDir) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(appDir, 'package.json'), 'utf8')).version || null;
+  } catch {
+    return null;
+  }
+}
+
+function runSelfUpdate(appDir) {
+  const kind = detectInstallKind(appDir, fs.existsSync(path.join(appDir, '.git')));
+  const plan = updatePlan(kind, PKG_NAME);
+  if (plan.type === 'manual') {
+    return Promise.resolve({ ok: false, kind, manual: plan.message });
+  }
+  let cmd = plan.cmd;
+  let args = plan.args;
+  if (kind === 'npm') {
+    const cli = npmCliCandidates(path.dirname(process.execPath)).find((p) => fs.existsSync(p));
+    if (cli) {
+      cmd = process.execPath;
+      args = [cli, ...plan.args];
+    }
+  }
+  const before = readPkgVersion(appDir);
+  return new Promise((resolve) => {
+    execFile(cmd, args, { cwd: appDir, timeout: 120_000 }, (err, stdout, stderr) => {
+      if (err) {
+        resolve({ ok: false, kind, error: String(stderr || err.message).slice(0, 300) });
+        return;
+      }
+      // The command exiting 0 isn't proof anything changed: npm can re-fetch
+      // the same version while a release is still publishing, and git can
+      // pull nothing. Only a version change on disk earns a restart.
+      const after = readPkgVersion(appDir);
+      const changed = Boolean(after && before && after !== before);
+      resolve({
+        ok: true,
+        kind,
+        version: after || undefined,
+        unchanged: !changed,
+        willRestart: changed && serviceManaged(),
+        output: String(stdout).slice(0, 300),
+      });
+    });
+  });
+}
+
+module.exports = { detectInstallKind, updatePlan, npmCliCandidates, runSelfUpdate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mission-control",
-  "version": "1.5.0",
+  "version": "1.8.0",
   "description": "Local dashboard for Claude Code: live sessions, transcripts, costs, git status — all your projects in one place.",
   "main": "server.js",
   "bin": {