claude-code-tracker 1.1.6 → 1.2.0

package/install.sh

@@ -1,6 +1,14 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
+# Windows detection — native Windows shells (Git Bash, MSYS, Cygwin) won't work correctly
+if [[ "$OSTYPE" == msys* || "$OSTYPE" == cygwin* || -n "${WINDIR:-}" ]]; then
+  echo "Error: claude-code-tracker requires a Unix shell (macOS, Linux, or WSL)." >&2
+  echo "On Windows, install WSL and run this from a WSL terminal:" >&2
+  echo "  https://learn.microsoft.com/windows/wsl/install" >&2
+  exit 1
+fi
+
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 INSTALL_DIR="$HOME/.claude/tracking"
 SETTINGS="$HOME/.claude/settings.json"
@@ -47,14 +55,31 @@ hook_entry = {"type": "command", "command": hook_cmd, "timeout": 30, "async": Tr
 hooks = data.setdefault("hooks", {})
 stop_hooks = hooks.setdefault("Stop", [])
 
-# Check if already registered
-for group in stop_hooks:
-    for h in group.get("hooks", []):
-        if h.get("command") == hook_cmd:
-            print("Hook already registered.")
-            sys.exit(0)
+already_stop = any(
+    h.get("command") == hook_cmd
+    for group in stop_hooks for h in group.get("hooks", [])
+)
+if already_stop:
+    print("Hook already registered.")
+else:
+    stop_hooks.append({"hooks": [hook_entry]})
+
+# SessionStart hook
+backfill_cmd = hook_cmd + " --backfill-only"
+session_hooks = hooks.setdefault("SessionStart", [])
+already_session = any(
+    h.get("command") == backfill_cmd
+    for group in session_hooks for h in group.get("hooks", [])
+)
+if not already_session:
+    session_hooks.append({"hooks": [{"type": "command", "command": backfill_cmd, "timeout": 60, "async": True}]})
 
-stop_hooks.append({"hooks": [hook_entry]})
+# permissions.allow
+allow_entry = f"Bash({hook_cmd}*)"
+perms = data.setdefault("permissions", {})
+allow_list = perms.setdefault("allow", [])
+if allow_entry not in allow_list:
+    allow_list.append(allow_entry)
 
 os.makedirs(os.path.dirname(os.path.abspath(settings_file)), exist_ok=True)
 with open(settings_file, 'w') as f:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-tracker",
-  "version": "1.1.6",
+  "version": "1.2.0",
   "description": "Automatic token, cost, and prompt tracking for Claude Code sessions",
   "keywords": [
     "claude",

package/src/backfill.py

@@ -6,9 +6,11 @@ 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.
+given project, parses token usage from each turn, and upserts entries to
+<project_root>/.claude/tracking/tokens.json. Sessions where all turns are
+already present are skipped.
+
+Old-format entries (no turn_index field) are replaced with per-turn entries.
 """
 import sys, json, os, glob
 from datetime import datetime
@@ -26,7 +28,7 @@ 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
+# Load existing data
 data = []
 if os.path.exists(tokens_file):
     try:
@@ -35,22 +37,25 @@ if os.path.exists(tokens_file):
     except Exception:
         data = []
 
-known_ids = {e.get("session_id") for e in data}
+# Remove old-format entries (no turn_index) — they will be re-processed
+old_sessions = {e.get("session_id") for e in data if "turn_index" not in e}
+data = [e for e in data if "turn_index" in e]
 
-# Find all JSONL transcripts
-jsonl_files = sorted(glob.glob(os.path.join(transcripts_dir, "*.jsonl")))
-backfilled = 0
+# Build index of existing (session_id, turn_index) pairs
+existing_turns = {(e.get("session_id"), e.get("turn_index")) for e in data}
 
-for jf in jsonl_files:
-    session_id = os.path.splitext(os.path.basename(jf))[0]
-    if session_id in known_ids:
-        continue
+# Count turns per known session
+turns_per_session = {}
+for e in data:
+    sid = e.get("session_id")
+    turns_per_session[sid] = turns_per_session.get(sid, 0) + 1
 
-    # Parse token usage — same logic as stop-hook.sh
-    inp = out = cache_create = cache_read = 0
+def parse_turns(jf):
+    """Parse a JSONL transcript into per-turn entries. Returns list of dicts."""
+    msgs = []       # (role, timestamp)
+    usages = []     # usage dicts from assistant messages, in order
     model = "unknown"
     first_ts = None
-    last_ts = None
 
     try:
         with open(jf) as f:
@@ -58,31 +63,36 @@ for jf in jsonl_files:
                 try:
                     obj = json.loads(line)
                     ts = obj.get("timestamp")
-                    if ts:
-                        if first_ts is None:
-                            first_ts = ts
-                        last_ts = ts
+                    if ts and first_ts is None:
+                        first_ts = ts
+                    t = obj.get("type")
+                    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", {})
                         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)
+                            usages.append(usage)
                         m = msg.get("model", "")
                         if m:
                             model = m
                 except Exception:
                     pass
     except Exception:
-        continue
+        return [], None, "unknown"
 
-    total = inp + cache_create + cache_read + out
-    if total == 0:
-        continue
+    return msgs, first_ts, model, usages
 
-    # Date from first timestamp in the transcript
+def compute_turns(msgs, usages, first_ts, model, session_id, project_name):
+    """Convert message list + usages into per-turn entry dicts."""
+    entries = []
+    turn_index = 0
+    usage_index = 0
+    i = 0
+
+    # Date from first timestamp
     session_date = None
     if first_ts:
         try:
@@ -91,53 +101,132 @@ for jf in jsonl_files:
             ).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
+    while i < len(msgs):
+        if msgs[i][0] == "user":
+            user_ts = msgs[i][1]
+            j = i + 1
+            while j < len(msgs) and msgs[j][0] != "assistant":
+                j += 1
+            if j < len(msgs):
+                asst_ts = msgs[j][1]
+                # Consume next usage block for this turn
+                usage = {}
+                if usage_index < len(usages):
+                    usage = usages[usage_index]
+                    usage_index += 1
+
+                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)
+                total = inp + cache_create + cache_read + out
+
+                if total == 0:
+                    # Skip turns with no token data
+                    i = j + 1
+                    turn_index += 1
+                    continue
+
+                duration = 0
+                try:
+                    t0 = datetime.fromisoformat(user_ts.replace("Z", "+00:00"))
+                    t1 = datetime.fromisoformat(asst_ts.replace("Z", "+00:00"))
+                    duration = max(0, int((t1 - t0).total_seconds()))
+                except Exception:
+                    pass
+
+                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
+
+                # Turn timestamp = user message timestamp
+                turn_ts = user_ts
+                # Normalize to Z format
+                try:
+                    turn_ts = datetime.fromisoformat(user_ts.replace("Z", "+00:00")).strftime("%Y-%m-%dT%H:%M:%SZ")
+                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
+                # Use date from this turn's timestamp if possible
+                turn_date = session_date
+                try:
+                    turn_date = datetime.fromisoformat(user_ts.replace("Z", "+00:00")).strftime("%Y-%m-%d")
+                except Exception:
+                    pass
+
+                entries.append({
+                    "date": turn_date or session_date,
+                    "project": project_name,
+                    "session_id": session_id,
+                    "turn_index": turn_index,
+                    "turn_timestamp": turn_ts,
+                    "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,
+                })
+                turn_index += 1
+                i = j + 1
+            else:
+                i += 1
+        else:
+            i += 1
+
+    return entries
+
+# Find all JSONL transcripts
+jsonl_files = sorted(glob.glob(os.path.join(transcripts_dir, "*.jsonl")))
+new_entries = []
+sessions_processed = 0
+
+for jf in jsonl_files:
+    session_id = os.path.splitext(os.path.basename(jf))[0]
+
+    result = parse_turns(jf)
+    if len(result) == 4:
+        msgs, first_ts, model, usages = result
     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
+        continue
+
+    turn_entries = compute_turns(msgs, usages, first_ts, model, session_id, project_name)
+
+    if not turn_entries:
+        continue
+
+    expected_count = len(turn_entries)
+    existing_count = turns_per_session.get(session_id, 0)
+
+    # If all turns already present and session not in old-format set, skip
+    if existing_count >= expected_count and session_id not in old_sessions:
+        continue
+
+    # Upsert: replace any existing turns for this session with fresh data
+    data = [e for e in data if e.get("session_id") != session_id]
+    data.extend(turn_entries)
+    new_entries.extend(turn_entries)
+    sessions_processed += 1
+
+# Sort by (date, session_id, turn_index)
+data.sort(key=lambda x: (x.get("date", ""), x.get("session_id", ""), x.get("turn_index", 0)))
 
 # Write updated tokens.json
-if backfilled > 0:
+if new_entries:
     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.")
+total_turns = len(new_entries)
+print(f"{sessions_processed} session{'s' if sessions_processed != 1 else ''} processed, {total_turns} turn{'s' if total_turns != 1 else ''} written.")
 
 # Regenerate charts if we added anything
-if backfilled > 0:
+if new_entries:
     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

@@ -54,11 +54,13 @@ 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, "duration": 0})
-by_model = defaultdict(lambda: {"cost": 0, "sessions": 0})
+# Each entry is a turn. Sessions = unique session_ids. Prompts = total entries.
+by_date = defaultdict(lambda: {"cost": 0, "prompts": 0, "output": 0, "cache_read": 0, "cache_create": 0, "input": 0, "duration": 0})
+by_model = defaultdict(lambda: {"cost": 0, "prompts": 0})
 total_cost = 0
-total_sessions = len(data)
-sessions_with_tokens = 0
+total_turns = len(data)
+total_sessions = len({e.get("session_id") for e in data})
+sessions_with_tokens = len({e.get("session_id") for e in data if e.get("total_tokens", 0) > 0})
 
 for e in data:
     d = e.get("date", "unknown")
@@ -67,7 +69,7 @@ for e in data:
     short_model = model.split("-20")[0] if "-20" in model else model
 
     by_date[d]["cost"] += cost
-    by_date[d]["sessions"] += 1
+    by_date[d]["prompts"] += 1
     by_date[d]["output"] += e.get("output_tokens", 0)
     by_date[d]["cache_read"] += e.get("cache_read_tokens", 0)
     by_date[d]["cache_create"] += e.get("cache_creation_tokens", 0)
@@ -75,11 +77,9 @@ for e in data:
     by_date[d]["duration"] += e.get("duration_seconds", 0)
 
     by_model[short_model]["cost"] += cost
-    by_model[short_model]["sessions"] += 1
+    by_model[short_model]["prompts"] += 1
 
     total_cost += cost
-    if e.get("total_tokens", 0) > 0:
-        sessions_with_tokens += 1
 
 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)
@@ -93,27 +93,28 @@ 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} {'Duration':>10} {'Cost':>10}")
+print(f"  {'Date':<12} {'Prompts':>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,} {format_duration(r['duration']):>10} ${r['cost']:>9.2f}")
+    print(f"  {d:<12} {r['prompts']:>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}")
+print(f"  {'Model':<30} {'Prompts':>8} {'Cost':>10}")
 print(f"  {'-'*30} {'-'*8} {'-'*10}")
 for m in sorted(by_model, key=lambda x: -by_model[x]["cost"]):
     r = by_model[m]
-    print(f"  {m:<30} {r['sessions']:>8} ${r['cost']:>9.2f}")
+    print(f"  {m:<30} {r['prompts']:>8} ${r['cost']:>9.2f}")
 
 print(f"\nTotals:")
 print(f"  Sessions:          {total_sessions:>8}  ({sessions_with_tokens} with token data)")
+print(f"  Prompts:           {total_turns:>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"  Active time:       {format_duration(total_duration):>12}")
 print(f"  Estimated cost:    ${total_cost:>11.2f}")
 
 if total_output > 0:

package/src/generate-charts.py

@@ -28,22 +28,24 @@ if not data:
     sys.exit(0)
 
 # --- Aggregate by date ---
-by_date = defaultdict(lambda: {"cost": 0, "sessions": 0, "output": 0,
+# Each entry is a turn; group by date for bar charts, session_id for unique session count
+by_date = defaultdict(lambda: {"cost": 0, "turns": 0, "output": 0,
                                 "cache_read": 0, "cache_create": 0, "input": 0,
                                 "opus_cost": 0, "sonnet_cost": 0, "duration": 0})
-by_model = defaultdict(lambda: {"cost": 0, "sessions": 0})
+by_model = defaultdict(lambda: {"cost": 0, "turns": 0})
 cumulative = []
 
 running_cost = 0
 running_duration = 0
-for e in sorted(data, key=lambda x: (x.get("date", ""), x.get("session_id", ""))):
+sort_key = lambda x: (x.get("date", ""), x.get("session_id", ""), x.get("turn_index", 0))
+for e in sorted(data, key=sort_key):
     d = e.get("date", "unknown")
     cost = e.get("estimated_cost_usd", 0)
     model = e.get("model", "unknown")
     short = model.split("-20")[0] if "-20" in model else model
 
     by_date[d]["cost"] += cost
-    by_date[d]["sessions"] += 1
+    by_date[d]["turns"] += 1
     by_date[d]["output"] += e.get("output_tokens", 0)
     by_date[d]["cache_read"] += e.get("cache_read_tokens", 0)
     by_date[d]["cache_create"] += e.get("cache_creation_tokens", 0)
@@ -55,24 +57,26 @@ for e in sorted(data, key=lambda x: (x.get("date", ""), x.get("session_id", ""))
     by_date[d]["duration"] += e.get("duration_seconds", 0)
 
     by_model[short]["cost"] += cost
-    by_model[short]["sessions"] += 1
+    by_model[short]["turns"] += 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]})
+                        "session_id": e.get("session_id", "")[:8],
+                        "turn_index": e.get("turn_index", 0)})
 
 dates = sorted(by_date.keys())
 total_cost = sum(e.get("estimated_cost_usd", 0) for e in data)
-total_sessions = len(data)
-sessions_with_data = sum(1 for e in data if e.get("total_tokens", 0) > 0)
+total_turns = len(data)
+total_sessions = len({e.get("session_id") for e in data})
+sessions_with_data = len({e.get("session_id") for e in data if e.get("total_tokens", 0) > 0})
 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
+avg_duration = total_duration // total_turns if total_turns > 0 else 0
 
 project_name = data[0].get("project", "Project") if data else "Project"
 
@@ -166,43 +170,43 @@ total_prompts = sum(v["total"] for v in prompt_by_date.values())
 # Build JS data structures
 dates_js = json.dumps(dates)
 cost_by_date_js = json.dumps([round(by_date[d]["cost"], 4) for d in dates])
-sessions_by_date_js = json.dumps([by_date[d]["sessions"] for d in dates])
+sessions_by_date_js = json.dumps([by_date[d]["turns"] for d in dates])
 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_labels_js = json.dumps([f"{c['date']} {c['session_id']}#{c['turn_index']}" for c in 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
+    round(by_date[d]["duration"] / by_date[d]["turns"])
+    if by_date[d]["turns"] > 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", ""))
+     "label": f"{e.get('date', '')} {e.get('session_id', '')[:6]}#{e.get('turn_index', 0)}"}
+    for e in sorted(data, key=sort_key)
     if e.get("duration_seconds", 0) > 0
 ])
 
-# Tokens per minute per session (output tokens / duration in minutes)
+# Tokens per minute per turn (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", ""))
+     "label": f"{e.get('date', '')} {e.get('session_id', '')[:6]}#{e.get('turn_index', 0)}"}
+    for e in sorted(data, key=sort_key)
     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)]
+# Duration histogram: bucket turns into ranges
+_dur_buckets = [("<5s", 0, 5), ("5–15s", 5, 15), ("15–30s", 15, 30),
+                ("30s–2m", 30, 120), ("2m+", 120, None)]
 _dur_counts = {label: 0 for label, _, _ in _dur_buckets}
 for e in data:
     d = e.get("duration_seconds", 0)
@@ -217,7 +221,7 @@ 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])
-model_sessions_js = json.dumps([by_model[m]["sessions"] for m in by_model])
+model_sessions_js = json.dumps([by_model[m]["turns"] for m in by_model])
 
 # All dates union for prompts vs total chart
 all_prompt_dates = sorted(set(list(prompt_by_date.keys()) + list(human_by_date.keys())))
@@ -326,7 +330,7 @@ html = f"""<!DOCTYPE html>
   <div class="stat">
     <div class="stat-label">Sessions</div>
     <div class="stat-value">{total_sessions}</div>
-    <div class="stat-sub">{sessions_with_data} with token data</div>
+    <div class="stat-sub">{total_turns} prompts total</div>
   </div>
   <div class="stat">
     <div class="stat-label">Output tokens</div>
@@ -339,9 +343,9 @@ html = f"""<!DOCTYPE html>
     <div class="stat-sub">of all tokens</div>
   </div>
   <div class="stat">
-    <div class="stat-label">Session time</div>
+    <div class="stat-label">Active time</div>
     <div class="stat-value">{format_duration(total_duration)}</div>
-    <div class="stat-sub">avg {format_duration(avg_duration)} / session</div>
+    <div class="stat-sub">avg {format_duration(avg_duration)} / prompt</div>
   </div>
   <div class="stat">
     <div class="stat-label">Key prompts captured</div>
@@ -370,7 +374,7 @@ html = f"""<!DOCTYPE html>
     </div>
 
     <div class="card">
-      <h2>Sessions per day</h2>
+      <h2>Prompts per day</h2>
       <canvas id="sessDay"></canvas>
     </div>
 
@@ -429,7 +433,7 @@ html = f"""<!DOCTYPE html>
     </div>
 
     <div class="card">
-      <h2>Session length distribution</h2>
+      <h2>Prompt length distribution</h2>
       <canvas id="durationDist"></canvas>
     </div>
 
@@ -524,12 +528,12 @@ new Chart(document.getElementById('costDay'), {{
     tooltip: {{ callbacks: {{ label: ctx => ' $' + ctx.parsed.y.toFixed(2) }} }} }} }}
 }});
 
-// Sessions per day
+// Prompts per day
 new Chart(document.getElementById('sessDay'), {{
   type: 'bar',
   data: {{
     labels: DATES,
-    datasets: [{{ label: 'Sessions', data: SESSIONS_BY_DATE,
+    datasets: [{{ label: 'Prompts', data: SESSIONS_BY_DATE,
       backgroundColor: '#22d3ee', borderRadius: 4 }}]
   }},
   options: baseOpts
@@ -605,7 +609,7 @@ new Chart(document.getElementById('cumulTime'), {{
 new Chart(document.getElementById('timeVsCost'), {{
   type: 'scatter',
   data: {{
-    datasets: [{{ label: 'Session', data: SCATTER_DATA,
+    datasets: [{{ label: 'Prompt', data: SCATTER_DATA,
       backgroundColor: '#34d399', pointRadius: 5, pointHoverRadius: 7 }}]
   }},
   options: {{ ...baseOpts,
@@ -629,7 +633,7 @@ new Chart(document.getElementById('timeVsCost'), {{
 new Chart(document.getElementById('tokensPerMin'), {{
   type: 'scatter',
   data: {{
-    datasets: [{{ label: 'Session', data: TPM_DATA,
+    datasets: [{{ label: 'Prompt', data: TPM_DATA,
       backgroundColor: '#818cf8', pointRadius: 5, pointHoverRadius: 7 }}]
   }},
   options: {{ ...baseOpts,
@@ -648,12 +652,12 @@ new Chart(document.getElementById('tokensPerMin'), {{
       }} }} }} }}
 }});
 
-// Session length distribution histogram
+// Prompt length distribution histogram
 new Chart(document.getElementById('durationDist'), {{
   type: 'bar',
   data: {{
     labels: DUR_HIST_LABELS,
-    datasets: [{{ label: 'Sessions', data: DUR_HIST_VALUES,
+    datasets: [{{ label: 'Prompts', data: DUR_HIST_VALUES,
       backgroundColor: '#34d399', borderRadius: 4 }}]
   }},
   options: {{ ...baseOpts,

package/src/patch-durations.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 """
-Patch duration_seconds for existing tokens.json entries that have duration 0.
+Patch duration_seconds for per-turn entries that have duration 0,
+and migrate old single-entry-per-session entries to per-turn format.
 
 Usage:
   python3 patch-durations.py <project_root>
@@ -14,63 +15,187 @@ tokens_file = os.path.join(tracking_dir, "tokens.json")
 
 slug = project_root.replace("/", "-")
 transcripts_dir = os.path.expanduser("~/.claude/projects/" + slug)
+project_name = os.path.basename(project_root)
 
 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
-
+def parse_transcript(jf):
     msgs = []
+    usages = []
+    model = "unknown"
+    first_ts = None
     try:
         with open(jf) as f:
             for line in f:
                 try:
                     obj = json.loads(line)
-                    t = obj.get("type")
                     ts = obj.get("timestamp")
+                    if ts and first_ts is None:
+                        first_ts = ts
+                    t = obj.get("type")
                     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", {})
+                        if usage:
+                            usages.append(usage)
+                        m = msg.get("model", "")
+                        if m:
+                            model = m
                 except Exception:
                     pass
     except Exception:
+        pass
+    return msgs, usages, model, first_ts
+
+# Separate old-format (no turn_index) from new-format entries
+old_entries = [e for e in data if "turn_index" not in e]
+new_entries = [e for e in data if "turn_index" in e]
+
+# For new-format entries with duration 0, patch from transcript
+existing_keys = {(e.get("session_id"), e.get("turn_index")): i for i, e in enumerate(new_entries)}
+patched = 0
+
+for entry in new_entries:
+    if entry.get("duration_seconds", 0) > 0:
         continue
+    sid = entry.get("session_id")
+    turn_index = entry.get("turn_index", 0)
+    jf = os.path.join(transcripts_dir, sid + ".jsonl")
+    if not os.path.exists(jf):
+        continue
+
+    msgs, usages, model, first_ts = parse_transcript(jf)
 
-    duration = 0
+    # Walk to the target turn
+    ti = 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):
+            if j < len(msgs) and ti == turn_index:
                 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()))
+                    duration = max(0, int((t1 - t0).total_seconds()))
+                    if duration > 0:
+                        entry["duration_seconds"] = duration
+                        patched += 1
+                        print(f"  patched {sid[:8]}#{turn_index}  {duration}s")
                 except Exception:
                     pass
-        i += 1
+                break
+            if j < len(msgs):
+                ti += 1
+                i = j + 1
+            else:
+                i += 1
+        else:
+            i += 1
+
+# Migrate old-format entries to per-turn
+migrated_sessions = 0
+new_turn_entries = []
+for old_entry in old_entries:
+    sid = old_entry.get("session_id")
+    if not sid:
+        continue
+    jf = os.path.join(transcripts_dir, sid + ".jsonl")
+    if not os.path.exists(jf):
+        # Keep old entry as-is if we can't reprocess
+        new_entries.append(old_entry)
+        continue
+
+    msgs, usages, model, first_ts = parse_transcript(jf)
+
+    turn_index = 0
+    usage_index = 0
+    i = 0
+    session_date = old_entry.get("date")
+
+    while i < len(msgs):
+        if msgs[i][0] == "user":
+            user_ts = msgs[i][1]
+            j = i + 1
+            while j < len(msgs) and msgs[j][0] != "assistant":
+                j += 1
+            if j < len(msgs):
+                asst_ts = msgs[j][1]
+                usage = {}
+                if usage_index < len(usages):
+                    usage = usages[usage_index]
+                    usage_index += 1
+
+                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)
+                total = inp + cache_create + cache_read + out
+
+                if total > 0:
+                    duration = 0
+                    try:
+                        t0 = datetime.fromisoformat(user_ts.replace("Z", "+00:00"))
+                        t1 = datetime.fromisoformat(asst_ts.replace("Z", "+00:00"))
+                        duration = max(0, int((t1 - t0).total_seconds()))
+                    except Exception:
+                        pass
+
+                    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
+
+                    try:
+                        turn_ts = datetime.fromisoformat(user_ts.replace("Z", "+00:00")).strftime("%Y-%m-%dT%H:%M:%SZ")
+                        turn_date = datetime.fromisoformat(user_ts.replace("Z", "+00:00")).strftime("%Y-%m-%d")
+                    except Exception:
+                        turn_ts = user_ts
+                        turn_date = session_date
+
+                    new_turn_entries.append({
+                        "date": turn_date,
+                        "project": project_name,
+                        "session_id": sid,
+                        "turn_index": turn_index,
+                        "turn_timestamp": turn_ts,
+                        "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,
+                    })
+                turn_index += 1
+                i = j + 1
+            else:
+                i += 1
+        else:
+            i += 1
+
+    if turn_index > 0:
+        migrated_sessions += 1
+        print(f"  migrated {sid[:8]}  {turn_index} turn(s)")
+    else:
+        new_entries.append(old_entry)
 
-    if duration > 0:
-        entry["duration_seconds"] = duration
-        patched += 1
-        print(f"  {sid[:8]}  {duration}s")
+new_entries.extend(new_turn_entries)
+new_entries.sort(key=lambda x: (x.get("date", ""), x.get("session_id", ""), x.get("turn_index", 0)))
 
-if patched > 0:
+if patched > 0 or migrated_sessions > 0:
     with open(tokens_file, "w") as f:
-        json.dump(data, f, indent=2)
+        json.dump(new_entries, 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.")
+print(f"{patched} turn(s) patched, {migrated_sessions} session(s) migrated to per-turn format.")

package/src/stop-hook.sh

@@ -2,6 +2,25 @@
 set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# --backfill-only: run backfill for current project and exit (used by SessionStart hook)
+if [[ "${1:-}" == "--backfill-only" ]]; then
+  INPUT="$(cat)"
+  CWD="$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('cwd',''))" 2>/dev/null || true)"
+  if [[ -z "$CWD" ]]; then exit 0; fi
+  PROJECT_ROOT="$CWD"
+  while [[ "$PROJECT_ROOT" != "/" ]]; do
+    [[ -d "$PROJECT_ROOT/.git" ]] && break
+    PROJECT_ROOT="$(dirname "$PROJECT_ROOT")"
+  done
+  if [[ "$PROJECT_ROOT" == "/" ]]; then exit 0; fi
+  TRACKING_DIR="$PROJECT_ROOT/.claude/tracking"
+  if [[ -d "$TRACKING_DIR" ]]; then
+    python3 "$SCRIPT_DIR/backfill.py" "$PROJECT_ROOT" 2>/dev/null || true
+  fi
+  exit 0
+fi
+
 INPUT="$(cat)"
 
 # Prevent loops
@@ -25,26 +44,26 @@ if [[ "$PROJECT_ROOT" == "/" ]]; then exit 0; fi
 
 TRACKING_DIR="$PROJECT_ROOT/.claude/tracking"
 
-# Auto-initialize if missing
+# Auto-initialize if missing, then backfill
 if [[ ! -d "$TRACKING_DIR" ]]; then
   bash "$SCRIPT_DIR/init-templates.sh" "$TRACKING_DIR"
+  python3 "$SCRIPT_DIR/backfill.py" "$PROJECT_ROOT" 2>/dev/null || true
 fi
 
-# Parse token usage from JSONL and update tokens.json
+# Parse token usage from JSONL — emit one entry per turn, upsert into tokens.json
 python3 - "$TRANSCRIPT" "$TRACKING_DIR/tokens.json" "$SESSION_ID" "$(basename "$PROJECT_ROOT")" <<'PYEOF'
 import sys, json, os
-from datetime import date, datetime
+from datetime import datetime, date
 
 transcript_path = sys.argv[1]
 tokens_file = sys.argv[2]
 session_id = sys.argv[3]
 project_name = sys.argv[4]
-today = date.today().isoformat()
 
-# Sum all token usage from assistant messages in this session
-inp = out = cache_create = cache_read = 0
+msgs = []       # (role, timestamp)
+usages = []     # usage dicts from assistant messages, in order
 model = "unknown"
-msgs = []
+
 with open(transcript_path) as f:
     for line in f:
         try:
@@ -59,40 +78,84 @@ with open(transcript_path) as f:
             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)
+                    usages.append(usage)
                 m = msg.get('model', '')
                 if m:
                     model = m
         except:
             pass
 
-# Compute active time: sum of (first assistant reply - user message) per turn
-duration = 0
+# Build per-turn entries
+turn_entries = []
+turn_index = 0
+usage_index = 0
 i = 0
 while i < len(msgs):
     if msgs[i][0] == 'user':
+        user_ts = msgs[i][1]
         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
-else:
-    cost = inp * 3 / 1e6 + cache_create * 3.75 / 1e6 + cache_read * 0.30 / 1e6 + out * 15 / 1e6
-
-# Load or create tokens.json
+            asst_ts = msgs[j][1]
+            usage = {}
+            if usage_index < len(usages):
+                usage = usages[usage_index]
+                usage_index += 1
+
+            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)
+            total = inp + cache_create + cache_read + out
+
+            if total > 0:
+                duration = 0
+                try:
+                    t0 = datetime.fromisoformat(user_ts.replace('Z', '+00:00'))
+                    t1 = datetime.fromisoformat(asst_ts.replace('Z', '+00:00'))
+                    duration = max(0, int((t1 - t0).total_seconds()))
+                except:
+                    pass
+
+                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
+
+                try:
+                    turn_ts = datetime.fromisoformat(user_ts.replace('Z', '+00:00')).strftime('%Y-%m-%dT%H:%M:%SZ')
+                    turn_date = datetime.fromisoformat(user_ts.replace('Z', '+00:00')).strftime('%Y-%m-%d')
+                except:
+                    turn_ts = user_ts
+                    turn_date = date.today().isoformat()
+
+                turn_entries.append({
+                    'date': turn_date,
+                    'project': project_name,
+                    'session_id': session_id,
+                    'turn_index': turn_index,
+                    'turn_timestamp': turn_ts,
+                    '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,
+                })
+            turn_index += 1
+            i = j + 1
+        else:
+            i += 1
+    else:
+        i += 1
+
+if not turn_entries:
+    sys.exit(0)
+
+# Load existing data
 data = []
 if os.path.exists(tokens_file):
     try:
@@ -101,30 +164,39 @@ if os.path.exists(tokens_file):
     except:
         data = []
 
-# Build entry
-entry = {
-    "date": today,
-    "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
-}
-
-# Update existing or append new
-found = False
-for i, e in enumerate(data):
-    if e.get('session_id') == session_id:
-        data[i] = entry
-        found = True
+# Build index of existing (session_id, turn_index) -> position
+existing_idx = {}
+for pos, e in enumerate(data):
+    key = (e.get('session_id'), e.get('turn_index'))
+    existing_idx[key] = pos
+
+# Check if anything actually changed
+changed = False
+for entry in turn_entries:
+    key = (entry['session_id'], entry['turn_index'])
+    if key not in existing_idx:
+        changed = True
         break
-if not found:
-    data.append(entry)
+    existing = data[existing_idx[key]]
+    if (existing.get('total_tokens') != entry['total_tokens'] or
+        existing.get('output_tokens') != entry['output_tokens']):
+        changed = True
+        break
+
+if not changed:
+    sys.exit(0)
+
+# Upsert: update existing entries or append new ones
+for entry in turn_entries:
+    key = (entry['session_id'], entry['turn_index'])
+    if key in existing_idx:
+        data[existing_idx[key]] = entry
+    else:
+        data.append(entry)
+        existing_idx[key] = len(data) - 1
+
+# Sort by (date, session_id, turn_index)
+data.sort(key=lambda x: (x.get('date', ''), x.get('session_id', ''), x.get('turn_index', 0)))
 
 with open(tokens_file, 'w') as f:
     json.dump(data, f, indent=2)