claude-mission-control 1.10.0 → 1.11.0

package/README.md

@@ -1,14 +1,52 @@
 # Claude Dashboard
 
-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.
+One web page that shows you everything Claude Code is doing on your machine.
 
-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.
+Claude Code runs in a terminal. Once you have two or three sessions going, you lose track. Which one is waiting for an answer? What did that session change while you were away? How much has this week cost? Claude Dashboard answers those questions on one screen, updated live, from the files Claude Code already writes to `~/.claude`.
 
-**Requirements:** macOS or Linux (or Windows, experimental — see below), Node.js ≥ 18, Claude Code.
+**What you get**
 
-![Claude Dashboard, dark mode — live sessions, the pinned strip, unpushed work, and today's digest](docs/screenshots/dashboard-dark.png)
+- A departures board of every running session. When Claude stops to ask you something, the row turns amber and shows the question, so you go straight to the right terminal.
+- What each running session costs so far, how fast it is spending, and how full its context window is.
+- A diff of every file Claude edited or created in a session, taken from the backups Claude Code keeps. Read what changed before you commit it.
+- The full transcript of any session, past or present, and a search across every prompt you have ever sent.
+- Cost per session, project, model, and week, estimated from the tokens in your transcripts, with a breakdown by model and cache use.
+- Per project, the plugins, agents, skills, and MCP servers Claude Code would actually use there, and the exact setting to switch each one on or off.
+- A macOS notification the moment a session needs you, and a reminder if you leave it waiting.
 
-*Every screenshot here is demo data (`CLAUDE_DASH_DEMO=1`) — the projects are invented.*
+**Why you would want it**
+
+- You stop checking terminals. The board and the notifications tell you when to look.
+- You stop losing sessions. Every session has a resume button that reopens it in the right folder.
+- You see where the time and the money go, per project.
+- It is read-only. It never writes to Claude's files. Nothing leaves your Mac except one optional call to Anthropic's usage API for your quota meters, using the sign-in Claude Code already has.
+- Nothing to configure. No API keys. Plain Node.js, zero npm dependencies, bound to `127.0.0.1` only.
+
+**Who it is for:** anyone who runs Claude Code in more than one terminal.
+
+**Requirements:** macOS or Linux (Windows experimental, see below), Node.js ≥ 18, Claude Code.
+
+![Claude Dashboard, dark mode: three live sessions, two of them waiting with the question shown, plus 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.*
+
+**New in 1.11.0**
+
+- Live cost and a `$/h` burn rate on every running session, and a cost breakdown by model, cache use, and subagents in each transcript.
+- A context meter on every running session, amber from 70% full and red from 90%, plus tool-call and failure counts in Mission Control.
+- A Toolset view in each project's slide-over: which plugins, agents, skills, and MCP servers apply there, which settings file decided each one, and the snippet to flip it.
+- Current list prices for every Claude model, your organization's contracted rates when Claude Code's `modelPricing` is set, and an amber `?` on any model the table does not price.
+- The ten most expensive sessions in stats, and your cache hit rate in the weekly report.
+- Cost labels that match your plan: *estimated cost* on API billing, *list-price value* on a subscription.
+
+**New in 1.10.0**
+
+- The board says what a waiting session needs: the question, the command awaiting permission, or Claude's last line.
+- `Δ n` on every session row, and a changes panel with a diff of every file the session touched.
+- Notes on any session, searchable.
+- A Plugins & MCP inventory: what is installed, enabled, stale, disabled, or needing auth.
+- Agent teams and subagents shown live in Mission Control.
+- An idle reminder when a session has waited on you for an hour.
 
 ## Try it in one command
 
@@ -68,34 +106,37 @@ You should see a dark board listing your projects. If a Claude Code session is r
 **Using it day to day** — three things cover most of it:
 
 - **Glance at the top row.** That's what's running right now. Amber **needs you** means go back to that terminal — Claude asked a question.
-- **Click any session title** to read the whole conversation. If it's still running, new messages stream in live.
+- **Click any session title** to read the whole conversation. If it's still running, new messages stream in live. The `≈$ ▾` button in its header shows what it cost, by model.
 - **Click `open ⬈`** next to an old session to pick it up again — it opens a terminal in the right folder with the conversation restored.
 
 If something looks off, the log is at `~/Library/Logs/claude-dashboard.log`. To remove everything, run `./uninstall.sh` from the same folder.
 
 ## 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. 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".
+- **Departures** — every live `claude` CLI session as a row on the board: start time, project, current task, model, cost so far with a `$/h` burn rate, a context-window meter, 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. Each pane head shows the model, cost and burn rate, the context meter, and how many tool calls the session has made (failures in amber). 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. 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.
+- **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 cost (list-price value on a subscription) 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)
+![Mission Control: every live session tiled side by side, each pane following its own transcript, with the waiting reason at the top of each pane and the agent team under the middle one](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)
+![Transcript viewer live-following a running session: the agent team at the top, then prompts, replies as markdown, and 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. 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.
+- **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 cost per day for the last 90 days (list-price value on a subscription), and an all-time per-model token/cost breakdown. The daily cost 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 cost (list-price value on a subscription) against your budget, busiest day and hour, models used, how long you typically take to answer a question, and your cache hit rate. 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.
+
+![The changes panel: three files the session touched, the first expanded to a unified diff from the pre-edit backup to disk](docs/screenshots/changes.png)
+
 - **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.
@@ -104,13 +145,21 @@ If something looks off, the log is at `~/Library/Logs/claude-dashboard.log`. To
 
 ![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, 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.
+- **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), plus the resolved **Toolset** below. Read-only; also a quick audit of which projects are missing instructions or memory. Esc closes.
+- **Toolset** — inside the project slide-over: what Claude Code would actually use in that project. Every installed plugin, every agent and skill from the project, your user dir, and enabled plugins, and every MCP server that applies, each marked on or off with where it came from and which settings scope decided it, resolved with Claude Code's own precedence (managed › local › project › user, deny beats allow, project agents shadow user agents shadow plugin agents). An amber list at the top flags things worth a look: a plugin enabled but not installed or gone stale, a deny rule naming an agent that no longer exists, a server that needs auth, a settings file that doesn't parse. The `⧉` on a row copies the exact snippet to flip it, aimed at `.claude/settings.local.json`; MCP toggles live in Claude's own registry, so that recipe tells you to run `/mcp` in a session instead (servers from a project's `.mcp.json` also honour the settings keys `enabledMcpjsonServers`, `disabledMcpjsonServers` and `enableAllProjectMcpServers`, and their recipes use those). Buttons at the foot reveal the project's settings files in Finder. Read-only — the dashboard never edits Claude configuration.
 - **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.
+
+![Plugins & MCP inventory: plugins with on, off, stale and missing states; MCP servers with scope, projects, disabled flags and needs-auth](docs/screenshots/inventory.png)
+
 - **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 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.
+- **Cost estimates** — every session, project, and live row carries a `≈$` figure computed from the token counts in its transcript. On an API-key login it is labelled *estimated cost*; on a subscription it is *list-price value*, a relative weight rather than a bill (hover a cost chip for the wording). Rates are Anthropic list prices bundled with the dashboard (cached 2026-10-06). If your organization deploys Claude Code's `modelPricing` managed setting, the dashboard reads it and reports at your contracted rates; you can also put the same `modelPricing` block in `config.json` (⚙ settings → *copy skeleton*). A model the table doesn't know is priced at the Opus tier and marked with an amber `?` so a stale table is never silent. Subagent tokens are included.
+- **Live cost** — running sessions show their cost so far on the departures board and in Mission Control, with a `$/h` burn rate once the session is five minutes old.
+- **Session cost breakdown** — the `≈$ ▾` button in a transcript's header opens a table by model (input, output, cache read, cache write), the subagent share, and the session's cache hit rate.
+- **Context and tools** — each live session shows how full its context window was on the last turn (`412k / 1M`, amber from 70%, red from 90%), so you can see a compaction or a fresh session coming. Mission Control panes add the session's tool-call count with failures in amber, and the transcript's cost panel shows the same count in its footer. Read from the same incremental transcript scan as everything else; subagents are not included.
+- **Most expensive sessions** — in the stats view: the ten costliest sessions all time, click to open.
 - **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.
 
@@ -136,6 +185,7 @@ The ⚙ gear in the header opens settings — no JSON editing required:
 - **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
+- **Pricing** shows which rate table is active (bundled, `config.json`, or your organization's managed `modelPricing`) and lists any model the table doesn't price; *copy skeleton* puts a `modelPricing` block on the clipboard to paste into `config.json`
 
 Everything saves instantly; the underlying files stay hand-editable. Keyboard: `⌘K` for the palette, `/` for search, `Esc` closes anything.
 
@@ -174,6 +224,21 @@ Edit `ignore.json` — an array of absolute path prefixes. A project is hidden i
 
 The server binds to `127.0.0.1` only by default.
 
+**Your own rates.** To price usage at rates other than Anthropic's list prices, add a `modelPricing` block to `config.json`. It uses the same shape as Claude Code's managed setting: a `multiplier` that scales every cost, and per-model `overrides` in USD per million tokens. ⚙ settings → **Pricing** → *copy skeleton* puts a starting block on your clipboard:
+
+```json
+{
+  "modelPricing": {
+    "multiplier": 1,
+    "overrides": {
+      "claude-opus-5-5": { "input": 4, "output": 20, "cacheRead": 0.2, "cacheWrite": 5 }
+    }
+  }
+}
+```
+
+If your organization deploys `modelPricing` in Claude Code's managed settings, the dashboard reads that instead, and ⚙ settings says which source is active.
+
 ## Windows (experimental — testers wanted)
 
 The core is plain cross-platform Node, and Windows support is wired in: paths handle drive letters, notifications use native toasts, and sessions open in Windows Terminal, PowerShell, or cmd (auto-detected). Install from PowerShell in the repo folder:
@@ -188,7 +253,7 @@ That registers a logon Scheduled Task ("ClaudeDashboard") running the server hid
 
 ## Access from your phone
 
-The recommended path is [Tailscale](https://tailscale.com): install it on the Mac and your phone, then run `tailscale serve --bg 4517`. That publishes the dashboard over HTTPS inside your private tailnet while the server itself stays loopback-only — nothing is exposed to the internet or your LAN. Alternatively set `CLAUDE_DASH_HOST=0.0.0.0` in the plist to bind to all interfaces, but understand what that means: anyone on the same network can view the dashboard **and use the open/new-session endpoints, which launch terminal commands on this Mac**. Don't do that on a network you don't fully control.
+The recommended path is [Tailscale](https://tailscale.com): install it on the Mac and your phone, then run `tailscale serve --bg 4517`. That publishes the dashboard over HTTPS inside your private tailnet while the server itself stays loopback-only — nothing is exposed to the internet or your LAN. Alternatively set `CLAUDE_DASH_HOST=0.0.0.0` in the plist to bind to all interfaces, but understand what that means: anyone on the same network can view the dashboard **and use the open/new-session endpoints, which launch terminal commands on this Mac**, plus the reveal-file endpoint, which opens Finder on a project's settings files. Don't do that on a network you don't fully control.
 
 ## Maintenance
 
@@ -214,6 +279,11 @@ Every `/api/*` route serves invented data from `lib/demo.js` instead of reading
 | Activity | `~/.claude/history.jsonl` |
 | Session todos | `~/.claude/tasks/<sessionId>/` |
 | Usage meters | Anthropic usage API via Claude Code's Keychain sign-in (fallback: `~/.claude/.statusline-usage-cache`) |
+| Cost, context, tool counts | Token usage, tool calls, and failed tool results in the same transcripts, read incrementally (only bytes added since the last scan) |
+| Pricing overrides | `modelPricing` in Claude Code's managed settings (`/Library/Application Support/ClaudeCode/managed-settings.json` on macOS), then `config.json` |
+| File changes | `~/.claude/file-history/<sessionId>/` (Claude Code's pre-edit backups) |
+| Plugins & MCP | `~/.claude/plugins/installed_plugins.json`, `known_marketplaces.json`, `~/.claude.json`, each project's `.mcp.json` |
+| Toolset | `~/.claude/settings.json`, each project's `.claude/settings.json` and `.claude/settings.local.json`, managed settings, `~/.claude/agents` and `~/.claude/skills`, the project's `.claude/agents` and `.claude/skills`, and each enabled plugin's `agents/` and `skills/` |
 
 ## Credits
 

package/lib/collector.js

@@ -7,14 +7,14 @@ const { readQuota } = require('./quota');
 const { fetchOauthUsage } = require('./usage');
 const { readRegistry } = require('./registry');
 const { refreshHistory, activityBuckets, weekHourHeat } = require('./history');
-const { scanAllTranscripts, scanFile, groupByProject, sessionTitle, combinedUsage, combinedDays, dailyCostSeries, subagentSummary, dayKey, reasonText } = require('./transcripts');
+const { scanAllTranscripts, scanFile, groupByProject, sessionTitle, combinedUsage, combinedDays, dailyCostSeries, subagentSummary, usageBreakdown, dayKey, reasonText, contextSummary, toolSummary } = require('./transcripts');
 const { collectGitStatus } = require('./gitstatus');
 const { friendlyName } = require('./names');
 const { isIgnored } = require('./ignore');
 const { worktreeRoot } = require('./paths');
 const { sendNotification, newlyWaiting, overdueWaits, isProjectMuted, trackWaits } = require('./notify');
-const { readConfig } = require('./config');
-const { estimateCost, budgetLevel, typicalWait } = require('./pricing');
+const { readConfig, readPricing } = require('./config');
+const { estimateCost, costReport, budgetLevel, typicalWait, burnRate, topByCost } = require('./pricing');
 const { readPlan } = require('./plan');
 const { readTeams, agentStatus, resolveTeam } = require('./teams');
 
@@ -225,6 +225,7 @@ class Collector {
   assemble() {
     const registry = readRegistry();
     const cfg = readConfig(); // read once, not per session
+    const pricing = readPricing(); // one table per assemble, threaded into every cost
     const sessionNames = cfg.sessionNames || {};
     const sessionNotes = cfg.sessionNotes || {};
     const liveByProject = new Set(
@@ -259,14 +260,15 @@ class Collector {
         git,
         spend7d: sessionMetas.reduce(
           (sum, m) =>
-            Date.now() - m.lastActivityAt < SPEND_WINDOW_MS ? sum + estimateCost(combinedUsage(m)) : sum,
+            Date.now() - m.lastActivityAt < SPEND_WINDOW_MS ? sum + estimateCost(combinedUsage(m), pricing) : sum,
           0
         ),
         sessions: sessionMetas.slice(0, SESSIONS_PER_PROJECT).map((m) => {
           const { title, source } = sessionTitle(m, sessionNames);
           return {
             sessionId: m.sessionId,
-            estCost: estimateCost(combinedUsage(m)),
+            estCost: estimateCost(combinedUsage(m), pricing),
+            assumed: costReport(combinedUsage(m), pricing).assumedModels.length > 0,
             model: m.model,
             title,
             titleSource: source,
@@ -295,10 +297,17 @@ class Collector {
     const titleBySession = new Map();
     const modelBySession = new Map();
     const subsBySession = new Map();
+    const usageBySession = new Map();
+    const contextBySession = new Map();
+    const toolsBySession = new Map();
     for (const g of this.raw.transcriptGroups.values()) {
       for (const m of g.sessions) {
         titleBySession.set(m.sessionId, sessionTitle(m, sessionNames).title);
         if (m.model) modelBySession.set(m.sessionId, m.model);
+        usageBySession.set(m.sessionId, combinedUsage(m));
+        contextBySession.set(m.sessionId, contextSummary(m.context));
+        const ts = toolSummary(m.tools);
+        toolsBySession.set(m.sessionId, ts ? { total: ts.total, errors: ts.errors } : null);
         const subs = subagentSummary(m);
         if (subs) subsBySession.set(m.sessionId, subs);
       }
@@ -338,6 +347,10 @@ class Collector {
         }
       }
       if (quietMin === null) this.stuckNotified.delete(s.sessionId);
+      // Rounded before entering state so the fingerprint only moves when a
+      // displayed digit would. Null until the transcript has been scanned.
+      const report = costReport(usageBySession.get(s.sessionId) || {}, pricing);
+      const estCost = report.usd >= 0.005 ? Math.round(report.usd * 100) / 100 : null;
       return {
         quietMin,
         waitingMin: (() => {
@@ -354,6 +367,11 @@ class Collector {
         isWorktree: worktree !== null,
         name: s.name,
         model: modelBySession.get(s.sessionId) || null,
+        estCost,
+        burnRate: burnRate(estCost, s.startedAt),
+        assumed: report.assumedModels.length > 0,
+        context: contextBySession.get(s.sessionId) || null,
+        tools: toolsBySession.get(s.sessionId) || null,
         title: titleBySession.get(s.sessionId) || s.name,
         status: s.status,
         waitingFor: s.waitingFor,
@@ -402,7 +420,7 @@ class Collector {
       if (isIgnored(g.path)) continue;
       for (const m of g.sessions) {
         const idx = 7 - Math.floor((windowEnd - 1 - m.lastActivityAt) / (7 * DAY));
-        if (idx >= 0 && idx < 8) weeklyCost[idx] += estimateCost(combinedUsage(m));
+        if (idx >= 0 && idx < 8) weeklyCost[idx] += estimateCost(combinedUsage(m), pricing);
       }
     }
     for (let i = 0; i < 8; i++) weeklyCost[i] = Math.round(weeklyCost[i] * 100) / 100;
@@ -438,13 +456,15 @@ class Collector {
     const g = this.raw.transcriptGroups.get(projectPath.toLowerCase());
     if (!g) return [];
     const notes = readConfig().sessionNotes || {};
+    const pricing = readPricing();
     return g.sessions.map((m) => {
       const { title, source } = this.titleOf(m);
       return {
         sessionId: m.sessionId,
         title,
         titleSource: source,
-        estCost: estimateCost(combinedUsage(m)),
+        estCost: estimateCost(combinedUsage(m), pricing),
+        assumed: costReport(combinedUsage(m), pricing).assumedModels.length > 0,
         awaySummary: m.awaySummary,
         note: notes[m.sessionId] || null,
         changeCount: m.changeCount || 0,
@@ -456,9 +476,21 @@ class Collector {
     });
   }
 
+  // Distinct model ids that fell through to the fallback rate, for the
+  // settings diagnostics: a non-empty list means the rate table is stale.
+  unpricedModels() {
+    const pricing = readPricing();
+    const out = new Set();
+    for (const m of this.raw.metaBySession.values()) {
+      for (const id of costReport(combinedUsage(m), pricing).assumedModels) out.add(id);
+    }
+    return [...out].sort();
+  }
+
   // Aggregates for the stats view: daily activity, hour histogram,
   // per-model usage, totals. Ignored projects excluded throughout.
   statsSummary() {
+    const pricing = readPricing();
     const DAY = 86400000;
     const perDay = new Map();
     const hours = new Array(24).fill(0);
@@ -506,6 +538,9 @@ class Collector {
     const weekProjects = new Map();
     const weekModels = new Set();
     const weekWaits = [0, 0, 0, 0];
+    const topCandidates = [];
+    let weekCacheRead = 0;
+    let weekCacheAll = 0;
     for (const g of this.raw.transcriptGroups.values()) {
       if (isIgnored(g.path)) continue;
       sessionTotal += g.sessions.length;
@@ -528,21 +563,36 @@ class Collector {
           let mWeekCost = 0;
           for (const [day, byM] of Object.entries(mDays)) {
             if (day >= weekDayKey) {
-              mWeekCost += estimateCost(byM);
+              mWeekCost += estimateCost(byM, pricing);
               for (const model of Object.keys(byM)) weekModels.add(model);
+              for (const u of Object.values(byM)) {
+                weekCacheRead += u.cacheRead || 0;
+                weekCacheAll += (u.input || 0) + (u.cacheRead || 0) + (u.cacheCreation || 0);
+              }
             }
           }
           weekCost += mWeekCost;
           const pn = friendlyName(g.path);
           weekProjects.set(pn, (weekProjects.get(pn) || 0) + mWeekCost);
         }
+        let mCost = 0;
         for (const [model, u] of Object.entries(combinedUsage(m))) {
           const e = byModel[model] || (byModel[model] = { tokens: 0, cost: 0 });
-          const cost = estimateCost({ [model]: u });
+          const cost = estimateCost({ [model]: u }, pricing);
           e.tokens += (u.input || 0) + (u.output || 0) + (u.cacheRead || 0) + (u.cacheCreation || 0);
           e.cost += cost;
+          mCost += cost;
           projModels[model] = (projModels[model] || 0) + cost;
         }
+        topCandidates.push({
+          sessionId: m.sessionId,
+          title: this.titleOf(m).title,
+          projectName: friendlyName(g.path),
+          projectPath: g.path,
+          model: m.model || null,
+          cost: Math.round(mCost * 100) / 100,
+          lastActivityAt: m.lastActivityAt,
+        });
       }
       const projTotal = Object.values(projModels).reduce((a, b) => a + b, 0);
       if (projTotal >= 0.01) {
@@ -555,7 +605,7 @@ class Collector {
       days,
       hours,
       heat: weekHourHeat(allTimestamps),
-      costDays: dailyCostSeries(sessionDays, 90),
+      costDays: dailyCostSeries(sessionDays, 90, Date.now(), pricing),
       timeline,
       week: {
         sessions: weekSessions,
@@ -571,9 +621,11 @@ class Collector {
         busiestHour: weekHours.some((c) => c) ? weekHours.indexOf(Math.max(...weekHours)) : null,
         waits: weekWaits,
         typicalWait: typicalWait(weekWaits),
+        cacheHitRatio: weekCacheAll ? Math.round((weekCacheRead / weekCacheAll) * 100) / 100 : null,
       },
       byModel,
       perProject: perProject.slice(0, 15),
+      topSessions: topByCost(topCandidates, 10),
       totals: { sessions: sessionTotal, prompts: promptTotal, cost: Math.round(costTotal * 100) / 100 },
     };
   }
@@ -583,7 +635,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), note: (readConfig().sessionNotes || {})[m.sessionId] || null, agents: this.agentsFor(m, this.raw.live.some((s) => s.sessionId === sessionId)) };
+          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)), usage: usageBreakdown(m, readPricing()) };
         }
       }
     }

package/lib/config.js

@@ -4,7 +4,8 @@
 // pretty-printed so hand-editing stays pleasant.
 const fs = require('fs');
 const path = require('path');
-const { canonicalize } = require('./paths');
+const { canonicalize, managedSettingsPath } = require('./paths');
+const { loadPricing } = require('./pricing');
 
 const ROOT = path.join(__dirname, '..');
 
@@ -62,6 +63,14 @@ function readConfig() {
   return { ...DEFAULTS, ...readJson(CONFIG_FILE, {}) };
 }
 
+// Rate table: Claude Code's managed `modelPricing` first (contracted rates
+// an admin deployed), then the same key in our config.json, then bundled
+// list prices. Both files are small; read fresh every call like readConfig.
+function readPricing() {
+  const managed = readJson(managedSettingsPath(), null);
+  return loadPricing(managed && managed.modelPricing, readConfig().modelPricing);
+}
+
 function updateConfig(patch) {
   const next = { ...readConfig() };
   if (typeof patch.terminal === 'string') next.terminal = patch.terminal;
@@ -239,6 +248,7 @@ function resolvedTerminal() {
 module.exports = {
   THEMES,
   readConfig,
+  readPricing,
   configDir: () => CONFIG_DIR,
   findOnPath,
   detectClaudeApp,

package/lib/demo.js

@@ -70,6 +70,7 @@ function demoState() {
       {
         sessionId: S1, pid: 1111, cwd: '/demo/acme-storefront', projectPath: '/demo/acme-storefront',
         projectName: 'Acme Storefront', isWorktree: false, model: 'claude-opus-5',
+        estCost: 24.6, burnRate: 11, assumed: false, context: { tokens: 412000, window: 1000000, pct: 41 }, tools: { total: 142, errors: 3 },
         title: 'Wire Stripe checkout into the cart', status: 'waiting',
         waitingFor: null,
         waitingReason: { kind: 'question', text: 'Which payment provider should checkout use for the wallet flow?', options: ['Payment Request Button', 'Native per wallet'] },
@@ -80,6 +81,7 @@ function demoState() {
       {
         sessionId: S2, pid: 2222, cwd: '/demo/blog-engine', projectPath: '/demo/blog-engine',
         projectName: 'Blog Engine', isWorktree: false, model: 'claude-fable-5',
+        estCost: 61.2, burnRate: 19, assumed: false, context: { tokens: 731000, window: 1000000, pct: 73 }, tools: { total: 388, errors: 0 },
         title: 'Migrate posts to the new block format', status: 'busy',
         waitingFor: null, waitingReason: null, startedAt: now - 3 * HOUR - 12 * MIN, statusUpdatedAt: now - MIN, quietMin: null, waitingMin: null,
         currentTask: { activeForm: 'Converting legacy shortcodes' },
@@ -94,6 +96,7 @@ function demoState() {
       {
         sessionId: S4, pid: 4444, cwd: '/demo/data-pipeline', projectPath: '/demo/data-pipeline',
         projectName: 'Data Pipeline', isWorktree: false, model: 'claude-sonnet-5',
+        estCost: 3.4, burnRate: 9, assumed: false, context: { tokens: 186000, window: 1000000, pct: 19 }, tools: { total: 37, errors: 1 },
         title: 'Backfill the analytics warehouse', status: 'waiting',
         waitingFor: null,
         waitingReason: { kind: 'permission', text: 'Bash node scripts/backfill.mjs --apply --from 2026-01-01' },
@@ -215,6 +218,7 @@ function demoStats() {
       models: ['claude-opus-5', 'claude-fable-5', 'claude-haiku-4-5'],
       busiestDay: 'Tuesday', busiestHour: 11,
       waits: [22, 31, 18, 4], typicalWait: 'under 2m',
+      cacheHitRatio: 0.91,
     },
     byModel: {
       'claude-opus-5': { tokens: 310e6, cost: 412.5 },
@@ -228,6 +232,11 @@ function demoStats() {
       { name: 'Claude Dashboard', total: 142.9, models: { 'claude-opus-5': 96.4, 'claude-fable-5': 46.5 } },
       { name: 'Design System', total: 88.1, models: { 'claude-opus-5': 61.2, 'claude-haiku-4-5': 26.9 } },
     ],
+    topSessions: [
+      { sessionId: S2, title: 'Migrate posts to the new block format', projectName: 'Blog Engine', projectPath: '/demo/blog-engine', model: 'claude-fable-5', cost: 61.2, lastActivityAt: now - MIN },
+      { sessionId: S1, title: 'Wire Stripe checkout into the cart', projectName: 'Acme Storefront', projectPath: '/demo/acme-storefront', model: 'claude-opus-5', cost: 24.6, lastActivityAt: now - 2 * MIN },
+      { sessionId: S3, title: 'Design the onboarding flow', projectName: 'Acme Storefront', projectPath: '/demo/acme-storefront', model: 'claude-opus-5', cost: 18.9, lastActivityAt: now - 3 * HOUR },
+    ],
     totals: { sessions: 212, prompts: 1841, cost: 810.4 },
   };
 }
@@ -235,7 +244,7 @@ function demoStats() {
 // `after` mirrors the live-follow poll: once the viewer has the canned
 // transcript there is nothing new, so return an empty tail instead of
 // re-sending every event.
-function demoSession(id, after) {
+function demoSessionInner(id, after) {
   const now = Date.now();
   if (id === S2) return blogSession(now, after);
   if (id === S4) return pipelineSession(now, after);
@@ -262,6 +271,24 @@ function demoSession(id, after) {
   };
 }
 
+const DEMO_USAGE = {
+  cost: 61.2, tokens: 14_300_000, cacheHitRatio: 0.93,
+  byModel: [
+    { model: 'claude-fable-5', input: 210_000, output: 480_000, cacheRead: 11_900_000, cacheCreation: 640_000, cost: 55.9 },
+    { model: 'claude-haiku-4-5', input: 120_000, output: 90_000, cacheRead: 860_000, cacheCreation: 0, cost: 5.3 },
+  ],
+  subagents: { count: 4, cost: 5.3, tokens: 1_070_000 },
+  assumedModels: [],
+  context: { tokens: 731000, window: 1000000, pct: 73 },
+  tools: { total: 388, errors: 0, byName: [{ name: 'Edit', count: 141, errors: 0 }, { name: 'Read', count: 122, errors: 0 }, { name: 'Bash', count: 79, errors: 0 }, { name: 'Grep', count: 46, errors: 0 }] },
+};
+
+// The usage block rides only on the initial load, like the real endpoint.
+function demoSession(id, after) {
+  const t = demoSessionInner(id, after);
+  return after ? t : { ...t, usage: DEMO_USAGE };
+}
+
 function blogSession(now, after) {
   return {
     sessionId: S2,
@@ -371,5 +398,39 @@ function demoInventory() {
   };
 }
 
-module.exports = { demoState, demoStats, demoSession, demoChanges, demoInventory };
+// A believable toolset for the demo project drawer.
+function demoToolset() {
+  const local = '.claude/settings.local.json';
+  const rec = (label, obj) => ({ label, text: JSON.stringify(obj, null, 2), target: local });
+  const mcpRec = (name, on) => ({ label: `${on ? 'disable' : 'enable'} MCP server ${name}`, text: `Run /mcp inside a Claude session in this project and toggle ${name}.`, target: 'a Claude session in this project' });
+  return {
+    files: { managed: false, local: true, project: true, user: true },
+    audit: [
+      { level: 'warn', text: 'plugin ado-skills is enabled by user settings but not installed' },
+      { level: 'info', text: 'agent reviewer (project) shadows plugin:ecc' },
+    ],
+    plugins: [
+      { name: 'superpowers', kind: 'plugin', enabled: true, source: 'user', pluginId: 'superpowers@claude-plugins-official', decidedBy: 'user', shadowed: [], description: null, installed: true, stale: false, recipe: rec('disable plugin superpowers', { enabledPlugins: { 'superpowers@claude-plugins-official': false } }) },
+      { name: 'ecc', kind: 'plugin', enabled: true, source: 'user', pluginId: 'ecc@claude-plugins-official', decidedBy: 'local', shadowed: [], description: null, installed: true, stale: false, recipe: rec('disable plugin ecc', { enabledPlugins: { 'ecc@claude-plugins-official': false } }) },
+      { name: 'ado-skills', kind: 'plugin', enabled: true, source: 'user', pluginId: 'ado-skills@bt-ai-tools', decidedBy: 'user', shadowed: [], description: null, installed: false, stale: false, recipe: rec('disable plugin ado-skills', { enabledPlugins: { 'ado-skills@bt-ai-tools': false } }) },
+      { name: 'figma', kind: 'plugin', enabled: false, source: 'user', pluginId: 'figma@claude-plugins-official', decidedBy: 'project', shadowed: [], description: null, installed: true, stale: false, recipe: rec('enable plugin figma', { enabledPlugins: { 'figma@claude-plugins-official': true } }) },
+    ],
+    agents: [
+      { name: 'reviewer', kind: 'agent', enabled: true, source: 'project', pluginId: null, decidedBy: 'default', shadowed: ['plugin:ecc'], description: 'Reviews a diff for correctness', recipe: rec('disable agent reviewer', { permissions: { deny: ['Agent(reviewer)'] } }) },
+      { name: 'code-explorer', kind: 'agent', enabled: true, source: 'plugin', pluginId: 'ecc@claude-plugins-official', decidedBy: 'default', shadowed: [], description: 'Traces execution paths', recipe: rec('disable agent code-explorer', { permissions: { deny: ['Agent(ecc:code-explorer)'] } }) },
+      { name: 'planner', kind: 'agent', enabled: false, source: 'user', pluginId: null, decidedBy: 'local', shadowed: [], description: null, recipe: { label: 'enable agent planner', text: 'Remove the "Agent(planner)" (or "Task(planner)") entry from permissions.deny in .claude/settings.local.json.', target: local } },
+    ],
+    skills: [
+      { name: 'brainstorming', kind: 'skill', enabled: true, mode: null, source: 'plugin', pluginId: 'superpowers@claude-plugins-official', decidedBy: 'plugin', shadowed: [], description: 'Design before code', recipe: rec('disable plugin superpowers', { enabledPlugins: { 'superpowers@claude-plugins-official': false } }) },
+      { name: 'deploy', kind: 'skill', enabled: true, mode: 'user-invocable-only', source: 'project', pluginId: null, decidedBy: 'local', shadowed: [], description: 'Ship to staging', recipe: rec('turn off skill deploy', { skillOverrides: { deploy: 'off' } }) },
+      { name: 'legacy-notes', kind: 'skill', enabled: false, mode: 'off', source: 'user', pluginId: null, decidedBy: 'user', shadowed: [], description: null, recipe: rec('turn on skill legacy-notes', { skillOverrides: { 'legacy-notes': 'on' } }) },
+    ],
+    mcp: [
+      { name: 'github', kind: 'mcp', enabled: true, source: 'global', pluginId: null, decidedBy: 'default', shadowed: [], description: 'http · https://api.githubcopilot.com/…', needsAuth: false, recipe: mcpRec('github', true) },
+      { name: 'postgres', kind: 'mcp', enabled: false, source: 'project', pluginId: null, decidedBy: 'claude.json', shadowed: [], description: 'stdio', needsAuth: false, recipe: mcpRec('postgres', false) },
+    ],
+  };
+}
+
+module.exports = { demoState, demoStats, demoSession, demoChanges, demoInventory, demoToolset };
 

package/lib/detail.js

@@ -5,46 +5,7 @@
 const fsp = require('fs/promises');
 const path = require('path');
 const { CLAUDE_DIR, canonicalize, encodeProjectDir } = require('./paths');
-
-const MAX_FILE_BYTES = 64 * 1024; // per-file cap for returned content
-
-async function readCapped(abs) {
-  try {
-    const st = await fsp.stat(abs);
-    if (!st.isFile()) return null;
-    const fh = await fsp.open(abs, 'r');
-    try {
-      const len = Math.min(st.size, MAX_FILE_BYTES);
-      const buf = Buffer.alloc(len);
-      await fh.read(buf, 0, len, 0);
-      let content = buf.toString('utf8');
-      if (st.size > MAX_FILE_BYTES) content += `\n\n… truncated (${st.size} bytes total)`;
-      return { content, size: st.size, mtimeMs: st.mtimeMs };
-    } finally {
-      await fh.close();
-    }
-  } catch {
-    return null;
-  }
-}
-
-async function listMd(dir) {
-  try {
-    const names = await fsp.readdir(dir);
-    return names.filter((n) => n.endsWith('.md')).sort();
-  } catch {
-    return [];
-  }
-}
-
-// First `description:` line of YAML frontmatter, if any.
-function frontmatterDescription(content) {
-  if (!content || !content.startsWith('---')) return null;
-  const end = content.indexOf('\n---', 3);
-  if (end === -1) return null;
-  const m = content.slice(0, end).match(/^description:\s*(.+)$/m);
-  return m ? m[1].trim().replace(/^["']|["']$/g, '').slice(0, 300) : null;
-}
+const { readCapped, listMd, frontmatterDescription } = require('./mdfiles');
 
 // Skills are directories containing SKILL.md; agents/commands are .md files.
 async function collectCapabilities(root) {

package/lib/inventory.js

@@ -27,6 +27,7 @@ function mergePlugins(installed, enabledMap, marketplaces, now = Date.now()) {
     rows.push({
       id, name, marketplace,
       version: inst ? String(inst.version || '') : null,
+      installPath: inst && typeof inst.installPath === 'string' ? inst.installPath : null,
       installedAt: inst ? ms(inst.installedAt) : null,
       lastUpdated: updated,
       enabled: !!(enabledMap && enabledMap[id]),