claude-mission-control 1.9.0 → 1.10.0

package/README.md

@@ -2,11 +2,13 @@
 
 A local, zero-dependency dashboard for all your [Claude Code](https://claude.com/claude-code) projects. Live sessions pinned at the top — including whether one is waiting on your input — with a card per project below: recent sessions, git status, a 14-day activity sparkline, and one-click resume commands.
 
-Everything is read from local files under `~/.claude`, and it never writes to Claude's data — read-only. No API keys to configure. The only automatic network call is to Anthropic's own usage API for your quota meters, authenticated with the Keychain credentials Claude Code already holds (kept in memory, toggleable in settings). Plain Node.js (which Claude Code already requires), zero npm dependencies, macOS.
+Everything is read from local files under `~/.claude`, and it never writes to Claude's data — read-only. No API keys to configure. The only automatic network call is to Anthropic's own usage API for your quota meters, authenticated with the Keychain credentials Claude Code already holds (kept in memory, toggleable in settings). Plain Node.js (which Claude Code already requires), zero npm dependencies. macOS first, Linux supported, Windows experimental.
 
 **Requirements:** macOS or Linux (or Windows, experimental — see below), Node.js ≥ 18, Claude Code.
 
-![Claude Dashboard, dark mode — live sessions, unpushed-work strip, and the daily digest](docs/screenshots/dashboard-dark.png)
+![Claude Dashboard, dark mode — live sessions, the pinned strip, unpushed work, and today's digest](docs/screenshots/dashboard-dark.png)
+
+*Every screenshot here is demo data (`CLAUDE_DASH_DEMO=1`) — the projects are invented.*
 
 ## Try it in one command
 
@@ -73,36 +75,50 @@ If something looks off, the log is at `~/Library/Logs/claude-dashboard.log`. To
 
 ## What you're looking at
 
-- **Departures** — every live `claude` CLI session as a row on the board: start time, project, current task, model, elapsed time, and a split-flap status cell. The cell flips to an amber **needs you** when a session is waiting on your input — readable from across the room.
+- **Departures** — every live `claude` CLI session as a row on the board: start time, project, current task, model, elapsed time, and a split-flap status cell. The cell flips to an amber **needs you** when a session is waiting on your input — readable from across the room. A second line under the title says what it needs: `?` for a question Claude asked (with its options), `🔒` for a tool call awaiting permission (with the command or file), or the last question in Claude's reply, or failing that the first line of its final paragraph.
+- **Mission Control** — the `▦` button in the header (or `⌘K` → Mission Control) tiles every live session side by side, each pane following its own transcript. One screen for "what is everything doing right now".
+- **Agents** — a session running subagents or an agent team shows them under its Mission Control pane: name, type, model, and a pulsing `●` while an agent has written in the last two minutes, `○` once it has gone quiet (idle teammates stay alive, so quiet is not finished), with the team name when there is one. Finished sessions list them at the top of the transcript.
+- **Pinned** — `☆ pin` on any transcript sticks that session to a strip under the departures board, so the thing you care about stays in view whether it's running or not.
 - **Digest** — what happened across every project, grouped by day. Each entry shows the session's recap (Claude's own "away summary" where one exists — click to expand), how many tasks it completed, and an open button. Switch the window between day / 3 days / week; collapses out of the way and remembers your choice.
 - **Project cards** — sorted by last activity. Branch chip, `●n` uncommitted changes, `↑n` unpushed commits. The sparkline is prompts per day for the last two weeks. Each session row has an `open ⬈` button that resumes the session in your terminal (new window, right directory) or imports it into the Claude desktop app when it's installed — the **Open in** selector in the header names whichever terminal you've configured (auto-detected on first run). The `⧉` button copies the `claude --resume` command instead.
-- **Header meters** — your plan and rate-limit tier (Free/Pro/Max/Enterprise/API, detected from Claude Code's local account cache), live session and weekly usage from Anthropic's usage API via your existing Claude Code sign-in, plus extra-usage spend. First run may show one macOS Keychain prompt — click Always Allow.
-![Transcript viewer live-following a running session — this one shows the session that built the dashboard](docs/screenshots/transcript.png)
+- **Header meters** — your plan and rate-limit tier (Free/Pro/Max/Enterprise/API, detected from Claude Code's local account cache), live session and weekly usage from Anthropic's usage API via your existing Claude Code sign-in, plus extra-usage spend. Set a **weekly budget** in settings and a third meter tracks estimated spend against it, with one alert each at 75 / 90 / 100%. First run may show one macOS Keychain prompt — click Always Allow.
+
+![Mission Control — every live session tiled side by side, each pane following its own transcript](docs/screenshots/mission-control.png)
+
+![Transcript viewer live-following a running session — prompts, replies as markdown, tool calls as one-liners](docs/screenshots/transcript.png)
 
 - **Transcripts** — click any session title (cards, digest, search results, project drawer) to read the conversation: your prompts, Claude's replies rendered as markdown, tool calls as compact one-liners, and away-summaries highlighted. Long sessions show the newest ~1200 events. **Running sessions follow live** — a `● live` badge appears, new turns stream in every few seconds, and the view sticks to the bottom unless you've scrolled up to read.
-- **Search** — the header box searches every prompt you've ever sent plus all session titles (Enter to run, 2+ characters). Narrow with `project:name` or `since:7d` / `since:2026-08-01`. Clicking a prompt result opens the transcript scrolled to the matching turn.
+- **Search** — the header box searches every prompt you've ever sent plus all session titles (Enter to run, 2+ characters). Narrow with `project:name` or `since:7d` / `since:2026-08-01`. Clicking a prompt result opens the transcript scrolled to the matching turn. If the answer isn't in a prompt, **search inside full transcripts** runs the same query across the conversation bodies — slower, so it's a second click rather than the default.
 - **Command palette** — `⌘K` from anywhere: fuzzy-jump to any project or session, watch a live session, start a new one, open settings or stats. Arrow keys + Enter.
 - **Stats** — click the weekly bar chart in the header: a 26-week activity heatmap, your busiest hours, a weekly-rhythm grid (prompts by day of week and hour), estimated spend per day for the last 90 days, and an all-time per-model token/cost breakdown. The daily spend history is computed from your existing transcripts, so it's full from the first run.
+- **Your week with Claude** — a 7-day report (`⌘K`, or the button at the top of stats): sessions, prompts, estimated spend against your budget, busiest day and hour, models used, and how long you typically take to answer a question. Exports as markdown.
+- **Day timeline** — `⌘K` → Day timeline: the last 24 hours as one lane per project, with amber ticks where a session needed you.
+- **Catch-up** — the `🔔` in the header keeps every notification the server has fired since it started, with an unread count. Useful after a morning away from the desk.
 - **Export** — any transcript downloads as clean markdown via the `export ⇩` button.
+- **Changes** — a `Δ n` chip on any session row counts the files Claude edited. Click it (or `changes` in the transcript header) for the list with `+added −removed` per file and a unified diff of what the session changed, from the pre-edit backup Claude Code keeps to the file as it is on disk now. Files with several checkpoints also offer each step (`v1 → v2`). Read-only: nothing here reverts anything.
+- **Notes** — `note` in the transcript header attaches a free-text note to a session (⌘⏎ saves, empty removes). Rows with a note show `≡`, hover to read it, and notes are searchable from the header box. Stored in `config.json` under `sessionNotes`.
 - **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.
+
+- **Project details** — click any project's name for a slide-over with its full session list, recent git commits, 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.
+- **Plugins & MCP** — `⌘K` → Plugins & MCP (or the button in settings) lists every installed plugin with its marketplace, version, on/off state and a `stale` flag when its marketplace was refreshed after the plugin was last updated, plus every MCP server with its scope, the projects that use it, an `off` chip for servers you have disabled in a project, and an amber `needs auth` when Claude Code says so. Read-only; server secrets never reach the browser.
 - **Unpushed work strip** — an amber band listing every repo with uncommitted changes (`●n`) or unpushed commits (`↑n`), sorted by recent activity. Disappears when everything's clean.
 - **Dormant** — projects with no activity for 60+ days, tucked away at the bottom.
 - Worktree sessions (`.claude/worktrees/…`) are folded into their parent project and badged `⎇`.
-- **Notifications** — the moment any session flips to "waiting for input", you get a macOS notification (with sound) naming the project. Fires once per wait, never on server restart. Mute a single noisy project from its slide-over (the bell button at the top), or disable everything with `CLAUDE_DASH_NOTIFY=0` in the plist. Notifications arrive via Script Editor/osascript — if you don't see them, allow it under System Settings → Notifications.
+- **Notifications** — the moment any session flips to "waiting for input", you get a macOS notification (with sound) naming the project and what it needs — the question, the command awaiting permission, or Claude's last line. Fires once per wait, never on server restart. Mute a single noisy project from its slide-over (the bell button at the top), or disable everything with `CLAUDE_DASH_NOTIFY=0` in the plist. Notifications arrive via Script Editor/osascript — if you don't see them, allow it under System Settings → Notifications.
 - **Cost estimates** — the header shows the estimated list-price value of the last 7 days across all projects; each project card and digest entry shows its share. Computed from token usage in the transcripts at Anthropic list rates (cache reads at 0.1×, cache writes at 1.25×). On a subscription plan these are relative weights, not billed dollars — use them to see where your usage goes. Subagent tokens are included.
 - **Stuck flag** — a session that's "busy" but has written nothing to its transcript for 10+ minutes gets an amber `quiet Nm` cell; at 20 minutes you get one notification. It's a hint, not a verdict — a session waiting on slow background work can look the same.
+- **Idle reminder** — a session left on **needs you** for an hour (configurable in settings, `0` to turn off) gets one more notification and a `still waiting` entry in the catch-up bell, and its elapsed cell turns amber with the wait time. Nothing repeats until you answer it.
 
 ![Light mode — the same board, printed on paper](docs/screenshots/dashboard-light.png)
 
 ## Menu bar companion
 
-A SwiftBar plugin lives in `menubar/claude-dash.15s.sh`. The menu bar shows `❯ N` while sessions run, `❯ N⚠` in amber when one is waiting on you, and `❯ N?` when a busy session has gone quiet. The dropdown lists live sessions, repos with unpushed work, the 7-day estimate, and an "Open dashboard" link.
+A SwiftBar plugin lives in `menubar/claude-dash.15s.sh`. The menu bar shows `❯ N` while sessions run, `❯ N⚠` in amber when one is waiting on you, and `❯ N?` when a busy session has gone quiet, and `❯ N⚠⏳` when one of them has waited past the idle reminder. The dropdown lists live sessions, repos with unpushed work, the 7-day estimate, and an "Open dashboard" link.
 
 Setup: `brew install --cask swiftbar`, then point SwiftBar's plugin folder at this repo's `menubar/` directory. The plugin refreshes every 15 seconds (rename the file to change the interval).
 
@@ -112,8 +128,13 @@ 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
+- **Claude desktop app**: lets `open ⬈` hand a session to the Claude app instead of a terminal
+- **Usage meters** on/off — this is the switch for the one automatic network call
 - **Theme**: Departures board (follows system light/dark), Phosphor, Amber CRT, Midnight, or Newsprint (`config.json`)
+- **Weekly budget** in dollars — drives the header meter and the 75 / 90 / 100% alerts; `0` turns it off
+- **Idle reminder** in minutes — one extra notification when a session has waited that long; `0` turns it off
+- **Rename any project** (writes `names.json`) or **hide it** and its whole subtree (writes `ignore.json`), with an unhide list below
+- **Claude.ai chats**: pick the `conversations.json` from your claude.ai export to make those chats searchable here
 - **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.
@@ -133,6 +154,7 @@ Edit `names.json` to control how projects are titled:
 Unlisted projects fall back to a cleaned-up folder name. Changes are picked up automatically — no restart needed.
 
 Sessions can be renamed too: click the ✎ next to any session title (live board, project cards, pinned strip, or a project's slide-over), type a name, and press Enter. Escape cancels; an empty name goes back to the automatic title. Custom names live in `config.json` under `sessionNames`, keyed by session id, and win over the AI-generated or first-prompt title everywhere.
+Notes work the same way: `sessionNotes` in `config.json`, keyed by session id, editable by hand.
 
 ## Hiding projects
 
@@ -147,6 +169,7 @@ Edit `ignore.json` — an array of absolute path prefixes. A project is hidden i
 | `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_OPEN` | unset | `1` = open the browser on startup (what `npx` sets for you) |
 | `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.
@@ -173,6 +196,14 @@ The recommended path is [Tailscale](https://tailscale.com): install it on the Ma
 - Restart after pulling changes: `launchctl kickstart -k gui/$(id -u)/com.claude-dashboard`
 - Tests: `node --test test/pure-logic.test.js`
 
+## Demo mode
+
+```bash
+CLAUDE_DASH_DEMO=1 node server.js
+```
+
+Every `/api/*` route serves invented data from `lib/demo.js` instead of reading `~/.claude` — two live sessions, a handful of projects, a full transcript. Nothing touches your own history, so it's the safe way to try the UI, record a walkthrough, or take screenshots. Every image in this README comes from it. Edit `lib/demo.js` if you want different fixtures.
+
 ## Data sources
 
 | What | Where |

package/lib/changes.js

@@ -0,0 +1,121 @@
+'use strict';
+// Files Claude edited in a session, from the file-history records in the
+// transcript, plus read-only access to the backups Claude Code keeps under
+// ~/.claude/file-history/<sessionId>/. Pure helpers first; fs code below.
+const path = require('path');
+const fsp = require('fs/promises');
+const { CLAUDE_DIR } = require('./paths');
+const { diffLines } = require('./diff');
+
+const FILE_HISTORY_DIR = path.join(CLAUDE_DIR, 'file-history');
+const BACKUP_NAME = /^[0-9a-f]{8,32}@v\d+$/;
+
+// changes: { [realPath]: { versions: [{ v, backup, at }], first, last } }
+// `backup` is null only for v1 of a file Claude created (nothing existed
+// before it, so there is no pre-edit backup to point at). A null name at any
+// other version means the file already has a real earlier backup; ignore it.
+function recordChange(changes, realPath, backup) {
+  if (!realPath || !backup) return changes;
+  const v = Number(backup.version) || 0;
+  if (!backup.backupFileName && v !== 1) return changes;
+  const at = backup.backupTime ? Date.parse(backup.backupTime) : NaN;
+  const e = changes[realPath] || (changes[realPath] = { versions: [], first: null, last: null });
+  if (!e.versions.some((x) => x.v === v)) {
+    e.versions.push({ v, backup: backup.backupFileName ? String(backup.backupFileName) : null, at: Number.isNaN(at) ? null : at });
+    e.versions.sort((x, y) => x.v - y.v);
+  }
+  if (!Number.isNaN(at)) {
+    if (e.first === null || at < e.first) e.first = at;
+    if (e.last === null || at > e.last) e.last = at;
+  }
+  return changes;
+}
+
+function mergeChanges(target, src) {
+  for (const [p, e] of Object.entries(src || {})) {
+    for (const ver of e.versions) {
+      recordChange(target, p, { backupFileName: ver.backup, version: ver.v, backupTime: ver.at ? new Date(ver.at).toISOString() : null });
+    }
+  }
+  return target;
+}
+
+// Real path for a file-history entry: the key/trackingPath can be an odd
+// encoded form, but realParentDir is always the true directory.
+function realPathOf(key, backup) {
+  if (!backup || !backup.realParentDir || !key) return null;
+  return path.join(backup.realParentDir, path.basename(String(key)));
+}
+
+const SESSION_ID = /^[0-9a-f-]{8,64}$/i;
+
+function changeFiles(changes) {
+  return Object.entries(changes || {})
+    .sort((a, b) => (b[1].last || 0) - (a[1].last || 0) || a[0].localeCompare(b[0]))
+    .map(([p, e], n) => ({ n, path: p, versions: e.versions, first: e.first, last: e.last }));
+}
+
+function relPath(abs, root) {
+  const r = String(root || '').replace(/\/+$/, '');
+  return r && abs.startsWith(r + '/') ? abs.slice(r.length + 1) : abs;
+}
+
+function backupPath(sessionId, backupName) {
+  if (!SESSION_ID.test(String(sessionId)) || !BACKUP_NAME.test(String(backupName))) return null;
+  return path.join(FILE_HISTORY_DIR, sessionId, backupName);
+}
+
+async function defaultRead(abs) {
+  try {
+    return await fsp.readFile(abs, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+// A null backup (v1 of a created file) has no file to read: the file didn't
+// exist before, so the "original" is the empty string, not a missing read.
+async function readVersion(sessionId, file, v, readFile = defaultRead) {
+  const ver = file.versions.find((x) => x.v === v);
+  if (!ver) return null;
+  if (ver.backup === null) return '';
+  const p = backupPath(sessionId, ver.backup);
+  return p ? readFile(p) : null;
+}
+
+async function sessionChangeList({ sessionId, changes, root, readFile = defaultRead }) {
+  const files = [];
+  for (const f of changeFiles(changes)) {
+    const original = await readVersion(sessionId, f, f.versions[0].v, readFile);
+    const disk = await readFile(f.path);
+    const d = original === null ? { added: 0, removed: 0, tooLarge: false } : diffLines(original, disk || '');
+    files.push({
+      n: f.n, path: f.path, rel: relPath(f.path, root),
+      versions: f.versions.map((x) => x.v), first: f.first, last: f.last,
+      exists: disk !== null, missingBackup: original === null,
+      added: d.added, removed: d.removed, tooLarge: !!d.tooLarge, truncated: !!d.truncated,
+    });
+  }
+  return { files };
+}
+
+// Normalise the `to` side of a diff request: anything that is not a usable
+// version number means "the file on disk".
+function diffTarget(to) {
+  if (to === undefined || to === null || to === 'disk') return 'disk';
+  const n = Number(to);
+  return Number.isInteger(n) && n > 0 ? n : 'disk';
+}
+
+async function sessionFileDiff({ sessionId, changes, n, from, to, root, readFile = defaultRead }) {
+  const f = changeFiles(changes)[n];
+  if (!f) return null;
+  const fromV = Number.isInteger(from) ? from : f.versions[0].v;
+  const toV = diffTarget(to);
+  const a = await readVersion(sessionId, f, fromV, readFile);
+  const b = toV === 'disk' ? (await readFile(f.path)) || '' : await readVersion(sessionId, f, toV, readFile);
+  if (a === null || b === null) return { path: f.path, rel: relPath(f.path, root), from: fromV, to: toV, missingBackup: true, hunks: [], added: 0, removed: 0, truncated: false, tooLarge: false };
+  return { path: f.path, rel: relPath(f.path, root), from: fromV, to: toV, ...diffLines(a, b) };
+}
+
+module.exports = { recordChange, mergeChanges, realPathOf, changeFiles, relPath, backupPath, diffTarget, sessionChangeList, sessionFileDiff };

package/lib/collector.js

@@ -7,15 +7,16 @@ const { readQuota } = require('./quota');
 const { fetchOauthUsage } = require('./usage');
 const { readRegistry } = require('./registry');
 const { refreshHistory, activityBuckets, weekHourHeat } = require('./history');
-const { scanAllTranscripts, groupByProject, sessionTitle, combinedUsage, combinedDays, dailyCostSeries, subagentSummary, dayKey } = require('./transcripts');
+const { scanAllTranscripts, scanFile, groupByProject, sessionTitle, combinedUsage, combinedDays, dailyCostSeries, subagentSummary, dayKey, reasonText } = require('./transcripts');
 const { collectGitStatus } = require('./gitstatus');
 const { friendlyName } = require('./names');
 const { isIgnored } = require('./ignore');
 const { worktreeRoot } = require('./paths');
-const { sendNotification, newlyWaiting, isProjectMuted } = require('./notify');
+const { sendNotification, newlyWaiting, overdueWaits, isProjectMuted, trackWaits } = require('./notify');
 const { readConfig } = require('./config');
 const { estimateCost, budgetLevel, typicalWait } = require('./pricing');
 const { readPlan } = require('./plan');
+const { readTeams, agentStatus, resolveTeam } = require('./teams');
 
 // A busy session whose transcript hasn't grown for this long may be stalled.
 const QUIET_FLAG_MS = 10 * 60 * 1000;
@@ -33,7 +34,9 @@ const CADENCE = {
 class Collector {
   constructor() {
     this.state = { generatedAt: 0, quota: null, liveSessions: [], projects: [], errors: [] };
-    this.raw = { live: [], transcriptGroups: new Map(), history: new Map(), git: new Map(), quota: null };
+    this.raw = { live: [], transcriptGroups: new Map(), history: new Map(), git: new Map(), quota: null, metaBySession: new Map(), teams: [] };
+    this.waitingSince = new Map(); // sessionId -> when it entered 'waiting'
+    this.idleNotified = new Set(); // nagged once for the current wait
     this.listeners = new Set();
     this.events = []; // notification history for the catch-up bell, newest first
     this.clientCount = 0;
@@ -98,6 +101,17 @@ class Collector {
       s.tasksSummary = t ? t.tasksSummary : null;
     }
     this.raw.live = live;
+    // A session that just flipped to waiting has a transcript the scan loop
+    // may not have re-read yet; refresh those few so the reason is current.
+    for (const s of live) {
+      if (s.status !== 'waiting') continue;
+      const m = this.raw.metaBySession.get(s.sessionId);
+      if (!m || !m.file) continue;
+      try {
+        const fresh = await scanFile(m.file, s.sessionId);
+        if (fresh) this.raw.metaBySession.set(s.sessionId, { ...m, ...fresh });
+      } catch { /* transcript briefly unreadable: keep the last meta */ }
+    }
     this.notifyTransitions(live);
   }
 
@@ -111,17 +125,32 @@ class Collector {
   notifyTransitions(live) {
     const next = new Map(live.map((s) => [s.sessionId, s.status]));
     const prev = this.prevLiveStatus ?? null;
+    const now = Date.now();
+    const cfg = readConfig();
+
+    trackWaits(next, this.waitingSince, this.idleNotified, now);
+
     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({
-        title: `${project} needs you`,
-        body: s.waitingFor || 'Claude is waiting for your input',
-        sound: 'Glass',
-      });
+      const body = reasonText(this.reasonFor(s));
+      this.logEvent('needs you', friendlyName(root), body);
+      if (isProjectMuted(root, cfg.mutedProjects)) continue;
+      sendNotification({ title: `${friendlyName(root)} needs you`, body, sound: 'Glass' });
+    }
+
+    // Idle nag: one reminder per wait once it passes the threshold.
+    const thresholdMs = (cfg.idleNagMinutes || 0) * 60000;
+    for (const id of overdueWaits(now, this.waitingSince, thresholdMs, this.idleNotified)) {
+      this.idleNotified.add(id);
+      const s = live.find((x) => x.sessionId === id);
+      if (!s) continue;
+      const root = worktreeRoot(s.cwd).root;
+      const mins = Math.floor((now - this.waitingSince.get(id)) / 60000);
+      const body = `Waiting ${mins} minutes — ${reasonText(this.reasonFor(s))}`;
+      this.logEvent('still waiting', friendlyName(root), body);
+      if (isProjectMuted(root, cfg.mutedProjects)) continue;
+      sendNotification({ title: `${friendlyName(root)} still needs you`, body, sound: 'Glass' });
     }
     this.prevLiveStatus = next;
   }
@@ -129,7 +158,9 @@ class Collector {
   async refreshScan() {
     const sessions = await scanAllTranscripts();
     this.raw.transcriptGroups = groupByProject(sessions);
+    this.raw.metaBySession = new Map(sessions.map((m) => [m.sessionId, m]));
     this.raw.history = await refreshHistory();
+    this.raw.teams = await readTeams();
     // Task summaries for recent sessions (readTasks caches by dir mtime).
     const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
     for (const g of this.raw.transcriptGroups.values()) {
@@ -170,9 +201,32 @@ class Collector {
     return sessionTitle(m, readConfig().sessionNames);
   }
 
+  // What a session is waiting for: the session file's own waitingFor when
+  // Claude Code populates it, else the reason derived from the transcript.
+  reasonFor(s) {
+    if (s.waitingFor) return { kind: 'reply', text: String(s.waitingFor).slice(0, 200) };
+    const m = this.raw.metaBySession.get(s.sessionId);
+    return (m && m.waitingReason) || null;
+  }
+
+  // Subagents/team for a session, statuses derived so state stays stable.
+  agentsFor(m, live) {
+    if (!m || !m.agents) return null;
+    const now = Date.now();
+    return {
+      team: resolveTeam(m.agents, this.raw.teams || [], m.sessionId),
+      list: m.agents.map((a) => ({
+        name: a.name, type: a.type, model: a.model, color: a.color,
+        status: live ? agentStatus(a.lastWriteAt, now) : 'done',
+      })),
+    };
+  }
+
   assemble() {
     const registry = readRegistry();
-    const sessionNames = readConfig().sessionNames || {}; // read once, not per session
+    const cfg = readConfig(); // read once, not per session
+    const sessionNames = cfg.sessionNames || {};
+    const sessionNotes = cfg.sessionNotes || {};
     const liveByProject = new Set(
       this.raw.live.map((s) => worktreeRoot(s.cwd).root.toLowerCase())
     );
@@ -220,6 +274,8 @@ class Collector {
             awaySummary: m.awaySummary,
             awaySummaryAt: m.awaySummaryAt || null,
             tasksSummary: m.tasksSummary || null,
+            note: sessionNotes[m.sessionId] || null,
+            changeCount: m.changeCount || 0,
             startedAt: m.startedAt,
             lastActivityAt: m.lastActivityAt,
             worktree: m.worktree,
@@ -255,6 +311,7 @@ class Collector {
     }
     this.stuckNotified = this.stuckNotified || new Set();
 
+    const nagMs = (cfg.idleNagMinutes || 0) * 60000;
     const liveSessions = this.raw.live.map((s) => {
       const { root, worktree } = worktreeRoot(s.cwd);
       // "Quiet" = busy but the transcript hasn't grown. Long quiet spells
@@ -283,6 +340,12 @@ class Collector {
       if (quietMin === null) this.stuckNotified.delete(s.sessionId);
       return {
         quietMin,
+        waitingMin: (() => {
+          const since = s.status === 'waiting' ? this.waitingSince.get(s.sessionId) : null;
+          if (!since || !nagMs) return null;
+          const w = Date.now() - since;
+          return w >= nagMs ? Math.floor(w / 60000) : null;
+        })(),
         pid: s.pid,
         sessionId: s.sessionId,
         cwd: s.cwd,
@@ -294,11 +357,13 @@ class Collector {
         title: titleBySession.get(s.sessionId) || s.name,
         status: s.status,
         waitingFor: s.waitingFor,
+        waitingReason: s.status === 'waiting' ? this.reasonFor(s) : null,
         startedAt: s.startedAt,
         statusUpdatedAt: s.statusUpdatedAt,
         currentTask: s.currentTask,
         tasksSummary: s.tasksSummary,
         subagents: subsBySession.get(s.sessionId) || null,
+        agents: this.agentsFor(this.raw.metaBySession.get(s.sessionId), true),
         resumeCommand: resumeCommand(s.cwd, s.sessionId),
       };
     });
@@ -315,6 +380,8 @@ class Collector {
               title: sessionTitle(m, sessionNames).title,
               projectName: friendlyName(g.path),
               model: m.model || null,
+              note: sessionNotes[m.sessionId] || null,
+              changeCount: m.changeCount || 0,
               lastActivityAt: m.lastActivityAt,
             });
           }
@@ -370,6 +437,7 @@ class Collector {
   allSessions(projectPath) {
     const g = this.raw.transcriptGroups.get(projectPath.toLowerCase());
     if (!g) return [];
+    const notes = readConfig().sessionNotes || {};
     return g.sessions.map((m) => {
       const { title, source } = this.titleOf(m);
       return {
@@ -378,6 +446,8 @@ class Collector {
         titleSource: source,
         estCost: estimateCost(combinedUsage(m)),
         awaySummary: m.awaySummary,
+        note: notes[m.sessionId] || null,
+        changeCount: m.changeCount || 0,
         startedAt: m.startedAt,
         lastActivityAt: m.lastActivityAt,
         worktree: m.worktree,
@@ -513,7 +583,7 @@ class Collector {
     for (const g of this.raw.transcriptGroups.values()) {
       for (const m of g.sessions) {
         if (m.sessionId === sessionId) {
-          return { file: m.file, title: this.titleOf(m).title, projectName: friendlyName(g.path) };
+          return { file: m.file, title: this.titleOf(m).title, projectName: friendlyName(g.path), note: (readConfig().sessionNotes || {})[m.sessionId] || null, agents: this.agentsFor(m, this.raw.live.some((s) => s.sessionId === sessionId)) };
         }
       }
     }
@@ -533,6 +603,16 @@ class Collector {
     return null;
   }
 
+  // Files a session edited, with its project root for relative display.
+  sessionChanges(sessionId) {
+    for (const g of this.raw.transcriptGroups.values()) {
+      for (const m of g.sessions) {
+        if (m.sessionId === sessionId) return { sessionId, changes: m.changes || {}, root: g.path };
+      }
+    }
+    return null;
+  }
+
   noteError(source, err) {
     const msg = `${source}: ${String(err && err.message ? err.message : err).slice(0, 200)}`;
     this.state.errors.push({ at: Date.now(), message: msg });

package/lib/config.js

@@ -33,7 +33,7 @@ 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: [], sessionNames: {}, theme: 'board' };
+const DEFAULTS = { terminal: 'ghostty', notifications: true, usageApi: true, mutedProjects: [], weeklyBudget: 0, pinnedSessions: [], sessionNames: {}, sessionNotes: {}, idleNagMinutes: 60, 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
@@ -70,6 +70,9 @@ function updateConfig(patch) {
   if (typeof patch.weeklyBudget === 'number' && patch.weeklyBudget >= 0 && Number.isFinite(patch.weeklyBudget)) {
     next.weeklyBudget = Math.round(patch.weeklyBudget);
   }
+  if (typeof patch.idleNagMinutes === 'number' && patch.idleNagMinutes >= 0 && Number.isFinite(patch.idleNagMinutes)) {
+    next.idleNagMinutes = Math.round(patch.idleNagMinutes);
+  }
   if (THEMES.some((t) => t.id === patch.theme)) next.theme = patch.theme;
   writeJson(CONFIG_FILE, next);
   return next;
@@ -113,6 +116,24 @@ function setSessionName(sessionId, name) {
   return next.sessionNames[sessionId] || '';
 }
 
+// Pure: returns a new sessionNotes map with `note` set for `sessionId`
+// (trimmed, capped at 2000 chars); an empty note removes the entry.
+const NOTE_CAP = 2000;
+function applySessionNote(sessionNotes, sessionId, note) {
+  const next = { ...(sessionNotes || {}) };
+  const clean = String(note || '').trim().slice(0, NOTE_CAP);
+  if (clean) next[sessionId] = clean;
+  else delete next[sessionId];
+  return next;
+}
+
+function setSessionNote(sessionId, note) {
+  const next = { ...readConfig() };
+  next.sessionNotes = applySessionNote(next.sessionNotes, sessionId, note);
+  writeJson(CONFIG_FILE, next);
+  return next.sessionNotes[sessionId] || '';
+}
+
 function readNames() {
   return readJson(NAMES_FILE, {});
 }
@@ -227,6 +248,8 @@ module.exports = {
   togglePin,
   applySessionName,
   setSessionName,
+  applySessionNote,
+  setSessionNote,
   readNames,
   setName,
   readIgnores,