claude-finops 0.8.0 → 0.9.0

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/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
 
@@ -334,6 +335,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 +445,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)
@@ -673,6 +699,11 @@ 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,))
+        # Cowork transcripts live under the desktop app's own config dir, where
+        # `claude --resume` would not find them.
+        cowork = "local-agent-mode-sessions" in (s.get("source_file") or "")
+        s["resume"] = (f"claude --resume {sid}"
+                       if (s.get("agent") or "claude") == "claude" and not cowork else None)
         return s
 
     # ---------------- categories ----------------

package/finops/api.py

@@ -366,6 +366,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 +388,8 @@ 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 == "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/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.9.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/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})}
@@ -763,9 +776,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 +807,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 +827,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 +867,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 +920,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});

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);
+}