claude-code-tracker 1.0.0 → 1.1.0

package/README.md

@@ -45,6 +45,16 @@ cd claude-code-tracker
 
 Restart Claude Code after any install method.
 
+### Backfilling historical sessions
+
+The installer automatically backfills all pre-existing sessions for the current project. If you run `install.sh` from inside a git repo, any transcripts that exist in `~/.claude/projects/` for that project will be parsed and added to `tokens.json` with their original dates. Re-running install won't create duplicates.
+
+To backfill manually (e.g. for a different project):
+
+```bash
+python3 ~/.claude/tracking/backfill.py /path/to/your/project
+```
+
 ---
 
 ## What gets created

package/install.sh

@@ -49,4 +49,27 @@ with open(settings_file, 'w') as f:
 print("Hook registered in", settings_file)
 PYEOF
 
+# Patch ~/.claude/CLAUDE.md — add tracking instruction if not present
+CLAUDE_MD="$HOME/.claude/CLAUDE.md"
+MARKER="planning session ends without implementation"
+if [ -f "$CLAUDE_MD" ] && grep -qF "$MARKER" "$CLAUDE_MD"; then
+  echo "CLAUDE.md tracking instruction already present."
+else
+  cat >> "$CLAUDE_MD" <<'MDEOF'
+- When a planning session ends without implementation (plan rejected, approach changed, or pure research), still write a tracking entry — mark it as architecture category and note what was decided against and why.
+MDEOF
+  echo "Tracking instruction added to $CLAUDE_MD"
+fi
+
+# Backfill historical sessions for the current project
+PROJECT_ROOT="$PWD"
+while [[ "$PROJECT_ROOT" != "/" ]]; do
+  [[ -d "$PROJECT_ROOT/.git" ]] && break
+  PROJECT_ROOT="$(dirname "$PROJECT_ROOT")"
+done
+if [[ "$PROJECT_ROOT" != "/" ]]; then
+  echo "Backfilling historical sessions..."
+  python3 "$INSTALL_DIR/backfill.py" "$PROJECT_ROOT"
+fi
+
 echo "claude-code-tracker installed. Restart Claude Code to activate."

package/package.json

@@ -1,18 +1,25 @@
 {
   "name": "claude-code-tracker",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Automatic token, cost, and prompt tracking for Claude Code sessions",
-  "keywords": ["claude", "claude-code", "anthropic", "tracking", "cost", "tokens"],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "anthropic",
+    "tracking",
+    "cost",
+    "tokens"
+  ],
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/kelsi-andrewss/claude-code-tracker"
+    "url": "git+https://github.com/kelsi-andrewss/claude-code-tracker.git"
   },
   "scripts": {
     "postinstall": "bash ./install.sh"
   },
   "bin": {
-    "claude-tracker-cost": "./src/cost-summary.py"
+    "claude-tracker-cost": "src/cost-summary.py"
   },
   "engines": {
     "node": ">=14"

package/src/backfill.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+"""
+Backfill historical Claude Code sessions into tokens.json.
+
+Usage:
+  python3 backfill.py <project_root>
+
+Scans ~/.claude/projects/<slug>/*.jsonl for transcripts belonging to the
+given project, parses token usage from each, and appends entries to
+<project_root>/.claude/tracking/tokens.json. Sessions already present
+are skipped.
+"""
+import sys, json, os, glob
+from datetime import datetime
+
+project_root = os.path.abspath(sys.argv[1])
+project_name = os.path.basename(project_root)
+tracking_dir = os.path.join(project_root, ".claude", "tracking")
+tokens_file = os.path.join(tracking_dir, "tokens.json")
+
+# Claude Code slugifies project paths: replace "/" with "-"
+slug = project_root.replace("/", "-")
+transcripts_dir = os.path.expanduser("~/.claude/projects/" + slug)
+
+if not os.path.isdir(transcripts_dir):
+    print("No transcript directory found, nothing to backfill.")
+    sys.exit(0)
+
+# Load existing data and build set of known session IDs
+data = []
+if os.path.exists(tokens_file):
+    try:
+        with open(tokens_file) as f:
+            data = json.load(f)
+    except Exception:
+        data = []
+
+known_ids = {e.get("session_id") for e in data}
+
+# Find all JSONL transcripts
+jsonl_files = sorted(glob.glob(os.path.join(transcripts_dir, "*.jsonl")))
+backfilled = 0
+
+for jf in jsonl_files:
+    session_id = os.path.splitext(os.path.basename(jf))[0]
+    if session_id in known_ids:
+        continue
+
+    # Parse token usage — same logic as stop-hook.sh
+    inp = out = cache_create = cache_read = 0
+    model = "unknown"
+    first_ts = None
+    last_ts = None
+
+    try:
+        with open(jf) as f:
+            for line in f:
+                try:
+                    obj = json.loads(line)
+                    ts = obj.get("timestamp")
+                    if ts:
+                        if first_ts is None:
+                            first_ts = ts
+                        last_ts = ts
+                    msg = obj.get("message", {})
+                    if isinstance(msg, dict) and msg.get("role") == "assistant":
+                        usage = msg.get("usage", {})
+                        if usage:
+                            inp += usage.get("input_tokens", 0)
+                            out += usage.get("output_tokens", 0)
+                            cache_create += usage.get("cache_creation_input_tokens", 0)
+                            cache_read += usage.get("cache_read_input_tokens", 0)
+                        m = msg.get("model", "")
+                        if m:
+                            model = m
+                except Exception:
+                    pass
+    except Exception:
+        continue
+
+    total = inp + cache_create + cache_read + out
+    if total == 0:
+        continue
+
+    # Date from first timestamp in the transcript
+    session_date = None
+    if first_ts:
+        try:
+            session_date = datetime.fromisoformat(
+                first_ts.replace("Z", "+00:00")
+            ).strftime("%Y-%m-%d")
+        except Exception:
+            pass
+    if not session_date:
+        session_date = datetime.fromtimestamp(os.path.getmtime(jf)).strftime("%Y-%m-%d")
+
+    # Duration
+    duration = 0
+    if first_ts and last_ts:
+        try:
+            t0 = datetime.fromisoformat(first_ts.replace("Z", "+00:00"))
+            t1 = datetime.fromisoformat(last_ts.replace("Z", "+00:00"))
+            duration = max(0, int((t1 - t0).total_seconds()))
+        except Exception:
+            pass
+
+    # Cost
+    if "opus" in model:
+        cost = inp * 15 / 1e6 + cache_create * 18.75 / 1e6 + cache_read * 1.50 / 1e6 + out * 75 / 1e6
+    else:
+        cost = inp * 3 / 1e6 + cache_create * 3.75 / 1e6 + cache_read * 0.30 / 1e6 + out * 15 / 1e6
+
+    entry = {
+        "date": session_date,
+        "project": project_name,
+        "session_id": session_id,
+        "input_tokens": inp,
+        "cache_creation_tokens": cache_create,
+        "cache_read_tokens": cache_read,
+        "output_tokens": out,
+        "total_tokens": total,
+        "estimated_cost_usd": round(cost, 4),
+        "model": model,
+        "duration_seconds": duration,
+    }
+
+    data.append(entry)
+    backfilled += 1
+
+# Write updated tokens.json
+if backfilled > 0:
+    os.makedirs(os.path.dirname(tokens_file), exist_ok=True)
+    with open(tokens_file, "w") as f:
+        json.dump(data, f, indent=2)
+        f.write("\n")
+
+print(f"{backfilled} session{'s' if backfilled != 1 else ''} backfilled.")
+
+# Regenerate charts if we added anything
+if backfilled > 0:
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    charts_html = os.path.join(tracking_dir, "charts.html")
+    os.system(f'python3 "{script_dir}/generate-charts.py" "{tokens_file}" "{charts_html}" 2>/dev/null')

package/src/cost-summary.py

@@ -3,25 +3,47 @@
 Usage:
   python3 cost-summary.py <tokens.json>
   python3 cost-summary.py  (defaults to .claude/tracking/tokens.json in cwd's git root)
+  python3 cost-summary.py --chart  (open tracking charts in browser)
 """
 import sys
 import json
 import os
+import webbrowser
 from collections import defaultdict
 from datetime import date
 
-def find_tokens_file():
-    cwd = os.getcwd()
-    root = cwd
+def find_git_root():
+    root = os.getcwd()
     while root != "/":
         if os.path.isdir(os.path.join(root, ".git")):
-            break
+            return root
         root = os.path.dirname(root)
+    return root
+
+def find_tokens_file():
+    root = find_git_root()
     path = os.path.join(root, ".claude", "tracking", "tokens.json")
     if os.path.exists(path):
         return path
     sys.exit(f"No tokens.json found at {path}")
 
+def format_duration(seconds):
+    if seconds <= 0:
+        return "0m"
+    h = seconds // 3600
+    m = (seconds % 3600) // 60
+    s = seconds % 60
+    if h > 0:
+        return f"{h}h {m}m"
+    return f"{m}m {s}s"
+
+if "--chart" in sys.argv:
+    chart = os.path.join(find_git_root(), ".claude", "tracking", "charts.html")
+    if not os.path.exists(chart):
+        sys.exit(f"No charts.html found at {chart} — run generate-charts.py first")
+    webbrowser.open(f"file://{chart}")
+    sys.exit(0)
+
 tokens_file = sys.argv[1] if len(sys.argv) > 1 else find_tokens_file()
 
 with open(tokens_file) as f:
@@ -32,7 +54,7 @@ if not data:
     sys.exit(0)
 
 # --- Aggregate ---
-by_date = defaultdict(lambda: {"cost": 0, "sessions": 0, "output": 0, "cache_read": 0, "cache_create": 0, "input": 0})
+by_date = defaultdict(lambda: {"cost": 0, "sessions": 0, "output": 0, "cache_read": 0, "cache_create": 0, "input": 0, "duration": 0})
 by_model = defaultdict(lambda: {"cost": 0, "sessions": 0})
 total_cost = 0
 total_sessions = len(data)
@@ -50,6 +72,7 @@ for e in data:
     by_date[d]["cache_read"] += e.get("cache_read_tokens", 0)
     by_date[d]["cache_create"] += e.get("cache_creation_tokens", 0)
     by_date[d]["input"] += e.get("input_tokens", 0)
+    by_date[d]["duration"] += e.get("duration_seconds", 0)
 
     by_model[short_model]["cost"] += cost
     by_model[short_model]["sessions"] += 1
@@ -70,11 +93,11 @@ print(f"  Cost Summary — {os.path.basename(os.path.dirname(os.path.dirname(tok
 print("=" * W)
 
 print(f"\nBy date:")
-print(f"  {'Date':<12} {'Sessions':>8} {'Output':>10} {'Cache Read':>12} {'Cost':>10}")
-print(f"  {'-'*12} {'-'*8} {'-'*10} {'-'*12} {'-'*10}")
+print(f"  {'Date':<12} {'Sessions':>8} {'Output':>10} {'Cache Read':>12} {'Duration':>10} {'Cost':>10}")
+print(f"  {'-'*12} {'-'*8} {'-'*10} {'-'*12} {'-'*10} {'-'*10}")
 for d in sorted(by_date):
     r = by_date[d]
-    print(f"  {d:<12} {r['sessions']:>8} {r['output']:>10,} {r['cache_read']:>12,} ${r['cost']:>9.2f}")
+    print(f"  {d:<12} {r['sessions']:>8} {r['output']:>10,} {r['cache_read']:>12,} {format_duration(r['duration']):>10} ${r['cost']:>9.2f}")
 
 print(f"\nBy model:")
 print(f"  {'Model':<30} {'Sessions':>8} {'Cost':>10}")
@@ -89,6 +112,8 @@ print(f"  Input tokens:      {total_input:>12,}")
 print(f"  Cache write:       {total_cache_create:>12,}")
 print(f"  Cache read:        {total_cache_read:>12,}")
 print(f"  Output tokens:     {total_output:>12,}")
+total_duration = sum(e.get("duration_seconds", 0) for e in data)
+print(f"  Session time:      {format_duration(total_duration):>12}")
 print(f"  Estimated cost:    ${total_cost:>11.2f}")
 
 if total_output > 0:

package/src/generate-charts.py

@@ -11,6 +11,16 @@ from collections import defaultdict
 tokens_file = sys.argv[1]
 output_file = sys.argv[2]
 
+def format_duration(seconds):
+    if seconds <= 0:
+        return "0m"
+    h = seconds // 3600
+    m = (seconds % 3600) // 60
+    s = seconds % 60
+    if h > 0:
+        return f"{h}h {m}m"
+    return f"{m}m {s}s"
+
 with open(tokens_file) as f:
     data = json.load(f)
 
@@ -20,11 +30,12 @@ if not data:
 # --- Aggregate by date ---
 by_date = defaultdict(lambda: {"cost": 0, "sessions": 0, "output": 0,
                                 "cache_read": 0, "cache_create": 0, "input": 0,
-                                "opus_cost": 0, "sonnet_cost": 0})
+                                "opus_cost": 0, "sonnet_cost": 0, "duration": 0})
 by_model = defaultdict(lambda: {"cost": 0, "sessions": 0})
 cumulative = []
 
 running_cost = 0
+running_duration = 0
 for e in sorted(data, key=lambda x: (x.get("date", ""), x.get("session_id", ""))):
     d = e.get("date", "unknown")
     cost = e.get("estimated_cost_usd", 0)
@@ -41,12 +52,15 @@ for e in sorted(data, key=lambda x: (x.get("date", ""), x.get("session_id", ""))
         by_date[d]["opus_cost"] += cost
     else:
         by_date[d]["sonnet_cost"] += cost
+    by_date[d]["duration"] += e.get("duration_seconds", 0)
 
     by_model[short]["cost"] += cost
     by_model[short]["sessions"] += 1
 
     running_cost += cost
+    running_duration += e.get("duration_seconds", 0)
     cumulative.append({"date": d, "cumulative_cost": round(running_cost, 4),
+                        "cumulative_duration": round(running_duration),
                         "session_id": e.get("session_id", "")[:8]})
 
 dates = sorted(by_date.keys())
@@ -57,16 +71,22 @@ total_output = sum(e.get("output_tokens", 0) for e in data)
 total_cache_read = sum(e.get("cache_read_tokens", 0) for e in data)
 total_all_tokens = sum(e.get("total_tokens", 0) for e in data)
 cache_pct = round(total_cache_read / total_all_tokens * 100, 1) if total_all_tokens > 0 else 0
+total_duration = sum(e.get("duration_seconds", 0) for e in data)
+avg_duration = total_duration // total_sessions if total_sessions > 0 else 0
 
 project_name = data[0].get("project", "Project") if data else "Project"
 
 # --- Count total human messages per date from JSONL transcripts ---
-project_dir = os.path.dirname(os.path.dirname(os.path.dirname(tokens_file)))  # project root
+project_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(tokens_file))))  # project root
 # Claude Code slugifies paths as: replace every "/" with "-" (keeping leading slash → leading dash)
 transcripts_dir = os.path.expanduser(
     "~/.claude/projects/" + project_dir.replace("/", "-")
 )
 human_by_date = defaultdict(int)
+trivial_by_date = defaultdict(int)
+
+def _is_trivial(text):
+    return len(text) < 40 and "?" not in text
 
 if os.path.isdir(transcripts_dir):
     for jf in glob.glob(os.path.join(transcripts_dir, "*.jsonl")):
@@ -97,24 +117,30 @@ if os.path.isdir(transcripts_dir):
                         content = obj.get("message", {}).get("content", "")
                         if isinstance(content, list):
                             # Skip pure tool-result messages
-                            has_real_text = any(
-                                isinstance(c, dict) and c.get("type") == "text"
+                            texts = [
+                                c.get("text", "") for c in content
+                                if isinstance(c, dict) and c.get("type") == "text"
                                 and not str(c.get("text", "")).strip().startswith("<")
-                                for c in content
-                            )
-                            if has_real_text:
+                            ]
+                            if texts:
+                                text = " ".join(texts).strip()
                                 human_by_date[session_date] += 1
+                                if _is_trivial(text):
+                                    trivial_by_date[session_date] += 1
                         elif isinstance(content, str):
                             text = content.strip()
                             # Skip slash commands and empty
                             if text and not text.startswith("<") and not text.startswith("/"):
                                 human_by_date[session_date] += 1
+                                if _is_trivial(text):
+                                    trivial_by_date[session_date] += 1
                     except:
                         pass
         except:
             pass
 
 total_human_msgs = sum(human_by_date.values())
+total_trivial_msgs = sum(trivial_by_date.values())
 
 # --- Aggregate prompt data from key-prompts/ folder ---
 prompts_dir = os.path.join(os.path.dirname(tokens_file), "key-prompts")
@@ -145,9 +171,49 @@ output_by_date_js = json.dumps([by_date[d]["output"] for d in dates])
 cache_read_by_date_js = json.dumps([by_date[d]["cache_read"] for d in dates])
 opus_by_date_js = json.dumps([round(by_date[d]["opus_cost"], 4) for d in dates])
 sonnet_by_date_js = json.dumps([round(by_date[d]["sonnet_cost"], 4) for d in dates])
+duration_by_date_js = json.dumps([by_date[d]["duration"] for d in dates])
 
 cumul_labels_js = json.dumps([f"{c['date']} #{i+1}" for i, c in enumerate(cumulative)])
 cumul_values_js = json.dumps([c["cumulative_cost"] for c in cumulative])
+cumul_duration_js = json.dumps([c["cumulative_duration"] for c in cumulative])
+
+avg_duration_by_date_js = json.dumps([
+    round(by_date[d]["duration"] / by_date[d]["sessions"])
+    if by_date[d]["sessions"] > 0 else 0
+    for d in dates
+])
+
+scatter_data_js = json.dumps([
+    {"x": e.get("duration_seconds", 0),
+     "y": round(e.get("estimated_cost_usd", 0), 4),
+     "label": f"{e.get('date', '')} {e.get('session_id', '')[:6]}"}
+    for e in sorted(data, key=lambda x: x.get("date", ""))
+    if e.get("duration_seconds", 0) > 0
+])
+
+# Tokens per minute per session (output tokens / duration in minutes)
+tpm_data_js = json.dumps([
+    {"x": e.get("duration_seconds", 0),
+     "y": round(e.get("output_tokens", 0) / (e["duration_seconds"] / 60), 1),
+     "label": f"{e.get('date', '')} {e.get('session_id', '')[:6]}"}
+    for e in sorted(data, key=lambda x: x.get("date", ""))
+    if e.get("duration_seconds", 0) > 0 and e.get("output_tokens", 0) > 0
+])
+
+# Duration histogram: bucket sessions into ranges
+_dur_buckets = [("0–2m", 0, 120), ("2–5m", 120, 300), ("5–15m", 300, 900),
+                ("15–30m", 900, 1800), ("30m+", 1800, None)]
+_dur_counts = {label: 0 for label, _, _ in _dur_buckets}
+for e in data:
+    d = e.get("duration_seconds", 0)
+    if d <= 0:
+        continue
+    for label, lo, hi in _dur_buckets:
+        if hi is None or d < hi:
+            _dur_counts[label] += 1
+            break
+dur_hist_labels_js = json.dumps([b[0] for b in _dur_buckets])
+dur_hist_values_js = json.dumps([_dur_counts[b[0]] for b in _dur_buckets])
 
 model_labels_js = json.dumps(list(by_model.keys()))
 model_costs_js = json.dumps([round(by_model[m]["cost"], 4) for m in by_model])
@@ -157,17 +223,21 @@ model_sessions_js = json.dumps([by_model[m]["sessions"] for m in by_model])
 all_prompt_dates = sorted(set(list(prompt_by_date.keys()) + list(human_by_date.keys())))
 all_prompt_dates_js = json.dumps(all_prompt_dates)
 total_msgs_by_date_js = json.dumps([human_by_date.get(d, 0) for d in all_prompt_dates])
+trivial_by_date_js = json.dumps([trivial_by_date.get(d, 0) for d in all_prompt_dates])
 key_prompts_by_date_js = json.dumps([prompt_by_date.get(d, {}).get("total", 0) for d in all_prompt_dates])
 
-# Efficiency ratio per date (key / total * 100), None if no messages
+# Efficiency ratio per date: key / (total - trivial) * 100, None if no non-trivial messages
 efficiency_by_date = []
 for d in all_prompt_dates:
     total = human_by_date.get(d, 0)
+    trivial = trivial_by_date.get(d, 0)
+    non_trivial = total - trivial
     key = prompt_by_date.get(d, {}).get("total", 0)
-    efficiency_by_date.append(round(key / total * 100, 1) if total > 0 else None)
+    efficiency_by_date.append(round(key / non_trivial * 100, 1) if non_trivial > 0 else None)
 efficiency_by_date_js = json.dumps(efficiency_by_date)
 
-overall_efficiency = round(total_prompts / total_human_msgs * 100, 1) if total_human_msgs > 0 else 0
+non_trivial_total = total_human_msgs - total_trivial_msgs
+overall_efficiency = round(total_prompts / non_trivial_total * 100, 1) if non_trivial_total > 0 else 0
 
 # Prompt chart data
 prompt_dates_js = json.dumps(prompt_dates)
@@ -219,14 +289,22 @@ html = f"""<!DOCTYPE html>
                   letter-spacing: 0.05em; margin-bottom: 4px; }}
   .stat-value {{ font-size: 1.4rem; font-weight: 700; color: #f8fafc; }}
   .stat-sub {{ font-size: 0.7rem; color: #94a3b8; margin-top: 2px; }}
+  .section {{ margin-bottom: 36px; }}
+  .section-header {{ font-size: 0.75rem; font-weight: 600; color: #64748b;
+                     text-transform: uppercase; letter-spacing: 0.08em;
+                     padding: 0 0 10px 12px; margin-bottom: 16px;
+                     border-bottom: 1px solid #2d3748; }}
+  .section-header.cost  {{ border-left: 3px solid #6366f1; color: #818cf8; }}
+  .section-header.time  {{ border-left: 3px solid #34d399; color: #34d399; }}
+  .section-header.prompts {{ border-left: 3px solid #a78bfa; color: #a78bfa; }}
   .grid {{ display: grid; grid-template-columns: 1fr 1fr; gap: 20px; }}
   .card {{ background: #1e2330; border: 1px solid #2d3748; border-radius: 10px;
            padding: 16px; }}
   .card.wide {{ grid-column: 1 / -1; }}
-  .card h2 {{ font-size: 0.8rem; font-weight: 600; color: #94a3b8;
+  .card h2 {{ font-size: 0.78rem; font-weight: 600; color: #94a3b8;
                text-transform: uppercase; letter-spacing: 0.05em; margin-bottom: 14px; }}
-  canvas {{ max-height: 220px; }}
-  .wide canvas {{ max-height: 180px; }}
+  canvas {{ max-height: 240px; }}
+  .wide canvas {{ max-height: 200px; }}
   .notice {{ font-size: 0.78rem; color: #94a3b8; background: #1e2330;
              border: 1px solid #3b4a6b; border-left: 3px solid #6366f1;
              border-radius: 6px; padding: 10px 14px; margin-bottom: 20px; }}
@@ -260,6 +338,11 @@ html = f"""<!DOCTYPE html>
     <div class="stat-value">{cache_pct}%</div>
     <div class="stat-sub">of all tokens</div>
   </div>
+  <div class="stat">
+    <div class="stat-label">Session time</div>
+    <div class="stat-value">{format_duration(total_duration)}</div>
+    <div class="stat-sub">avg {format_duration(avg_duration)} / session</div>
+  </div>
   <div class="stat">
     <div class="stat-label">Key prompts captured</div>
     <div class="stat-value">{total_prompts}</div>
@@ -268,64 +351,99 @@ html = f"""<!DOCTYPE html>
   <div class="stat">
     <div class="stat-label">Prompt efficiency</div>
     <div class="stat-value">{overall_efficiency}%</div>
-    <div class="stat-sub">key / total (higher = better)</div>
+    <div class="stat-sub">key / non-trivial (higher = better)</div>
   </div>
 </div>
 
-<div class="grid">
+<div class="section">
+  <div class="section-header cost">Cost &amp; Usage</div>
+  <div class="grid">
 
-  <div class="card wide">
-    <h2>Cumulative cost over sessions</h2>
-    <canvas id="cumul"></canvas>
-  </div>
+    <div class="card wide">
+      <h2>Cumulative cost</h2>
+      <canvas id="cumul"></canvas>
+    </div>
 
-  <div class="card">
-    <h2>Cost per day</h2>
-    <canvas id="costDay"></canvas>
-  </div>
+    <div class="card">
+      <h2>Cost per day</h2>
+      <canvas id="costDay"></canvas>
+    </div>
 
-  <div class="card">
-    <h2>Sessions per day</h2>
-    <canvas id="sessDay"></canvas>
-  </div>
+    <div class="card">
+      <h2>Sessions per day</h2>
+      <canvas id="sessDay"></canvas>
+    </div>
 
-  <div class="card">
-    <h2>Cost by model (stacked per day)</h2>
-    <canvas id="modelStack"></canvas>
-  </div>
+    <div class="card wide">
+      <h2>Cost by model</h2>
+      <canvas id="modelStack"></canvas>
+    </div>
 
-  <div class="card">
-    <h2>Output tokens per day</h2>
-    <canvas id="outputDay"></canvas>
   </div>
-
 </div>
 
-<h2 style="font-size:0.85rem;font-weight:600;color:#94a3b8;text-transform:uppercase;
-           letter-spacing:0.05em;margin:32px 0 16px">Key Prompts</h2>
+<div class="section">
+  <div class="section-header prompts">Key Prompts</div>
+  <div class="grid">
 
-<div class="grid">
+    <div class="card wide">
+      <h2>Prompts per day</h2>
+      <canvas id="promptsVsTotal"></canvas>
+    </div>
 
-  <div class="card wide">
-    <h2>Total prompts vs key prompts per day</h2>
-    <canvas id="promptsVsTotal"></canvas>
-  </div>
+    <div class="card">
+      <h2>Efficiency per day (%)</h2>
+      <canvas id="promptEfficiency"></canvas>
+    </div>
 
-  <div class="card">
-    <h2>Prompt efficiency per day (%)</h2>
-    <canvas id="promptEfficiency"></canvas>
-  </div>
+    <div class="card">
+      <h2>Category breakdown</h2>
+      <canvas id="promptDonut"></canvas>
+    </div>
 
-  <div class="card">
-    <h2>Category breakdown (all time)</h2>
-    <canvas id="promptDonut"></canvas>
-  </div>
+    <div class="card wide">
+      <h2>Categories per day</h2>
+      <canvas id="promptStack"></canvas>
+    </div>
 
-  <div class="card wide">
-    <h2>Category breakdown per day (stacked)</h2>
-    <canvas id="promptStack"></canvas>
   </div>
+</div>
+
+<div class="section">
+  <div class="section-header time">Time</div>
+  <div class="grid">
+
+    <div class="card">
+      <h2>Duration per day</h2>
+      <canvas id="durationDay"></canvas>
+    </div>
+
+    <div class="card">
+      <h2>Avg duration per day</h2>
+      <canvas id="avgDurationDay"></canvas>
+    </div>
+
+    <div class="card">
+      <h2>Tokens per minute</h2>
+      <canvas id="tokensPerMin"></canvas>
+    </div>
 
+    <div class="card">
+      <h2>Session length distribution</h2>
+      <canvas id="durationDist"></canvas>
+    </div>
+
+    <div class="card wide">
+      <h2>Cumulative time</h2>
+      <canvas id="cumulTime"></canvas>
+    </div>
+
+    <div class="card wide">
+      <h2>Time vs cost</h2>
+      <canvas id="timeVsCost"></canvas>
+    </div>
+
+  </div>
 </div>
 
 <script>
@@ -348,8 +466,26 @@ const DONUT_VALUES = {donut_values_js};
 const DONUT_COLORS = {donut_colors_js};
 const ALL_PROMPT_DATES = {all_prompt_dates_js};
 const TOTAL_MSGS_BY_DATE = {total_msgs_by_date_js};
+const TRIVIAL_BY_DATE = {trivial_by_date_js};
 const KEY_PROMPTS_BY_DATE = {key_prompts_by_date_js};
 const EFFICIENCY_BY_DATE = {efficiency_by_date_js};
+const DURATION_BY_DATE = {duration_by_date_js};
+const CUMUL_DURATION = {cumul_duration_js};
+const AVG_DURATION_BY_DATE = {avg_duration_by_date_js};
+const SCATTER_DATA = {scatter_data_js};
+const TPM_DATA = {tpm_data_js};
+const DUR_HIST_LABELS = {dur_hist_labels_js};
+const DUR_HIST_VALUES = {dur_hist_values_js};
+
+function formatDuration(s) {{
+  if (s <= 0) return '0s';
+  const h = Math.floor(s / 3600);
+  const m = Math.floor((s % 3600) / 60);
+  const sec = Math.round(s % 60);
+  if (h > 0) return h + 'h ' + m + 'm';
+  if (m > 0) return m + 'm' + (sec > 0 ? ' ' + sec + 's' : '');
+  return sec + 's';
+}}
 
 const GRID = '#2d3748';
 const TEXT = '#94a3b8';
@@ -415,15 +551,115 @@ new Chart(document.getElementById('modelStack'), {{
       tooltip: {{ callbacks: {{ label: ctx => ' $' + ctx.parsed.y.toFixed(2) }} }} }} }}
 }});
 
-// Output tokens per day
-new Chart(document.getElementById('outputDay'), {{
+// Session duration per day
+new Chart(document.getElementById('durationDay'), {{
   type: 'bar',
   data: {{
     labels: DATES,
-    datasets: [{{ label: 'Output tokens', data: OUTPUT_BY_DATE,
+    datasets: [{{ label: 'Duration', data: DURATION_BY_DATE,
+      backgroundColor: '#f59e0b', borderRadius: 4 }}]
+  }},
+  options: {{ ...baseOpts,
+    scales: {{ ...baseOpts.scales,
+      y: {{ ...baseOpts.scales.y,
+        ticks: {{ ...baseOpts.scales.y.ticks, callback: v => formatDuration(v) }} }} }},
+    plugins: {{ ...baseOpts.plugins,
+      tooltip: {{ callbacks: {{ label: ctx => ' ' + formatDuration(ctx.parsed.y) }} }} }} }}
+}});
+
+// Avg session duration per day
+new Chart(document.getElementById('avgDurationDay'), {{
+  type: 'line',
+  data: {{
+    labels: DATES,
+    datasets: [{{ label: 'Avg duration', data: AVG_DURATION_BY_DATE,
+      borderColor: '#a78bfa', backgroundColor: 'rgba(167,139,250,0.15)',
+      fill: true, tension: 0.3, pointRadius: 3 }}]
+  }},
+  options: {{ ...baseOpts,
+    scales: {{ ...baseOpts.scales,
+      y: {{ ...baseOpts.scales.y,
+        ticks: {{ ...baseOpts.scales.y.ticks, callback: v => formatDuration(v) }} }} }},
+    plugins: {{ ...baseOpts.plugins,
+      tooltip: {{ callbacks: {{ label: ctx => ' ' + formatDuration(ctx.parsed.y) }} }} }} }}
+}});
+
+// Cumulative time line
+new Chart(document.getElementById('cumulTime'), {{
+  type: 'line',
+  data: {{
+    labels: CUMUL_LABELS,
+    datasets: [{{ label: 'Cumulative time', data: CUMUL_DURATION,
+      borderColor: '#22d3ee', backgroundColor: 'rgba(34,211,238,0.15)',
+      fill: true, tension: 0.3, pointRadius: 2 }}]
+  }},
+  options: {{ ...baseOpts,
+    scales: {{ ...baseOpts.scales,
+      y: {{ ...baseOpts.scales.y,
+        ticks: {{ ...baseOpts.scales.y.ticks, callback: v => formatDuration(v) }} }} }},
+    plugins: {{ ...baseOpts.plugins,
+      tooltip: {{ callbacks: {{ label: ctx => ' ' + formatDuration(ctx.parsed.y) }} }} }} }}
+}});
+
+// Time vs cost scatter
+new Chart(document.getElementById('timeVsCost'), {{
+  type: 'scatter',
+  data: {{
+    datasets: [{{ label: 'Session', data: SCATTER_DATA,
+      backgroundColor: '#34d399', pointRadius: 5, pointHoverRadius: 7 }}]
+  }},
+  options: {{ ...baseOpts,
+    scales: {{ ...baseOpts.scales,
+      x: {{ ...baseOpts.scales.x, type: 'linear', min: 0,
+        ticks: {{ ...baseOpts.scales.x.ticks, callback: v => formatDuration(v) }},
+        title: {{ display: true, text: 'Duration', color: TEXT, font: {{ size: 10 }} }} }},
+      y: {{ ...baseOpts.scales.y,
+        ticks: {{ ...baseOpts.scales.y.ticks, callback: v => '$' + v.toFixed(2) }},
+        title: {{ display: true, text: 'Cost (USD)', color: TEXT, font: {{ size: 10 }} }} }} }},
+    plugins: {{ ...baseOpts.plugins,
+      tooltip: {{ callbacks: {{
+        label: ctx => {{
+          const d = ctx.raw;
+          return ` ${{d.label}}: ${{formatDuration(d.x)}} / $${{d.y.toFixed(4)}}`;
+        }}
+      }} }} }} }}
+}});
+
+// Tokens per minute scatter
+new Chart(document.getElementById('tokensPerMin'), {{
+  type: 'scatter',
+  data: {{
+    datasets: [{{ label: 'Session', data: TPM_DATA,
+      backgroundColor: '#818cf8', pointRadius: 5, pointHoverRadius: 7 }}]
+  }},
+  options: {{ ...baseOpts,
+    scales: {{ ...baseOpts.scales,
+      x: {{ ...baseOpts.scales.x, type: 'linear', min: 0,
+        ticks: {{ ...baseOpts.scales.x.ticks, callback: v => formatDuration(v) }},
+        title: {{ display: true, text: 'Duration', color: TEXT, font: {{ size: 10 }} }} }},
+      y: {{ ...baseOpts.scales.y,
+        title: {{ display: true, text: 'Output tokens / min', color: TEXT, font: {{ size: 10 }} }} }} }},
+    plugins: {{ ...baseOpts.plugins,
+      tooltip: {{ callbacks: {{
+        label: ctx => {{
+          const d = ctx.raw;
+          return ` ${{d.label}}: ${{formatDuration(d.x)}} — ${{d.y}} tok/min`;
+        }}
+      }} }} }} }}
+}});
+
+// Session length distribution histogram
+new Chart(document.getElementById('durationDist'), {{
+  type: 'bar',
+  data: {{
+    labels: DUR_HIST_LABELS,
+    datasets: [{{ label: 'Sessions', data: DUR_HIST_VALUES,
       backgroundColor: '#34d399', borderRadius: 4 }}]
   }},
-  options: baseOpts
+  options: {{ ...baseOpts,
+    plugins: {{ ...baseOpts.plugins, legend: {{ display: false }} }},
+    scales: {{ ...baseOpts.scales,
+      y: {{ ...baseOpts.scales.y, ticks: {{ ...baseOpts.scales.y.ticks, stepSize: 1 }} }} }} }}
 }});
 
 // Total vs key prompts per day
@@ -434,6 +670,8 @@ new Chart(document.getElementById('promptsVsTotal'), {{
     datasets: [
       {{ label: 'Total prompts', data: TOTAL_MSGS_BY_DATE,
          backgroundColor: 'rgba(148,163,184,0.35)', borderRadius: 4 }},
+      {{ label: 'Trivial prompts', data: TRIVIAL_BY_DATE,
+         backgroundColor: '#34d399', borderRadius: 4 }},
       {{ label: 'Key prompts', data: KEY_PROMPTS_BY_DATE,
          backgroundColor: '#a78bfa', borderRadius: 4 }}
     ]

package/src/patch-durations.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""
+Patch duration_seconds for existing tokens.json entries that have duration 0.
+
+Usage:
+  python3 patch-durations.py <project_root>
+"""
+import sys, json, os, glob
+from datetime import datetime
+
+project_root = os.path.abspath(sys.argv[1])
+tracking_dir = os.path.join(project_root, ".claude", "tracking")
+tokens_file = os.path.join(tracking_dir, "tokens.json")
+
+slug = project_root.replace("/", "-")
+transcripts_dir = os.path.expanduser("~/.claude/projects/" + slug)
+
+with open(tokens_file) as f:
+    data = json.load(f)
+
+patched = 0
+for entry in data:
+    sid = entry.get("session_id")
+    if not sid:
+        continue
+    jf = os.path.join(transcripts_dir, sid + ".jsonl")
+    if not os.path.exists(jf):
+        continue
+
+    msgs = []
+    try:
+        with open(jf) as f:
+            for line in f:
+                try:
+                    obj = json.loads(line)
+                    t = obj.get("type")
+                    ts = obj.get("timestamp")
+                    if t == "user" and not obj.get("isSidechain") and ts:
+                        msgs.append(("user", ts))
+                    elif t == "assistant" and ts:
+                        msgs.append(("assistant", ts))
+                except Exception:
+                    pass
+    except Exception:
+        continue
+
+    duration = 0
+    i = 0
+    while i < len(msgs):
+        if msgs[i][0] == "user":
+            j = i + 1
+            while j < len(msgs) and msgs[j][0] != "assistant":
+                j += 1
+            if j < len(msgs):
+                try:
+                    t0 = datetime.fromisoformat(msgs[i][1].replace("Z", "+00:00"))
+                    t1 = datetime.fromisoformat(msgs[j][1].replace("Z", "+00:00"))
+                    duration += max(0, int((t1 - t0).total_seconds()))
+                except Exception:
+                    pass
+        i += 1
+
+    if duration > 0:
+        entry["duration_seconds"] = duration
+        patched += 1
+        print(f"  {sid[:8]}  {duration}s")
+
+if patched > 0:
+    with open(tokens_file, "w") as f:
+        json.dump(data, f, indent=2)
+        f.write("\n")
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    charts_html = os.path.join(tracking_dir, "charts.html")
+    os.system(f'python3 "{script_dir}/generate-charts.py" "{tokens_file}" "{charts_html}" 2>/dev/null')
+
+print(f"{patched} session{'s' if patched != 1 else ''} patched.")

package/src/stop-hook.sh

@@ -33,7 +33,7 @@ fi
 # Parse token usage from JSONL and update tokens.json
 python3 - "$TRANSCRIPT" "$TRACKING_DIR/tokens.json" "$SESSION_ID" "$(basename "$PROJECT_ROOT")" <<'PYEOF'
 import sys, json, os
-from datetime import date
+from datetime import date, datetime
 
 transcript_path = sys.argv[1]
 tokens_file = sys.argv[2]
@@ -44,10 +44,17 @@ today = date.today().isoformat()
 # Sum all token usage from assistant messages in this session
 inp = out = cache_create = cache_read = 0
 model = "unknown"
+msgs = []
 with open(transcript_path) as f:
     for line in f:
         try:
             obj = json.loads(line)
+            t = obj.get('type')
+            ts = obj.get('timestamp')
+            if t == 'user' and not obj.get('isSidechain') and ts:
+                msgs.append(('user', ts))
+            elif t == 'assistant' and ts:
+                msgs.append(('assistant', ts))
             msg = obj.get('message', {})
             if isinstance(msg, dict) and msg.get('role') == 'assistant':
                 usage = msg.get('usage', {})
@@ -62,6 +69,23 @@ with open(transcript_path) as f:
         except:
             pass
 
+# Compute active time: sum of (first assistant reply - user message) per turn
+duration = 0
+i = 0
+while i < len(msgs):
+    if msgs[i][0] == 'user':
+        j = i + 1
+        while j < len(msgs) and msgs[j][0] != 'assistant':
+            j += 1
+        if j < len(msgs):
+            try:
+                t0 = datetime.fromisoformat(msgs[i][1].replace('Z', '+00:00'))
+                t1 = datetime.fromisoformat(msgs[j][1].replace('Z', '+00:00'))
+                duration += max(0, int((t1 - t0).total_seconds()))
+            except:
+                pass
+    i += 1
+
 total = inp + cache_create + cache_read + out
 if 'opus' in model:
     cost = inp * 15 / 1e6 + cache_create * 18.75 / 1e6 + cache_read * 1.50 / 1e6 + out * 75 / 1e6
@@ -88,7 +112,8 @@ entry = {
     "output_tokens": out,
     "total_tokens": total,
     "estimated_cost_usd": round(cost, 4),
-    "model": model
+    "model": model,
+    "duration_seconds": duration
 }
 
 # Update existing or append new