claude-finops 0.8.0 → 0.10.0

package/README.md

@@ -63,6 +63,13 @@ npm install -g claude-finops    # then `claude-finops` from anywhere
 
 ## What you actually get
 
+**It acts, not just reports.** The overview opens with **⚡ Act now**: one-click
+actions that apply to you right now. Compact a running session that is carrying too
+much context (it types `/compact` into that session's terminal), hand it over to a
+fresh session, turn a shell command you keep re-running into a skill, or move an
+instruction you keep re-typing into `CLAUDE.md`. Every session row has **Resume**
+(copies `claude --resume <id>`), and running ones have **Compact**.
+
 **Where the money goes, per project.** Every project ranked by cost, drilling down
 Project → Session → Prompt.
 
@@ -140,17 +147,21 @@ labelled as your own configured figures.
 
 ## What is in it
 
-**Command center** — Executive overview (spend, tokens, usage %, remaining, forecast),
-an AI FinOps Advisor that answers "what should I do today?" from live data, and a
+**Command center** — Executive overview (spend, tokens, usage %, remaining, forecast,
+today vs yesterday) opening with the ⚡ Act now strip, running sessions you can
+interrupt, compact, hand over or close, an AI FinOps Advisor that answers "what should I do today?" from live data, and a
 0–100 FinOps scorecard with per-dimension reasoning.
 
 **Usage** — Interactive timeline across 10 metrics and 6 time ranges with day
-drill-down; burn rate and limits with a gauge, days-until-limit and projected overage;
+drill-down, plus a weekday × hour peak-hours heatmap in your local time; burn rate and
+limits with a gauge, days-until-limit and projected overage, and your 5-hour and weekly
+plan-limit history from the Claude desktop app;
 per-model FinOps table with superlatives (most expensive, most used, most
 token-efficient, best cost-per-output); context-size distribution and cache
 with-vs-without analysis.
 
-**Drill-down** — Project → Session → Prompt, everywhere. A prompt explorer over every
+**Drill-down** — Project → Session → Prompt, everywhere, with Resume (and Compact for
+running sessions) on every session row. A prompt explorer over every
 prompt with full text, category, tokens, cache split, tool calls, files touched,
 latency and efficiency; five leaderboards; prompt intelligence (spend by activity);
 and a Claude Code view (tools, files, branches, cost per repository).
@@ -212,12 +223,14 @@ depends entirely on how agentic your workload is.
 
 ```
 ~/.claude/projects/**/*.jsonl
+<Claude desktop app>/local-agent-mode-sessions/**/.claude/projects/**/*.jsonl   (Cowork)
         │
         ▼  finops/etl.py     stream-parse, normalize, roll up
    ~/.claude-finops/data/finops.db   SQLite warehouse
         │
         ▼  finops/analytics.py   KPIs · burn · forecast · waste · anomalies · scorecard
    finops/api.py             stdlib HTTP: JSON API + static files (127.0.0.1 only)
+                             (+ <Claude desktop app>/plan-usage-history.json, read on request)
         │
         ▼  web/              vanilla JS, inline-SVG charts, no build step
 ```
@@ -262,6 +275,8 @@ claude-finops --stop          stop it
 claude-finops --where         where your data, settings and keys live
 claude-finops --set-key       store a provider API key (hidden prompt, 0600)
 claude-finops --keys          which provider keys are configured
+claude-finops --install-statusline    model, context % and 5-hour limit under every prompt
+claude-finops --uninstall-statusline  remove it again
 claude-finops --help          everything
 ```
 
@@ -293,6 +308,12 @@ place for you to delete once you are happy.
 
 ## Privacy
 
+**What it reads, all read-only:** Claude Code transcripts in `~/.claude/projects`, and,
+if the Claude desktop app is installed, its Cowork transcripts and
+`plan-usage-history.json` (`~/Library/Application Support/Claude` on macOS,
+`%APPDATA%\Claude` on Windows, `~/.config/Claude` on Linux), plus the other coding
+agents listed under Multi-agent.
+
 `~/.claude-finops/data/finops.db` and the prompt/CSV exports contain **your full prompt text**. The
 server binds to `127.0.0.1` only, but treat the database and any export you
 generate as sensitive.
@@ -310,7 +331,8 @@ configure a key with `--set-key`.
 
 The app has nothing tied to one person. Whoever runs it sees **their own** Claude usage:
 
-- It reads `~/.claude/projects` on the machine it runs on (override with `CLAUDE_PROJECTS=/path`).
+- It reads `~/.claude/projects` on the machine it runs on (override with `CLAUDE_PROJECTS=/path`),
+  plus the Claude desktop app's Cowork sessions when the default location is used.
 - The account label comes from that machine's `~/.claude.json`.
 - Budgets and limits you set in the UI are saved to `~/.claude-finops/settings.local.json`. The committed `config/settings.json` holds only shared defaults.
 
@@ -344,6 +366,19 @@ files on Windows.
   `config/free_models.json`.
 - **Skills & MCP** suggests MCP servers and skills from work you repeat, with the evidence.
   "Add" runs `claude mcp add -s user …`; "Create skill" writes `~/.claude/skills/<name>/SKILL.md`.
+  The strongest skill suggestions also appear in **⚡ Act now** on the overview.
+- **Compact** (Running sessions, Act now, session rows) types `/compact` into that session's
+  terminal: tmux, Terminal.app, iTerm2 or the Windows console. Anywhere else it copies the
+  command for you to paste. It asks you to click twice.
+- **Hand over / split** (Running sessions) writes a brief of the session to
+  `~/.claude/finops-handoffs/` and opens fresh session(s) in new terminals, one per sub-task if
+  you list them; it can close the old session (resumable).
+- **Interrupt / Close / Force kill** (Running sessions) send the session's process a signal.
+  Each asks you to click twice. Interrupt is macOS/Linux only: on Windows there is no way to
+  interrupt one console process without hitting the others in its window.
+- **Install statusline** (Act now, or `--install-statusline`) adds a `statusLine` entry to
+  `~/.claude/settings.json`, keeping a `.finops-backup` copy. It won't replace a statusline you
+  already have.
 
 ---
 

package/config/pricing.json

@@ -2,8 +2,8 @@
   "_comment": "Model pricing in USD per 1,000,000 tokens. Kept SEPARATE from usage data so it can be updated without touching the dashboard. Any cost derived from these numbers is ESTIMATED, never actual billed cost.",
   "currency": "USD",
   "unit": "per_million_tokens",
-  "updated": "2026-09-23",
-  "source": "Anthropic list prices (Claude API reference, cached 2026-06-24)",
+  "updated": "2026-09-28",
+  "source": "Anthropic list prices (platform.claude.com/docs/en/about-claude/pricing, fetched 2026-09-28)",
   "models": {
     "claude-opus-5": {
       "display_name": "Claude Opus 5",
@@ -84,6 +84,128 @@
       "context_window": 1000000,
       "provider": "anthropic"
     },
+    "claude-opus-4-8": {
+      "display_name": "Claude Opus 4.8",
+      "tier": "frontier",
+      "input": 5.0,
+      "output": 25.0,
+      "cache_write_5m": 6.25,
+      "cache_write_1h": 10.0,
+      "cache_read": 0.5,
+      "context_window": 1000000,
+      "provider": "anthropic"
+    },
+    "claude-opus-4-8[fast]": {
+      "display_name": "Claude Opus 4.8 (fast mode)",
+      "tier": "frontier",
+      "input": 10.0,
+      "output": 50.0,
+      "cache_write_5m": 12.5,
+      "cache_write_1h": 20.0,
+      "cache_read": 1.0,
+      "context_window": 1000000,
+      "provider": "anthropic",
+      "_note": "Research-preview fast mode, 2x standard. Selected when usage.speed == 'fast'."
+    },
+    "claude-opus-4-7": {
+      "display_name": "Claude Opus 4.7",
+      "tier": "frontier",
+      "input": 5.0,
+      "output": 25.0,
+      "cache_write_5m": 6.25,
+      "cache_write_1h": 10.0,
+      "cache_read": 0.5,
+      "context_window": 1000000,
+      "provider": "anthropic"
+    },
+    "claude-opus-4-6": {
+      "display_name": "Claude Opus 4.6",
+      "tier": "frontier",
+      "input": 5.0,
+      "output": 25.0,
+      "cache_write_5m": 6.25,
+      "cache_write_1h": 10.0,
+      "cache_read": 0.5,
+      "context_window": 1000000,
+      "provider": "anthropic"
+    },
+    "claude-opus-4-5": {
+      "display_name": "Claude Opus 4.5",
+      "tier": "frontier",
+      "input": 5.0,
+      "output": 25.0,
+      "cache_write_5m": 6.25,
+      "cache_write_1h": 10.0,
+      "cache_read": 0.5,
+      "context_window": 200000,
+      "provider": "anthropic"
+    },
+    "claude-opus-4-1": {
+      "display_name": "Claude Opus 4.1",
+      "tier": "frontier",
+      "input": 15.0,
+      "output": 75.0,
+      "cache_write_5m": 18.75,
+      "cache_write_1h": 30.0,
+      "cache_read": 1.5,
+      "context_window": 200000,
+      "provider": "anthropic"
+    },
+    "claude-opus-4": {
+      "display_name": "Claude Opus 4",
+      "tier": "frontier",
+      "input": 15.0,
+      "output": 75.0,
+      "cache_write_5m": 18.75,
+      "cache_write_1h": 30.0,
+      "cache_read": 1.5,
+      "context_window": 200000,
+      "provider": "anthropic"
+    },
+    "claude-sonnet-4-6": {
+      "display_name": "Claude Sonnet 4.6",
+      "tier": "balanced",
+      "input": 3.0,
+      "output": 15.0,
+      "cache_write_5m": 3.75,
+      "cache_write_1h": 6.0,
+      "cache_read": 0.3,
+      "context_window": 1000000,
+      "provider": "anthropic"
+    },
+    "claude-sonnet-4-5": {
+      "display_name": "Claude Sonnet 4.5",
+      "tier": "balanced",
+      "input": 3.0,
+      "output": 15.0,
+      "cache_write_5m": 3.75,
+      "cache_write_1h": 6.0,
+      "cache_read": 0.3,
+      "context_window": 200000,
+      "provider": "anthropic"
+    },
+    "claude-sonnet-4": {
+      "display_name": "Claude Sonnet 4",
+      "tier": "balanced",
+      "input": 3.0,
+      "output": 15.0,
+      "cache_write_5m": 3.75,
+      "cache_write_1h": 6.0,
+      "cache_read": 0.3,
+      "context_window": 200000,
+      "provider": "anthropic"
+    },
+    "claude-3-5-haiku": {
+      "display_name": "Claude Haiku 3.5",
+      "tier": "economy",
+      "input": 0.8,
+      "output": 4.0,
+      "cache_write_5m": 1.0,
+      "cache_write_1h": 1.6,
+      "cache_read": 0.08,
+      "context_window": 200000,
+      "provider": "anthropic"
+    },
     "claude-haiku-4-5-20251001": {
       "display_name": "Claude Haiku 4.5",
       "tier": "economy",

package/finops/act_now.py

@@ -0,0 +1,92 @@
+"""What to do right now: the few one-click actions that apply to this machine today.
+
+Everything here already exists deeper in the dashboard (Running sessions, Skills &
+MCP, Why so many tokens?). This picks the high-signal items only, so the overview
+can act instead of just reporting:
+
+  session     a running session carrying heavy context  -> Compact / Hand over
+  skill       a shell command you keep re-running       -> Create skill
+  memory      an instruction you keep re-typing          -> Add to CLAUDE.md
+  statusline  no statusline configured                   -> Install
+
+Prompt-based skill suggestions and one-off memory lines are left to their own pages:
+they are noisy enough that a one-click card would mostly be wrong.
+"""
+
+MAX_SESSIONS = 3
+MAX_SKILLS = 2
+MAX_MEMORY = 2
+
+
+def _k(n):
+    return f"{n / 1000:.0f}K" if n < 1_000_000 else f"{n / 1_000_000:.1f}M"
+
+
+def build(live, skills, memory, statusline):
+    """live: procs.list_sessions rows; skills: actions.suggestions()["skills"];
+    memory: Diagnoser.memory_suggestions(); statusline: integrate.statusline_state()."""
+    items = []
+    heavy = sorted((x for x in live if x.get("severity") in ("medium", "high") and x.get("context")),
+                   key=lambda x: -x["context"])[:MAX_SESSIONS]
+    for x in heavy:
+        items.append({
+            "kind": "session", "severity": x["severity"], "pid": x.get("pid"),
+            "session_id": x.get("session_id"), "hosts_dashboard": bool(x.get("hosts_dashboard")),
+            "title": f"{x.get('name') or 'A session'} is carrying {_k(x['context'])} tokens of context",
+            "detail": f"{x.get('project') or ''} · every message re-reads all of it. "
+                      + ("Hand it over to a fresh session." if x["severity"] == "high"
+                         else "Compact it at the next break."),
+        })
+    cmds = sorted((s for s in skills if s.get("kind") == "command" and not s.get("installed")),
+                  key=lambda s: -s.get("runs", 0))[:MAX_SKILLS]
+    for s in cmds:
+        items.append({
+            "kind": "skill", "skill": s,
+            "title": f"You ran `{s['trigger']}` {s['runs']} times in {s['sessions']} sessions",
+            "detail": "Make it a skill so Claude runs it the way this project expects, "
+                      "without re-explaining each time.",
+        })
+    themes = sorted((m for m in memory if m.get("kind") == "theme" and not m.get("already_saved")),
+                    key=lambda m: -m.get("sessions", 0))[:MAX_MEMORY]
+    for m in themes:
+        items.append({
+            "kind": "memory",
+            "title": f"You keep re-typing instructions about: {m['text']}",
+            "detail": f"Seen in {m['sessions']} sessions. Put it in {m['target']} once instead.",
+        })
+    if statusline is None:
+        items.append({
+            "kind": "statusline",
+            "title": "See model, context % and 5-hour limit under every Claude Code prompt",
+            "detail": "Adds a statusline to ~/.claude/settings.json (a backup is kept). "
+                      "Undo any time with claude-finops --uninstall-statusline.",
+        })
+    return {"items": items}
+
+
+def act_now(a):
+    """Gather the live inputs and build the strip. Each source fails soft."""
+    from .procs import list_sessions
+    from .actions import suggestions
+    from .diagnose import Diagnoser
+    from .integrate import statusline_state
+
+    def safe(fn, default):
+        try:
+            return fn()
+        except Exception:
+            return default
+
+    live = safe(lambda: list_sessions(a.pricing), [])
+    # the process registry names sessions after their folder; the transcript title reads better
+    ids = [x["session_id"] for x in live if x.get("session_id")]
+    titles = safe(lambda: {r["id"]: r["title"] for r in a.q(
+        "SELECT id, title FROM sessions WHERE title IS NOT NULL AND id IN (%s)" % ",".join("?" * len(ids)),
+        ids)} if ids else {}, {})
+    for x in live:
+        if titles.get(x.get("session_id")):
+            x["name"] = titles[x["session_id"]]
+    return build(live,
+                 safe(lambda: suggestions(a)["skills"], []),
+                 safe(lambda: Diagnoser(a).memory_suggestions({}), []),
+                 safe(statusline_state, "other"))

package/finops/agents.py

@@ -33,7 +33,8 @@ def _cursor_state_db():
 
 AGENTS = {
     "claude": {"name": "Claude Code", "data": "full",
-               "note": "Tokens, model, cost, prompts and tool calls per request."},
+               "note": "Tokens, model, cost, prompts and tool calls per request. "
+                       "Includes Claude desktop app (Cowork) sessions when present."},
     "codex": {"name": "Codex", "data": "tokens",
               "paths": [os.path.join(HOME, ".codex", "sessions")],
               "note": "Tokens and model per turn. Cost estimated at OpenAI API list prices; "

package/finops/analytics.py

@@ -12,6 +12,7 @@ import sqlite3
 import statistics
 import sys
 import threading
+import time
 from collections import defaultdict
 from datetime import date, datetime, timedelta, timezone
 
@@ -167,6 +168,16 @@ def _cumsum(values):
         yield total
 
 
+def resume_command(sid, agent, source_file):
+    """`claude --resume <id>` for a Claude Code session; None where it would not work.
+
+    Cowork transcripts live under the desktop app's own config dir, where
+    `claude --resume` would not find them.
+    """
+    cowork = "local-agent-mode-sessions" in (source_file or "")
+    return f"claude --resume {sid}" if (agent or "claude") == "claude" and not cowork else None
+
+
 class Analytics:
     def __init__(self, db_path=DB_PATH):
         # One connection per thread. The HTTP server is threaded, and a single sqlite
@@ -334,6 +345,7 @@ class Analytics:
                             f" FROM requests r WHERE {w} AND {extra}", p + ep)
 
         tot["cost_today"] = spend("r.day = ?", [today])
+        tot["cost_yesterday"] = spend("r.day = ?", [(_d(today) - timedelta(days=1)).isoformat()])
         tot["cost_week"] = spend("r.day >= ?", [wk])
         tot["cost_period"] = spend("r.day >= ? AND r.day <= ?", [bp["start"], bp["end"]])
         tot["billing_period"] = bp
@@ -443,6 +455,30 @@ class Analytics:
                  AVG(r.context_tokens) avg_context
           FROM requests r WHERE {w} AND r.day <> '' GROUP BY 1 ORDER BY 1""", p)
 
+    def heatmap(self, f=None):
+        """Spend by weekday x hour, in this machine's local time (Monday first).
+
+        Transcripts stamp UTC; bucketing on that would put a 10am IST session at
+        4am. SQLite's 'localtime' modifier applies the local offset, half-hour
+        zones included. Date filters still apply to UTC days like every view.
+        """
+        w, p = self.where(f)
+        rows = self.q(f"""
+          SELECT CAST(strftime('%w', r.ts, 'localtime') AS INTEGER) wd,
+                 CAST(strftime('%H', r.ts, 'localtime') AS INTEGER) hr,
+                 COALESCE(SUM(r.est_cost_usd),0) cost, COALESCE(SUM(r.billable_tokens),0) tokens,
+                 COUNT(*) requests
+          FROM requests r WHERE {w} AND r.ts <> '' GROUP BY 1, 2""", p)
+        grid = {(d, h): {"dow": d, "hour": h, "cost": 0.0, "tokens": 0, "requests": 0}
+                for d in range(7) for h in range(24)}
+        for r in rows:
+            if r["wd"] is None or r["hr"] is None:
+                continue
+            c = grid[((r["wd"] + 6) % 7, r["hr"])]
+            c["cost"], c["tokens"], c["requests"] = r["cost"], r["tokens"], r["requests"]
+        return {"cells": [grid[(d, h)] for d in range(7) for h in range(24)],
+                "tz": time.strftime("%Z"), "cost_basis": "estimated"}
+
     # ---------------- models ----------------
     def models(self, f=None):
         w, p = self.where(f)
@@ -535,6 +571,7 @@ class Analytics:
         rows = self.q(f"""
           SELECT s.id session_id, s.title, s.git_branch, s.cli_version, s.started_at,
                  s.ended_at, s.duration_s, s.files_touched, pr.name project, pr.id project_id,
+                 s.agent, s.source_file,
                  COUNT(DISTINCT r.prompt_id) prompts, COUNT(*) requests,
                  SUM(r.tool_call_count) tool_calls,
                  SUM(r.input_tokens) input_tokens, SUM(r.output_tokens) output_tokens,
@@ -553,6 +590,7 @@ class Analytics:
             r["output_ratio"] = (r["output_tokens"] or 0) / r["tokens"] if r["tokens"] else 0
             cr, cw = r["cache_read_tokens"] or 0, r["cache_write_tokens"] or 0
             r["cache_hit_ratio"] = (cr / (cr + cw)) if (cr + cw) else None
+            r["resume"] = resume_command(r["session_id"], r.pop("agent"), r.pop("source_file"))
         return rows
 
     def sessions_total(self, f=None):
@@ -673,6 +711,7 @@ class Analytics:
         s["files"] = self.q(
             "SELECT path, GROUP_CONCAT(DISTINCT op) ops, COUNT(*) n FROM files_touched"
             " WHERE session_id=? GROUP BY path ORDER BY n DESC LIMIT 100", (sid,))
+        s["resume"] = resume_command(sid, s.get("agent"), s.get("source_file"))
         return s
 
     # ---------------- categories ----------------
@@ -694,7 +733,7 @@ class Analytics:
 
     # ---------------- leaderboards ----------------
     def leaderboards(self, f=None, n=20):
-        return {
+        out = {
             "most_expensive": self.prompts(f, limit=n, order="cost"),
             "most_token_heavy": self.prompts(f, limit=n, order="tokens"),
             "cheapest": self.prompts(f, limit=n, order="cheapest"),
@@ -702,6 +741,17 @@ class Analytics:
             "longest_sessions": self.sessions(f, limit=n, order="duration"),
             "basis": "estimated",
         }
+        prompt_rows = [r for k in ("most_expensive", "most_token_heavy", "cheapest", "most_efficient")
+                       for r in out[k]]
+        sids = sorted({r["session_id"] for r in prompt_rows if r.get("session_id")})
+        src = {r["id"]: r for r in self.q(
+            "SELECT id, agent, source_file FROM sessions WHERE id IN (%s)" % ",".join("?" * len(sids)),
+            sids)} if sids else {}
+        for r in prompt_rows:
+            s = src.get(r.get("session_id")) or {}
+            r["resume"] = (resume_command(r["session_id"], s.get("agent"), s.get("source_file"))
+                           if s else None)
+        return out
 
     # ---------------- efficiency ----------------
     def hygiene(self, f=None, top=12, trajectory_points=80):

package/finops/api.py

@@ -270,6 +270,9 @@ class Handler(BaseHTTPRequestHandler):
             return self.send_json({"job": j["id"]})
         if parts == ["skill"]:
             return self.send_json(X.create_skill(payload))
+        if parts == ["statusline"]:
+            from .integrate import install_statusline
+            return self.send_json(install_statusline())
         if len(parts) == 2 and parts[0] == "mcp":
             return self.send_json(X.add_mcp(parts[1], payload))
         return self.send_json({"error": "unknown action"}, 404)
@@ -366,6 +369,9 @@ class Handler(BaseHTTPRequestHandler):
         if route == "usage":
             from .limits import usage
             return self.send_json(usage(force=qs.get("refresh", [""])[0] == "1"))
+        if route == "plan_history":
+            from .plan_history import history
+            return self.send_json(history())
         if route.startswith(("free_models", "suggestions", "job/", "sync", "compare")):
             return self.actions_get(route)
         f = filters_from(qs)
@@ -385,6 +391,11 @@ class Handler(BaseHTTPRequestHandler):
             return self.send_json(a.burn(f))
         if route == "timeline":
             return self.send_json(a.timeline(f, g("grain", "day")))
+        if route == "heatmap":
+            return self.send_json(a.heatmap(f))
+        if route == "act_now":
+            from .act_now import act_now
+            return self.send_json(act_now(a))
         if route == "models":
             return self.send_json(a.models(f))
         if route == "projects":

package/finops/etl.py

@@ -16,7 +16,7 @@ from datetime import datetime, timezone
 from .classify import classify
 from .pricing import Pricing
 
-from .paths import ROOT, DB_PATH
+from .paths import ROOT, DB_PATH, DESKTOP_SESSIONS
 DEFAULT_SOURCE = os.path.expanduser("~/.claude/projects")
 
 SCHEMA_VERSION = 3   # 3: cross-session request_id dedup (resumed sessions copy history)
@@ -203,8 +203,14 @@ def _slug_to_name(slug):
 
 
 class Loader:
-    def __init__(self, db_path=DB_PATH, source=DEFAULT_SOURCE, pricing=None, other_agents=True):
+    def __init__(self, db_path=DB_PATH, source=DEFAULT_SOURCE, pricing=None, other_agents=True,
+                 desktop_roots=None):
         self.other_agents = other_agents
+        # An explicit source means "load exactly this"; only the default also picks up
+        # the desktop app's Cowork sessions (same JSONL format, different config dir).
+        self.desktop_roots = (desktop_roots if desktop_roots is not None
+                              else [DESKTOP_SESSIONS] if source == DEFAULT_SOURCE else [])
+        self.cowork = False
         self.db_path = db_path
         self.source = source
         self.pricing = pricing or Pricing()
@@ -232,13 +238,19 @@ class Loader:
                 if n.endswith(".jsonl"):
                     files.append(os.path.join(dirpath, n))
         files.sort()
-        for i, fp in enumerate(files, 1):
+        marker = os.sep + os.path.join(".claude", "projects") + os.sep
+        desktop = sorted(os.path.join(d, n) for root in self.desktop_roots
+                         for d, _, names in os.walk(root) for n in names
+                         if n.endswith(".jsonl") and marker in d + os.sep)
+        for i, fp in enumerate(files + desktop, 1):
             if verbose and i % 20 == 0:
-                print(f"  ...{i}/{len(files)} transcripts", file=sys.stderr)
+                print(f"  ...{i}/{len(files) + len(desktop)} transcripts", file=sys.stderr)
+            self.cowork = i > len(files)
             try:
                 self.load_file(fp)
             except Exception as exc:  # a corrupt transcript must not kill the load
                 print(f"  ! skipped {os.path.basename(fp)}: {exc}", file=sys.stderr)
+        self.cowork = False
         if self.other_agents:
             from .agents import AgentLoader
             counts = AgentLoader(self, log=lambda m: print(m, file=sys.stderr)).run()
@@ -253,6 +265,7 @@ class Loader:
         for k, v in (
             ("source_dir", self.source),
             ("transcript_files", str(len(files))),
+            ("desktop_transcript_files", str(len(desktop))),
             ("pricing_updated", str(self.pricing.updated)),
             ("pricing_source", str(self.pricing.source)),
             ("cost_basis", "estimated"),
@@ -260,7 +273,7 @@ class Loader:
         ):
             self.db.execute("INSERT INTO meta VALUES (?,?)", (k, v))
         self.db.commit()
-        return len(files)
+        return len(files) + len(desktop)
 
     def project_id(self, slug, cwd):
         if slug in self.projects:
@@ -271,6 +284,8 @@ class Loader:
             return pid
         is_sandbox = 1 if ("sandbox" in slug or slug.startswith("-private")) else 0
         name = os.path.basename(cwd) if cwd else _slug_to_name(slug)
+        if self.cowork:
+            name = f"Cowork · {name or 'session'}"
         cur = self.db.execute(
             "INSERT INTO projects (slug, path, name, is_sandbox) VALUES (?,?,?,?)",
             (slug, cwd, name or slug, is_sandbox))

package/finops/integrate.py

@@ -12,6 +12,7 @@ fail silent, never block, never take long.
 """
 import json
 import os
+import shlex
 import shutil
 import sys
 
@@ -59,14 +60,17 @@ def hook():
 # -------------------------------------------------------------- statusline ----
 
 def statusline():
-    """One line, refreshed constantly: model and context usage."""
+    """One line, refreshed constantly: model, context usage and the 5-hour limit."""
     try:
         d = _stdin_json()
-        pct = _dig(d, "context.percentUsed", "context.percent_used")
+        pct = _dig(d, "context_window.used_percentage", "context.percentUsed", "context.percent_used")
+        five = _dig(d, "rate_limits.five_hour.used_percentage")
         name = _dig(d, "model.display_name", "session.model", "model") or "claude"
         bits = [str(name)]
         if isinstance(pct, (int, float)):
             bits.append(f"{pct:.0f}% ctx")
+        if isinstance(five, (int, float)):
+            bits.append(f"{five:.0f}% 5h")
         print(" · ".join(bits))
     except Exception:
         print("")     # an empty statusline beats a stack trace under the prompt
@@ -81,7 +85,8 @@ def _command():
     if exe:
         return exe
     root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-    return f"{sys.executable} {os.path.join(root, 'run.py')}"
+    # settings run this through a shell: an install path with a space would split
+    return f"{shlex.quote(sys.executable)} {shlex.quote(os.path.join(root, 'run.py'))}"
 
 
 def _load_settings():
@@ -113,21 +118,31 @@ def install_hook(remove=False):
     print("The statusline (claude-finops --install-statusline) still shows model and context %.")
 
 
+def statusline_state():
+    """"ours" when our statusline is installed, "other" for someone else's, else None."""
+    cur = _load_settings().get("statusLine")
+    if not cur:
+        return None
+    return "ours" if "finops" in json.dumps(cur) else "other"
+
+
 def install_statusline(remove=False):
-    cmd = f"{_command()} --statusline"
+    """Wire the statusline into ~/.claude/settings.json. Returns {"ok", "message"}.
+
+    Claude Code wants {"type": "command", "command": ...}; an existing statusline that
+    isn't ours is left alone.
+    """
     s = _load_settings()
     if remove:
-        if "finops" in str(s.get("statusLine", "")):
+        if statusline_state() == "ours":
             s.pop("statusLine", None)
-    else:
-        prev = s.get("statusLine")
-        if prev and "finops" not in str(prev):
-            print(f"You already have a statusLine configured:\n  {prev}")
-            print("Leaving it alone. Remove it first if you want ours.")
-            return
-        s["statusLine"] = cmd
+            _save_settings(s)
+        return {"ok": True, "message": f"Removed the statusline from {SETTINGS}"}
+    if statusline_state() == "other":
+        return {"ok": False, "message": "You already have a statusline configured "
+                f"({json.dumps(s['statusLine'])}). Left it alone: remove it first if you want ours."}
+    s["statusLine"] = {"type": "command", "command": f"{_command()} --statusline"}
     _save_settings(s)
-    print(("Removed" if remove else "Installed") + f" the statusline in {SETTINGS}")
-    if not remove:
-        print("  Shows the model and context usage percentage.")
-        print("  Undo: claude-finops --uninstall-statusline")
+    return {"ok": True, "message": f"Installed the statusline in {SETTINGS}. It shows the model, "
+                                   "context % and 5-hour limit % under every prompt. "
+                                   "Undo: claude-finops --uninstall-statusline"}

package/finops/paths.py

@@ -109,3 +109,15 @@ def migrate(log=print):
     with open(_MARKER, "w") as fh:
         fh.write("state dir in use; delete this file to re-run migration\n")
     return bool(moved)
+
+
+# The Claude desktop app's data dir. Read-only: Cowork transcripts and the plan
+# usage history live here.
+if os.name == "nt":
+    DESKTOP_DIR = os.path.join(os.environ.get("APPDATA", ""), "Claude")
+elif os.uname().sysname == "Darwin":
+    DESKTOP_DIR = os.path.join(os.path.expanduser("~"), "Library", "Application Support", "Claude")
+else:
+    DESKTOP_DIR = os.path.join(os.path.expanduser("~"), ".config", "Claude")
+DESKTOP_SESSIONS = os.path.join(DESKTOP_DIR, "local-agent-mode-sessions")
+PLAN_HISTORY_PATH = os.path.join(DESKTOP_DIR, "plan-usage-history.json")

package/finops/plan_history.py

@@ -0,0 +1,80 @@
+"""Plan-limit history, as the Claude desktop app records it.
+
+The desktop app samples plan usage every few minutes into plan-usage-history.json:
+`fh` is the 5-hour window and `sd` the weekly (seven-day) window, both percent used.
+The format is undocumented, so anything unexpected returns {"ok": False, "reason"}
+instead of raising. Read on request, cached on the file's mtime.
+"""
+import json
+import os
+from datetime import datetime, timezone
+
+from .paths import PLAN_HISTORY_PATH
+
+KNOWN_VERSIONS = {2}
+_cache = {}
+
+
+def _num(v):
+    return float(v) if isinstance(v, (int, float)) and not isinstance(v, bool) else None
+
+
+def _runs(values, threshold):
+    """Separate stretches at or above the threshold, not raw sample counts."""
+    n, above = 0, False
+    for v in values:
+        hit = v is not None and v >= threshold
+        n += hit and not above
+        above = hit
+    return n
+
+
+def _peak(values):
+    return max((v for v in values if v is not None), default=None)
+
+
+def history(path=None):
+    path = path or PLAN_HISTORY_PATH
+    try:
+        mtime = os.path.getmtime(path)
+    except OSError:
+        return {"ok": False, "reason": "No plan history on this machine. The Claude desktop "
+                                       "app records it; it is not installed or has not saved any yet."}
+    hit = _cache.get(path)
+    if hit and hit[0] == mtime:
+        return hit[1]
+    res = _read(path)
+    _cache[path] = (mtime, res)
+    return res
+
+
+def _read(path):
+    try:
+        with open(path) as fh:
+            raw = json.load(fh)
+    except (OSError, ValueError):
+        return {"ok": False, "reason": "The plan history file could not be read."}
+    version = raw.get("version") if isinstance(raw, dict) else None
+    if version not in KNOWN_VERSIONS:
+        return {"ok": False, "reason": f"Unrecognised plan history format (version {version})."}
+    samples = [x for x in raw.get("samples") or []
+               if isinstance(x, dict) and _num(x.get("t")) is not None]
+    if not samples:
+        return {"ok": False, "reason": "The plan history file has no samples yet."}
+    samples.sort(key=lambda x: x["t"])
+    orgs = {x.get("org") for x in samples}
+    org = samples[-1].get("org")
+    series = []
+    for x in samples:
+        if x.get("org") != org:
+            continue
+        u = x.get("u") if isinstance(x.get("u"), dict) else {}
+        t = datetime.fromtimestamp(x["t"] / 1000, timezone.utc).isoformat().replace("+00:00", "Z")
+        series.append({"t": t, "five_hour": _num(u.get("fh")), "weekly": _num(u.get("sd"))})
+    fh = [r["five_hour"] for r in series]
+    sd = [r["weekly"] for r in series]
+    return {"ok": True, "source": path, "org_count": len(orgs), "series": series,
+            "summary": {"five_hour_peak": _peak(fh), "weekly_peak": _peak(sd),
+                        "five_hour_ge90": _runs(fh, 90), "five_hour_hit100": _runs(fh, 100),
+                        "weekly_ge90": _runs(sd, 90), "weekly_hit100": _runs(sd, 100),
+                        "first": series[0]["t"], "last": series[-1]["t"]}}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-finops",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Local FinOps dashboard for Claude Code: what you used, what it cost, why it cost that much, and what to change. Reads your own transcripts, no API key, no data leaves the machine.",
   "bin": {
     "claude-finops": "bin/claude-finops.js"

package/run.py

@@ -153,7 +153,7 @@ HELP = """Claude FinOps Command Center
   claude-finops --version       print the installed version, and whether a newer one is out
   claude-finops --no-update-check   skip the once-a-day npm version check
   claude-finops --install-hook  retired no-op (prints a message, changes nothing)
-  claude-finops --install-statusline   show model and context % in your statusline
+  claude-finops --install-statusline   show model, context % and 5-hour limit in your statusline
   claude-finops --help          this message
 
 Environment:
@@ -296,7 +296,9 @@ def main():
         return install_hook(remove="--uninstall-hook" in args)
     if "--install-statusline" in args or "--uninstall-statusline" in args:
         from finops.integrate import install_statusline
-        return install_statusline(remove="--uninstall-statusline" in args)
+        r = install_statusline(remove="--uninstall-statusline" in args)
+        print(r["message"])
+        return sys.exit(0 if r["ok"] else 1)
     if "--where" in args:
         return where()
     if "--keys" in args:

package/web/app.js

@@ -73,6 +73,13 @@ const dur = s => s == null ? '—' : s < 60 ? `${Math.round(s)}s`
 const shortDay = d => (d || '').slice(5);
 const shortId = s => (s || '').slice(0, 8);
 
+// "(▲12% vs yesterday)"; nothing when yesterday had no spend to compare against.
+const vsYesterday = o => {
+  const y = o.cost_yesterday?.c, t = o.cost_today?.c;
+  if (!y || t == null) return '';
+  const d = (t - y) / y * 100;
+  return ` (${d >= 0 ? '▲' : '▼'}${Math.abs(d).toFixed(0)}% vs yesterday)`;
+};
 function kpi(label, value, detail, opts = {}) {
   const na = value == null;
   return `<div class="kpi${na ? ' na' : ''}">
@@ -452,6 +459,8 @@ async function openSession(id) {
         : '<div class="na">None</div>')}
     </div>
     ${card('Session metadata', `<dl class="kv">
+      ${s.resume ? `<dt>Resume</dt><dd><span class="mono">${esc(s.resume)}</span>
+        <button class="btn pb-copy" id="sess-resume" data-copy="${esc(s.resume)}">Copy</button></dd>` : ''}
       <dt>Session ID</dt><dd class="mono">${esc(s.id)}</dd>
       <dt>Title</dt><dd>${s.title ? esc(s.title) : NA()}</dd>
       <dt>Project</dt><dd>${esc(s.project)}</dd>
@@ -463,6 +472,10 @@ async function openSession(id) {
       <dt>Commits / PRs</dt><dd>${NA()}</dd>
     </dl>`)}`;
   wireTable(cont, s.prompts, r => openPrompt(r.prompt_id));
+  const rb = cont.querySelector('#sess-resume');
+  if (rb) rb.onclick = async () => {
+    try { await navigator.clipboard.writeText(rb.dataset.copy); rb.textContent = 'Copied'; }
+    catch { rb.textContent = 'Copy failed'; } };
   const tl = s.timeline.map((r, i) => ({i, ...r}));
   C.timeSeries($('#sesschart', cont), {rows: tl, x: 'i', type: 'area',
     series: [{key: 'context_tokens', label: 'Context tokens', color: seriesVar(0)}],
@@ -500,7 +513,7 @@ VIEWS.overview = async (page) => {
   page.innerHTML = `
     <div class="grid g5">
       ${kpi('Estimated spend', fmtUSD(o.est_cost_usd),
-        `${fmtUSD(o.cost_today.c)} today · ${fmtUSD(o.cost_week.c)} last 7d`, {badge: BADGE.estimated})}
+        `${fmtUSD(o.cost_today.c)} today${vsYesterday(o)} · ${fmtUSD(o.cost_week.c)} last 7d`, {badge: BADGE.estimated})}
       ${kpi('Billable tokens', fmtNum(o.billable_tokens),
         `${fmtNum(o.output_tokens)} output · ${fmtNum(o.cache_read_tokens)} cache read`,
         {badge: BADGE.actual})}
@@ -672,10 +685,110 @@ VIEWS.overview = async (page) => {
   api('diagnose').then(d => {
     if (!page.isConnected) return;
     const el = h(focusStrip(d) || '<div></div>');
-    page.insertBefore(el, page.firstChild);
+    page.insertBefore(el, page.querySelector('.actnow')?.nextSibling || page.firstChild);
+    page._focusData = d;
     wireFocus(page);
   }).catch(() => {});
+  if (hasClaude()) fetch('/api/act_now').then(r => r.json()).then(d => {
+    if (!page.isConnected || !(d.items || []).length) return;
+    const el = h(actNowStrip(d.items));
+    page.insertBefore(el, page.firstChild);
+    wireActNow(el, d.items);
+  }).catch(() => {});
+};
+
+/* ---------- act now: one-click actions, on the page everyone opens first ---------- */
+const ACT_ICON = {session: '🗜', skill: '⚙', memory: '📝', statusline: '▭'};
+const codeTicks = t => esc(t).replace(/`([^`]+)`/g, '<code>$1</code>');
+function actNowStrip(items) {
+  const btn = it => it.kind === 'session'
+    ? '<button class="act" data-do="compact" title="Types /compact into that session\'s terminal">🗜 Compact</button>'
+      + '<button class="act ghost" data-do="handover">⇢ Hand over</button>'
+    : it.kind === 'skill' ? '<button class="act" data-do="skill">＋ Create skill</button>'
+    : it.kind === 'memory' ? '<button class="act ghost" data-do="memory">Show examples</button>'
+    : '<button class="act" data-do="statusline">Install statusline</button>';
+  return `<section class="actnow"><div class="focus-hd">⚡ Act now
+      <span class="note">one click each · nothing changes until you click</span></div>
+    ${items.map((it, i) => `<div class="actnow-it" data-i="${i}">
+      <span class="ai">${ACT_ICON[it.kind] || '•'}</span>
+      <div class="ft"><b>${codeTicks(it.title)}</b><div class="note">${esc(it.detail)}</div></div>
+      <div class="live-actions">${btn(it)}<span class="live-msg"></span></div></div>`).join('')}</section>`;
+}
+function wireActNow(root, items) {
+  root.querySelectorAll('.actnow-it').forEach(row => {
+    const it = items[+row.dataset.i], msg = row.querySelector('.live-msg');
+    const say = (t, ok) => { msg.textContent = t; msg.className = 'live-msg ' + (ok ? 'ok' : 'err'); };
+    row.querySelectorAll('[data-do]').forEach(b => b.onclick = async () => {
+      const what = b.dataset.do;
+      if (what === 'handover') return go('live');
+      if (what === 'memory') return jumpTo('diagnose', 'dx-mem');
+      if (what === 'compact' && !armed(b)) return;
+      b.disabled = true;
+      try {
+        if (what === 'compact') {
+          const r = await sessionAction(it.pid, 'compact', {agent: 'claude'});
+          if (!r.ok && r.copy) { try { await navigator.clipboard.writeText(r.copy); } catch {} }
+          say(r.ok ? r.message : `Failed: ${r.error}`, r.ok);
+          b.disabled = false; return;
+        }
+        const r = what === 'skill' ? await doAction('skill', it.skill) : await doAction('statusline');
+        say(what === 'skill' ? `Created ${r.path}. Use it with ${r.use}.` : r.message, r.ok !== false);
+        if (r.ok !== false) b.remove(); else b.disabled = false;
+      } catch (e) { say('Failed: ' + e.message, false); b.disabled = false; }
+    });
+  });
+}
+// Two-click confirm, inline (no browser dialogs): the first click arms, the second runs.
+function armed(b) {
+  if (b.classList.contains('armed')) { b.classList.remove('armed'); b.textContent = b.dataset.label; return true; }
+  b.dataset.label = b.textContent; b.classList.add('armed'); b.textContent = 'Click again to confirm';
+  setTimeout(() => { if (b.classList.contains('armed')) { b.classList.remove('armed'); b.textContent = b.dataset.label; } }, 4000);
+  return false;
+}
+// Open a view and scroll to an element that appears once the (possibly slow) view renders.
+async function jumpTo(view, anchor) {
+  if (S.view !== view) go(view);
+  for (let i = 0; i < 60; i++) {
+    const el = document.getElementById(anchor);
+    if (el) { el.scrollIntoView({behavior: 'smooth', block: 'start'}); el.classList.add('flash');
+      setTimeout(() => el.classList.remove('flash'), 1600); return; }
+    await new Promise(r => setTimeout(r, 250));
+  }
+}
+
+/* ---------- row actions: Resume (copy) and, for a running session, Compact ---------- */
+async function liveSessions() {
+  try {
+    const d = await fetch('/api/live?agents=claude').then(r => r.json());
+    return new Map((d.sessions || []).filter(x => x.signalable && x.pid).map(x => [x.session_id, x.pid]));
+  } catch { return new Map(); }
+}
+const rowActs = (r, live) => {
+  const pid = live && live.get(r.session_id);
+  return `<span class="row-acts">${r.resume ? `<button class="act ghost" data-resume="${esc(r.resume)}"
+    title="Copy: ${esc(r.resume)}">⧉ Resume</button>` : ''}${pid ? ` <button class="act" data-compact="${pid}"
+    title="Running now: types /compact into its terminal">🗜 Compact</button>` : ''}</span>`;
 };
+function wireRowActs(host) {
+  if (!host) return;
+  host.querySelectorAll('[data-resume]').forEach(b => b.onclick = async e => {
+    e.stopPropagation();
+    try { await navigator.clipboard.writeText(b.dataset.resume); b.textContent = '✓ Copied'; }
+    catch { b.textContent = b.dataset.resume; }
+    setTimeout(() => { b.textContent = '⧉ Resume'; }, 1800);
+  });
+  host.querySelectorAll('[data-compact]').forEach(b => b.onclick = async e => {
+    e.stopPropagation();
+    if (!armed(b)) return;
+    b.disabled = true;
+    try {
+      const r = await sessionAction(+b.dataset.compact, 'compact', {agent: 'claude'});
+      if (!r.ok && r.copy) { try { await navigator.clipboard.writeText(r.copy); } catch {} }
+      b.textContent = r.ok ? '✓ Sent' : 'Failed'; b.title = r.ok ? r.message : r.error;
+    } catch (err) { b.textContent = 'Failed'; b.title = err.message; }
+    setTimeout(() => { b.disabled = false; b.textContent = '🗜 Compact'; }, 2500);
+  });
+}
 
 function renderAdvisorHero(page, advisor) {
   if (!page || !advisor || !Array.isArray(advisor.actions)) return;
@@ -763,9 +876,10 @@ const METRICS = [
   ['avg_context', 'Avg context', fmtNum],
 ];
 VIEWS.usage = async (page) => {
-  const [tl, models, ov] = await Promise.all([api('timeline', `&grain=${S.grain}`),
-    api('models'), api('overview')]);
+  const [tl, models, ov, hm] = await Promise.all([api('timeline', `&grain=${S.grain}`),
+    api('models'), api('overview'), api('heatmap')]);
   const [, mlabel, mfmt] = METRICS.find(m => m[0] === S.metric) || METRICS[0];
+  const hmMetric = ['cost', 'tokens', 'requests'].includes(S.metric) ? S.metric : 'cost';
   page.innerHTML = `
     <div class="grid g5">
       ${kpi('Total tokens', fmtNum(ov.billable_tokens), null, {badge: BADGE.actual})}
@@ -793,6 +907,9 @@ VIEWS.usage = async (page) => {
        footer: 'Days are bucketed in UTC, as Claude Code timestamps its transcripts. '
              + 'If you work late in a timezone ahead of UTC, that work lands on the previous day here.',
        flush: 0})}
+    ${card('Peak hours', '<div class="chart" id="heat"></div>',
+      {badge: hmMetric === 'cost' ? BADGE.estimated : BADGE.actual,
+       hint: `your local time (${hm.tz || 'local'}) · ${hmMetric === 'cost' ? 'estimated cost' : hmMetric}`})}
     ${card('Model mix over time', '<div class="legend" id="mixleg"></div>' +
       '<div class="chart" id="mix"></div>', {badge: BADGE.estimated,
       hint: 'stacked estimated cost per model'})}
@@ -810,6 +927,7 @@ VIEWS.usage = async (page) => {
     xLabel: v => S.grain === 'day' ? shortDay(v) : v.slice(8).replace('T', ' ') + ':00',
     onClick: r => { if (S.grain === 'day') { S.filter.start = r.bucket; S.filter.end = r.bucket;
       S.range = 'custom'; bust(); render(); } }});
+  C.heatmap($('#heat', page), {cells: hm.cells, metric: hmMetric});
 
   // per-model stacked mix
   const byDay = new Map();
@@ -849,7 +967,8 @@ VIEWS.usage = async (page) => {
 
 /* ---------- burn & limits ---------- */
 VIEWS.burn = async (page) => {
-  const burn = await api('burn');
+  const [burn, plan] = await Promise.all([api('burn'), fetch('/api/plan_history')
+    .then(r => r.json()).catch(e => ({ok: false, reason: e.message}))]);
   const bp = burn.period;
   const rows = Object.entries(burn.allowances);
   page.innerHTML = `
@@ -901,10 +1020,31 @@ VIEWS.burn = async (page) => {
             <span class="mono">config/settings.json → limits</span> to enable usage-vs-limit,
             days-until-limit and limit-date projections.</p></div>`,
       {badge: a.configured ? BADGE.estimated : ''})).join('')}</div>
+    ${card('Plan limits over time', plan.ok ? `
+      <div class="grid g3">
+        ${kpi('5-hour peak', fmtPct(plan.summary.five_hour_peak ?? 0, 0), null, {badge: BADGE.actual})}
+        ${kpi('Times at 90%+ (5-hour)', fmtInt(plan.summary.five_hour_ge90),
+          `${fmtInt(plan.summary.five_hour_hit100)} reached 100%`)}
+        ${kpi('Weekly peak', fmtPct(plan.summary.weekly_peak ?? 0, 0),
+          `${fmtInt(plan.summary.weekly_ge90)} times at 90%+`)}
+      </div>
+      <div class="legend" id="planleg"></div><div class="chart" id="plan"></div>`
+      : `<div class="empty">${esc(plan.reason || 'Unavailable')}</div>`,
+      {badge: BADGE.actual, hint: '5-hour and weekly plan usage, % used',
+       footer: 'Read from the Claude desktop app\'s local plan-usage-history.json. '
+             + 'Its format is undocumented, so this card may go blank after an app update.'})}
     ${card('Daily consumption within the billing period', '<div class="chart" id="bs"></div>',
       {badge: BADGE.estimated})}`;
   for (const [k, a] of rows) if (a.configured)
     C.gauge($(`#g-${k}`, page), {pct: a.used_pct, status: a.status, label: 'of allowance'});
+  if (plan.ok) {
+    const ps = [{key: 'five_hour', label: '5-hour window', color: seriesVar(0), fmt: v => fmtPct(v, 0)},
+                {key: 'weekly', label: 'Weekly window', color: seriesVar(1), fmt: v => fmtPct(v, 0)}];
+    C.legend($('#planleg', page), ps.map(s => ({label: s.label, color: s.color})));
+    C.timeSeries($('#plan', page), {rows: plan.series, x: 't', type: 'line', series: ps,
+      fmt: v => fmtPct(v, 0), max: 100, height: 220,
+      xLabel: t => new Date(t).toLocaleString([], {month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit'})});
+  }
   C.timeSeries($('#bs', page), {rows: burn.series, x: 'day', type: 'bar',
     series: [{key: 'cost', label: 'Estimated cost', color: seriesVar(0), fmt: fmtUSD}],
     fmt: fmtUSD, height: 220, xLabel: shortDay});
@@ -1036,7 +1176,7 @@ VIEWS.sessions = async (page) => {
   const sp = S.sessPage;
   const res = await api('sessions', `&limit=${sp.offset + sp.limit}&order=${order}`);
   const rows = res.rows, total = res.total;
-  const eff = await api('efficiency');
+  const [eff, live] = await Promise.all([api('efficiency'), liveSessions()]);
   const avgTok = rows.length ? rows.reduce((a, r) => a + r.tokens, 0) / rows.length : 0;
   page.innerHTML = `
     <div class="grid g4">
@@ -1081,6 +1221,7 @@ VIEWS.sessions = async (page) => {
     {h: 'Session', trunc: 1, title: r => r.session_id,
      f: r => `${r.tokens > avgTok * 3 ? '🔴 ' : ''}${esc(r.title || shortId(r.session_id))}
        <div class="sub mono">${esc(shortId(r.session_id))}</div>`},
+    {h: '', f: r => rowActs(r, live)},
     {h: 'Project', f: r => esc(r.project)},
     {h: 'Branch', f: r => r.git_branch ? `<span class="mono">${esc(r.git_branch)}</span>` : '—'},
     {h: 'Start', f: r => `<span class="mono">${esc((r.started_at || '').slice(0, 16).replace('T', ' '))}</span>`},
@@ -1101,6 +1242,7 @@ VIEWS.sessions = async (page) => {
     {h: 'Est. cost', num: 1, f: r => fmtUSD(r.cost)},
   ], rows, {onRow: 1});
   wireTable($('#st', page), rows, r => openSession(r.session_id));
+  wireRowActs($('#st', page));
   const effCards = [...page.querySelectorAll('.card')].filter(c =>
     /output yield/.test(c.querySelector('h3')?.textContent || ''));
   wireTable(effCards[0], eff.low_efficiency_sessions, r => openSession(r.session_id));
@@ -1179,7 +1321,7 @@ const RANK_TABS = [
   ['cheapest', 'Top 20 cheapest'], ['most_efficient', 'Top 20 most efficient'],
   ['longest_sessions', 'Top 20 longest sessions']];
 VIEWS.rankings = async (page) => {
-  const lb = await api('leaderboards', '&n=20');
+  const [lb, live] = await Promise.all([api('leaderboards', '&n=20'), liveSessions()]);
   const tab = S.rankTab || 'most_expensive';
   const isSess = tab === 'longest_sessions';
   const rows = lb[tab];
@@ -1193,6 +1335,7 @@ VIEWS.rankings = async (page) => {
   const cols = isSess ? [
     {h: '#', num: 1, f: r => rows.indexOf(r) + 1},
     {h: 'Session', trunc: 1, f: r => esc(r.title || shortId(r.session_id))},
+    {h: '', f: r => rowActs(r, live)},
     {h: 'Project', f: r => esc(r.project)},
     {h: 'Duration', num: 1, f: r => dur(r.duration_s)},
     {h: 'Prompts', num: 1, f: r => fmtInt(r.prompts)},
@@ -1211,10 +1354,12 @@ VIEWS.rankings = async (page) => {
     {h: 'Tok eff', num: 1, f: r => fmtPct(r.efficiency * 100, 2)},
     {h: 'Est. cost', num: 1, f: r => fmtUSD(r.pcost)},
     {h: 'Session', trunc: 1, f: r => esc(r.session_title || shortId(r.session_id))},
+    {h: '', f: r => rowActs(r, live)},
     {h: 'Date', f: r => esc(r.day)},
   ];
   $('#rt', page).innerHTML = table(cols, rows, {onRow: 1});
   wireTable($('#rt', page), rows, r => isSess ? openSession(r.session_id) : openPrompt(r.prompt_id));
+  wireRowActs($('#rt', page));
   addChart(page, 'Top 12 prompts by estimated cost', el => C.barsH(el, {
     rows: (lb.most_expensive || []).slice(0, 12), label: r => clip(r.preview, 46), value: r => r.pcost,
     sub: r => `<div class="row"><span class="k">Project</span><span class="v">${esc(r.project)}</span></div>
@@ -2257,45 +2402,81 @@ VIEWS.exports = async (page) => {
 /* ============================ focus cues ============================ */
 // "What needs me first": one ranked list built from the diagnosis, used for the nav
 // badges and the Focus strip at the top of the overview and diagnosis pages.
+// "What to change": things to fix once and habits to change, each with its reason.
+// Running sessions are left to ⚡ Act now, which can act on them. Items are keyed so a
+// dismissed one comes back only if its evidence changes (e.g. more sessions affected).
+const firstSentence = t => { const m = String(t || '').match(/^.*?[.!?](\s|$)/); return (m ? m[0] : String(t || '')).trim(); };
+// "29.7% of X." + "35.6% of X." -> "29.7–35.6% of X." plus the shared advice; null when they differ.
+function sameFix(fixes) {
+  const pct = /\d+(?:\.\d+)?%/, heads = fixes.map(firstSentence);
+  const shape = heads.map(t => t.replace(pct, '#'));
+  if (!shape.every(t => t === shape[0]) || !pct.test(heads[0])) return null;
+  const nums = heads.map(t => parseFloat(t.match(pct)[0]));
+  const range = `${Math.min(...nums)}–${Math.max(...nums)}%`;
+  const rest = fixes[0].slice(heads[0].length).trim().replace(/\bthis repo\b/g, 'each repo');
+  return `${shape[0].replace('#', range).replace(' here ', ' in these repos ')} ${rest}`.trim();
+}
 function focusItems(d) {
   const out = [];
-  for (const x of d.live_sessions || []) if (x.severity !== 'ok')
-    out.push({lvl: x.severity === 'high' ? 1 : 2, text: `Running session at ${fmtNum(x.context)} context: ${x.title || shortId(x.session_id)}`, view: 'diagnose', anchor: 'dx-live'});
   for (const m of d.memory_suggestions || []) if (m.kind === 'security')
-    out.push({lvl: 1, text: `Credentials pasted in prompts (${m.sessions} sessions): rotate them`, view: 'diagnose', anchor: 'dx-mem'});
+    out.push({lvl: 1, kind: 'fix', key: `sec:${m.sessions}`, view: 'diagnose', anchor: 'dx-mem',
+      text: `Rotate the credentials you pasted into prompts (${m.sessions} session${m.sessions === 1 ? '' : 's'})`,
+      why: 'Closing the sessions does not help: the secrets stay in plain text in those transcripts on disk.'});
+  const byIssue = (sev, lvl) => {
+    const groups = new Map();
+    for (const p of d.projects || []) for (const i of p.issues) if (i.severity === sev) {
+      if (!groups.has(i.title)) groups.set(i.title, []);
+      groups.get(i.title).push({project: p.name, fix: i.fix});
+    }
+    for (const [title, ps] of groups) out.push({lvl, kind: 'fix', view: 'diagnose', anchor: 'dx-issues',
+      key: `proj:${title}:${ps.map(x => x.project).sort().join(',')}`,
+      text: ps.length === 1 ? `${ps[0].project}: ${title}` : `${title} in ${ps.length} projects: ${ps.map(x => x.project).join(', ')}`,
+      why: ps.length === 1 ? ps[0].fix : sameFix(ps.map(x => x.fix))
+        || ps.slice(0, 3).map(x => `${x.project}: ${firstSentence(x.fix)}`).join(' · ')});
+  };
+  byIssue('high', 1);
   for (const r of d.recommendations || []) if (r.priority === 1)
-    out.push({lvl: 1, text: r.title, view: 'diagnose', anchor: 'dx-recs'});
-  for (const p of d.projects || []) for (const i of p.issues) if (i.severity === 'high')
-    out.push({lvl: 1, text: `${p.name}: ${i.title}`, view: 'diagnose', anchor: 'dx-issues'});
-  const s0 = (d.session_health || [])[0];
-  if (s0) out.push({lvl: 2, text: `Heaviest session: ${s0.title || shortId(s0.session_id)} (peak ${fmtNum(s0.peak)})`, view: 'diagnose', anchor: 'dx-past'});
-  for (const p of d.projects || []) for (const i of p.issues) if (i.severity === 'medium')
-    out.push({lvl: 2, text: `${p.name}: ${i.title}`, view: 'diagnose', anchor: 'dx-issues'});
+    out.push({lvl: 2, kind: 'habit', key: `rec:${r.title}`, view: 'diagnose', anchor: 'dx-recs',
+      text: r.title, why: `${firstSentence(r.why)} ${firstSentence(r.how)}`});
+  byIssue('medium', 3);
   return out.sort((a, b) => a.lvl - b.lvl);
 }
+const FOCUS_KEY = 'finops.focus.hidden';
+const focusHidden = () => { try { return new Set(JSON.parse(localStorage.getItem(FOCUS_KEY) || '[]')); } catch { return new Set(); } };
+const setFocusHidden = set => { try { localStorage.setItem(FOCUS_KEY, JSON.stringify([...set])); } catch {} };
 function focusStrip(d, n = 5) {
-  const items = focusItems(d);
-  if (!items.length) return '';
-  return `<section class="focus"><div class="focus-hd">🎯 Focus on these first
-      <span class="note">${items.filter(i => i.lvl === 1).length} urgent · ${items.filter(i => i.lvl === 2).length} next</span></div>
-    ${items.slice(0, n).map((it, k) => `<a class="focus-it l${it.lvl}" data-go="${it.view}" data-anchor="${it.anchor}">
-      <span class="fn">${k + 1}</span><span class="ft">${esc(it.text)}</span>
-      <span class="fl">${it.lvl === 1 ? 'Fix first' : 'Next'}</span></a>`).join('')}</section>`;
+  const all = focusItems(d), hidden = focusHidden();
+  const items = all.filter(i => !hidden.has(i.key));
+  const nHidden = all.length - items.length;
+  if (!all.length) return '';
+  const fixes = items.filter(i => i.kind === 'fix').length, habits = items.filter(i => i.kind === 'habit').length;
+  return `<section class="focus"><div class="focus-hd">🎯 What to change
+      <span class="note">${fixes} to fix once · ${habits} habit${habits === 1 ? '' : 's'} from your past sessions</span>
+      <span class="spacer"></span>${nHidden ? `<button class="act ghost" data-unhide="1">Show ${nHidden} hidden</button>` : ''}</div>
+    ${items.slice(0, n).map((it, k) => `<div class="focus-it l${it.lvl === 1 ? 1 : 2}" data-go="${it.view}" data-anchor="${it.anchor}" data-key="${esc(it.key)}">
+      <span class="fn">${k + 1}</span>
+      <span class="ft"><span class="fx">${esc(it.text)}</span><span class="fw">${esc(it.why || '')}</span></span>
+      <span class="fl">${it.kind === 'habit' ? 'Habit' : 'Fix once'}</span>
+      <button class="fd" title="Hide this until its evidence changes" aria-label="Hide">✕</button></div>`).join('')
+      || '<div class="note">Everything here is hidden. Nice.</div>'}</section>`;
 }
 function wireFocus(root) {
-  root.querySelectorAll('.focus-it').forEach(a => a.onclick = async () => {
-    if (S.view !== a.dataset.go) { go(a.dataset.go); await new Promise(r => setTimeout(r, 400)); }
-    const el = document.getElementById(a.dataset.anchor);
-    if (el) { el.scrollIntoView({behavior: 'smooth', block: 'start'}); el.classList.add('flash');
-      setTimeout(() => el.classList.remove('flash'), 1600); }
+  const redraw = () => { const old = root.querySelector('.focus'); if (!old || !root._focusData) return;
+    const el = h(focusStrip(root._focusData) || '<div></div>'); old.replaceWith(el); wireFocus(root); };
+  root.querySelectorAll('.focus-it').forEach(a => {
+    a.onclick = () => jumpTo(a.dataset.go, a.dataset.anchor);
+    a.querySelector('.fd').onclick = e => { e.stopPropagation();
+      const hid = focusHidden(); hid.add(a.dataset.key); setFocusHidden(hid); redraw(); };
   });
+  const un = root.querySelector('[data-unhide]');
+  if (un) un.onclick = () => { setFocusHidden(new Set()); redraw(); };
 }
 async function updateNavBadges() {
   const set = (id, n, lvl) => { const el = document.querySelector(`[data-nb="${id}"]`);
     if (el) { el.textContent = n ? n : ''; el.className = 'nb' + (n ? ' l' + lvl : ''); } };
   try {
     const [d, w, a] = await Promise.all([hasPriced() ? api('diagnose') : null, api('waste'), api('anomalies')]);
-    if (d) { const f = focusItems(d), urgent = f.filter(i => i.lvl === 1).length;
+    if (d) { const hid = focusHidden(), f = focusItems(d).filter(i => !hid.has(i.key)), urgent = f.filter(i => i.lvl === 1).length;
       set('diagnose', urgent || f.length, urgent ? 1 : 2); }
     const hw = w.findings.filter(x => x.severity === 'high').length;
     set('waste', hw || w.findings.length, hw ? 1 : 2);

package/web/charts.js

@@ -70,7 +70,7 @@ export function timeSeries(host, opts) {
   const totals = rows.map(r => stacked
     ? active.reduce((a, s) => a + (+r[s.key] || 0), 0)
     : Math.max(...active.map(s => +r[s.key] || 0), 0));
-  const max = nice(Math.max(...totals, 0) || 1);
+  const max = Math.max(opts.max || 0, nice(Math.max(...totals, 0) || 1));
   const y = v => m.t + ih - (v / max) * ih;
   const n = rows.length;
   const bw = Math.max(2, Math.min(34, iw / n * 0.72));
@@ -349,3 +349,36 @@ export function legend(host, items, onToggle) {
     host.appendChild(s);
   });
 }
+
+/* ---------- heatmap: weekday x hour ---------- */
+const DOW = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'];
+export function heatmap(host, {cells, metric = 'cost'}) {
+  host.innerHTML = '';
+  const max = Math.max(0, ...cells.map(c => +c[metric] || 0));
+  if (!max) { host.innerHTML = '<div class="empty">No activity in range</div>'; return; }
+  const W = Math.max(host.clientWidth || 640, 320);
+  const m = {t: 4, r: 4, b: 18, l: 34};
+  const cw = (W - m.l - m.r) / 24, ch = Math.min(22, Math.max(12, cw * 0.8));
+  const H = m.t + ch * 7 + m.b;
+  const svg = el('svg', {viewBox: `0 0 ${W} ${H}`, height: H, role: 'img'});
+  DOW.forEach((d, i) => svg.appendChild(el('text', {x: m.l - 6, y: m.t + i * ch + ch * 0.68,
+    'text-anchor': 'end'}, d)));
+  for (let h = 0; h < 24; h += 3) svg.appendChild(el('text', {x: m.l + h * cw + cw / 2,
+    y: H - 5, 'text-anchor': 'middle'}, String(h).padStart(2, '0')));
+  cells.forEach(c => {
+    const v = +c[metric] || 0;
+    const r = el('rect', {x: m.l + c.hour * cw + 1, y: m.t + c.dow * ch + 1,
+      width: Math.max(1, cw - 2), height: Math.max(1, ch - 2), rx: 2,
+      fill: v ? 'var(--s1)' : 'var(--grid)',
+      'fill-opacity': v ? (0.15 + 0.85 * Math.sqrt(v / max)).toFixed(3) : 1});
+    r.addEventListener('mousemove', ev => showTip(
+      `<div class="t">${DOW[c.dow]} ${String(c.hour).padStart(2, '0')}:00</div>
+       <div class="row"><span class="k">Est. cost</span><span class="v">${fmtUSD(c.cost)}</span></div>
+       <div class="row"><span class="k">Tokens</span><span class="v">${fmtNum(c.tokens)}</span></div>
+       <div class="row"><span class="k">Requests</span><span class="v">${fmtInt(c.requests)}</span></div>`,
+      ev.clientX, ev.clientY));
+    r.addEventListener('mouseleave', hideTip);
+    svg.appendChild(r);
+  });
+  host.appendChild(svg);
+}

package/web/styles.css

@@ -331,6 +331,17 @@ table.tbl .sub { font-size:10.5px; color:var(--muted); }
 .nav a .nb.l1 { background: var(--critical); color: #fff; }
 .nav a .nb.l2 { background: var(--warning); color: #3a2a00; }
 
+.actnow { border: 1px solid color-mix(in srgb, var(--s1) 40%, var(--border));
+  background: color-mix(in srgb, var(--s1) 5%, var(--surface)); border-radius: var(--radius);
+  padding: 10px 12px; margin-bottom: 14px; display: flex; flex-direction: column; gap: 6px; }
+.actnow-it { display: flex; align-items: center; gap: 10px; flex-wrap: wrap; padding: 7px 8px;
+  border: 1px solid var(--border); border-radius: 8px; background: var(--surface); }
+.actnow-it .ai { width: 22px; text-align: center; font-size: 15px; }
+.actnow-it .ft { flex: 1; min-width: 220px; }
+.actnow-it .live-actions { margin-top: 0; }
+.row-acts { white-space: nowrap; }
+.row-acts .act { padding: 2px 8px; font-size: 11px; }
+
 .focus { border: 1px solid color-mix(in srgb, var(--critical) 35%, var(--border));
   background: color-mix(in srgb, var(--critical) 5%, var(--surface)); border-radius: var(--radius);
   padding: 10px 12px; margin-bottom: 14px; display: flex; flex-direction: column; gap: 5px; }
@@ -341,7 +352,12 @@ table.tbl .sub { font-size:10.5px; color:var(--muted); }
 .focus-it .fn { width: 20px; height: 20px; border-radius: 50%; display: grid; place-items: center;
   font-size: 11px; font-weight: 700; color: #fff; flex: none; }
 .focus-it.l1 .fn { background: var(--critical); } .focus-it.l2 .fn { background: var(--warning); }
-.focus-it .ft { flex: 1; min-width: 0; }
+.focus-it .ft { flex: 1; min-width: 0; display: flex; flex-direction: column; gap: 1px; }
+.focus-it .fx { color: var(--s1); }
+.focus-it .fw { font-size: 11.5px; color: var(--muted); }
+.focus-it .fd { border: 0; background: none; color: var(--muted); cursor: pointer; font-size: 12px;
+  padding: 2px 6px; border-radius: 6px; }
+.focus-it .fd:hover { background: var(--surface-2); color: var(--text); }
 .focus-it .fl { font-size: 10.5px; font-weight: 700; text-transform: uppercase; letter-spacing: .05em; }
 .focus-it.l1 .fl { color: var(--critical-ink); } .focus-it.l2 .fl { color: var(--warning-ink); }