claude-code-tracker 1.2.3 → 1.4.0-beta.3

package/src/stop-hook.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+'use strict';
+const { execFileSync, spawnSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const scriptDir = path.dirname(path.resolve(__filename));
+const bashScript = path.join(scriptDir, 'stop-hook.sh');
+
+// On Windows, run via bash (Git Bash / WSL); on Unix, run directly
+const input = fs.readFileSync(process.stdin.fd, 'utf8');
+
+if (process.platform === 'win32') {
+  const result = spawnSync('bash', [bashScript], {
+    input,
+    stdio: ['pipe', 'inherit', 'inherit'],
+    shell: false,
+  });
+  process.exit(result.status || 0);
+} else {
+  const result = spawnSync('bash', [bashScript], {
+    input,
+    stdio: ['pipe', 'inherit', 'inherit'],
+  });
+  process.exit(result.status || 0);
+}

package/src/stop-hook.sh

@@ -50,161 +50,29 @@ if [[ ! -d "$TRACKING_DIR" ]]; then
   python3 "$SCRIPT_DIR/backfill.py" "$PROJECT_ROOT" 2>/dev/null || true
 fi
 
-# 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 datetime, date
+# Parse token usage from JSONL and write to SQLite
+python3 "$SCRIPT_DIR/write-turns.py" "$TRANSCRIPT" "$TRACKING_DIR" "$SESSION_ID" "$(basename "$PROJECT_ROOT")"
 
-transcript_path = sys.argv[1]
-tokens_file = sys.argv[2]
-session_id = sys.argv[3]
-project_name = sys.argv[4]
+# Parse friction events from JSONL
+python3 "$SCRIPT_DIR/parse_friction.py" "$TRANSCRIPT" "$TRACKING_DIR/friction.json" \
+  "$SESSION_ID" "$(basename "$PROJECT_ROOT")" "main" 2>/dev/null || true
 
-msgs = []       # (role, timestamp)
-usages = []     # usage dicts from assistant messages, in order
-model = "unknown"
-
-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', {})
-                if usage:
-                    usages.append(usage)
-                m = msg.get('model', '')
-                if m:
-                    model = m
-        except:
-            pass
-
-# 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):
-            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:
-        with open(tokens_file) as f:
-            data = json.load(f)
-    except:
-        data = []
-
-# 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
-    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)
-    f.write('\n')
-PYEOF
+# Parse skill invocations from JSONL
+python3 "$SCRIPT_DIR/parse_skills.py" "$TRANSCRIPT" "$TRACKING_DIR" \
+  "$SESSION_ID" "$(basename "$PROJECT_ROOT")" 2>/dev/null || true
 
 # Regenerate charts
-python3 "$SCRIPT_DIR/generate-charts.py" "$TRACKING_DIR/tokens.json" "$TRACKING_DIR/charts.html" 2>/dev/null || true
+python3 "$SCRIPT_DIR/generate-charts.py" "$TRACKING_DIR" "$TRACKING_DIR/charts.html" 2>/dev/null || true
+
+# Regenerate key-prompts index + shadow to OpenMemory
+OM_DB="$HOME/.claude/.claude/openmemory.sqlite"
+LEARNINGS="$HOME/.claude/tool-learnings.md"
+OM_ARGS=""
+if [[ -f "$OM_DB" ]]; then
+  OM_ARGS="--om-db $OM_DB"
+  if [[ -f "$LEARNINGS" ]]; then
+    OM_ARGS="$OM_ARGS --learnings $LEARNINGS"
+  fi
+fi
+python3 "$SCRIPT_DIR/update-prompts-index.py" "$TRACKING_DIR" $OM_ARGS 2>/dev/null || true
 
-# Regenerate key-prompts index
-python3 "$SCRIPT_DIR/update-prompts-index.py" "$TRACKING_DIR" 2>/dev/null || true

package/src/storage.py

@@ -0,0 +1,397 @@
+#!/usr/bin/env python3
+"""SQLite storage module for Claude Code Tracker.
+
+Flat-function API for all DB operations. Replaces flat JSON file storage
+with a WAL-mode SQLite backend. Handles auto-migration from existing
+tokens.json / agents.json on first access.
+"""
+import json
+import os
+import sqlite3
+import sys
+from datetime import datetime, timezone
+from typing import Optional
+
+DB_NAME = "tracking.db"
+
+TURN_COLS = [
+    "session_id", "turn_index", "date", "project", "turn_timestamp",
+    "input_tokens", "cache_creation_tokens", "cache_read_tokens",
+    "output_tokens", "total_tokens", "estimated_cost_usd", "model",
+    "duration_seconds",
+]
+
+TURN_DEFAULTS = {
+    "turn_timestamp": None,
+    "input_tokens": 0,
+    "cache_creation_tokens": 0,
+    "cache_read_tokens": 0,
+    "output_tokens": 0,
+    "total_tokens": 0,
+    "estimated_cost_usd": 0,
+    "model": "unknown",
+    "duration_seconds": 0,
+}
+
+AGENT_COLS = [
+    "timestamp", "session_id", "agent_id", "agent_type",
+    "input_tokens", "output_tokens", "cache_creation_tokens",
+    "cache_read_tokens", "total_tokens", "turns",
+    "estimated_cost_usd", "model",
+]
+
+AGENT_DEFAULTS = {
+    "agent_type": "unknown",
+    "input_tokens": 0,
+    "output_tokens": 0,
+    "cache_creation_tokens": 0,
+    "cache_read_tokens": 0,
+    "total_tokens": 0,
+    "turns": 0,
+    "estimated_cost_usd": 0,
+    "model": "unknown",
+}
+
+SKILL_COLS = [
+    "session_id", "date", "project", "skill_name", "args",
+    "tool_use_id", "timestamp", "duration_seconds",
+    "success", "error_message",
+]
+
+SKILL_DEFAULTS = {
+    "args": None,
+    "tool_use_id": None,
+    "timestamp": None,
+    "duration_seconds": 0,
+    "success": 1,
+    "error_message": None,
+}
+
+SCHEMA_SQL = """\
+CREATE TABLE IF NOT EXISTS turns (
+    session_id TEXT NOT NULL,
+    turn_index INTEGER NOT NULL,
+    date TEXT NOT NULL,
+    project TEXT NOT NULL,
+    turn_timestamp TEXT,
+    input_tokens INTEGER DEFAULT 0,
+    cache_creation_tokens INTEGER DEFAULT 0,
+    cache_read_tokens INTEGER DEFAULT 0,
+    output_tokens INTEGER DEFAULT 0,
+    total_tokens INTEGER DEFAULT 0,
+    estimated_cost_usd REAL DEFAULT 0,
+    model TEXT DEFAULT 'unknown',
+    duration_seconds INTEGER DEFAULT 0,
+    PRIMARY KEY (session_id, turn_index)
+);
+CREATE INDEX IF NOT EXISTS idx_turns_date ON turns(date);
+
+CREATE TABLE IF NOT EXISTS agents (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    timestamp TEXT NOT NULL,
+    session_id TEXT NOT NULL,
+    agent_id TEXT NOT NULL,
+    agent_type TEXT DEFAULT 'unknown',
+    input_tokens INTEGER DEFAULT 0,
+    output_tokens INTEGER DEFAULT 0,
+    cache_creation_tokens INTEGER DEFAULT 0,
+    cache_read_tokens INTEGER DEFAULT 0,
+    total_tokens INTEGER DEFAULT 0,
+    turns INTEGER DEFAULT 0,
+    estimated_cost_usd REAL DEFAULT 0,
+    model TEXT DEFAULT 'unknown'
+);
+CREATE INDEX IF NOT EXISTS idx_agents_session ON agents(session_id);
+
+CREATE TABLE IF NOT EXISTS skills (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id TEXT NOT NULL,
+    date TEXT NOT NULL,
+    project TEXT NOT NULL,
+    skill_name TEXT NOT NULL,
+    args TEXT,
+    tool_use_id TEXT,
+    timestamp TEXT,
+    duration_seconds INTEGER DEFAULT 0,
+    success INTEGER DEFAULT 1,
+    error_message TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_skills_session ON skills(session_id);
+CREATE INDEX IF NOT EXISTS idx_skills_name ON skills(skill_name);
+
+CREATE TABLE IF NOT EXISTS metadata (
+    key TEXT PRIMARY KEY,
+    value TEXT
+);
+"""
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+def _db_path(tracking_dir: str) -> str:
+    return os.path.join(tracking_dir, DB_NAME)
+
+
+def _insert_turns(conn: sqlite3.Connection, entries: list[dict]) -> None:
+    """INSERT OR REPLACE turns via executemany."""
+    placeholders = ", ".join(["?"] * len(TURN_COLS))
+    sql = f"INSERT OR REPLACE INTO turns ({', '.join(TURN_COLS)}) VALUES ({placeholders})"
+    rows = []
+    for e in entries:
+        rows.append(tuple(e.get(col, TURN_DEFAULTS.get(col)) for col in TURN_COLS))
+    if rows:
+        conn.executemany(sql, rows)
+
+
+def _insert_agents(conn: sqlite3.Connection, entries: list[dict]) -> None:
+    """INSERT agents via executemany (always appends — autoincrement id)."""
+    placeholders = ", ".join(["?"] * len(AGENT_COLS))
+    sql = f"INSERT INTO agents ({', '.join(AGENT_COLS)}) VALUES ({placeholders})"
+    rows = []
+    for e in entries:
+        rows.append(tuple(e.get(col, AGENT_DEFAULTS.get(col)) for col in AGENT_COLS))
+    if rows:
+        conn.executemany(sql, rows)
+
+
+def _insert_skills(conn: sqlite3.Connection, entries: list[dict]) -> None:
+    """INSERT skills via executemany (always appends — autoincrement id)."""
+    placeholders = ", ".join(["?"] * len(SKILL_COLS))
+    sql = f"INSERT INTO skills ({', '.join(SKILL_COLS)}) VALUES ({placeholders})"
+    rows = []
+    for e in entries:
+        rows.append(tuple(e.get(col, SKILL_DEFAULTS.get(col)) for col in SKILL_COLS))
+    if rows:
+        conn.executemany(sql, rows)
+
+
+def _maybe_migrate(conn: sqlite3.Connection, tracking_dir: str) -> None:
+    """One-time migration from JSON files to SQLite.
+
+    Checks metadata for 'migrated_at'. If absent and JSON files exist,
+    imports their data, stamps metadata, and renames .json -> .json.migrated.
+    """
+    row = conn.execute(
+        "SELECT value FROM metadata WHERE key = 'migrated_at'"
+    ).fetchone()
+    if row is not None:
+        return
+
+    tokens_path = os.path.join(tracking_dir, "tokens.json")
+    agents_path = os.path.join(tracking_dir, "agents.json")
+
+    if os.path.exists(tokens_path):
+        try:
+            with open(tokens_path, encoding="utf-8") as f:
+                data = json.load(f)
+            if data:
+                _insert_turns(conn, data)
+        except (json.JSONDecodeError, OSError):
+            pass
+
+    if os.path.exists(agents_path):
+        try:
+            with open(agents_path, encoding="utf-8") as f:
+                data = json.load(f)
+            if data:
+                _insert_agents(conn, data)
+        except (json.JSONDecodeError, OSError):
+            pass
+
+    now = datetime.now(timezone.utc).isoformat()
+    conn.execute(
+        "INSERT OR REPLACE INTO metadata (key, value) VALUES (?, ?)",
+        ("schema_version", "1"),
+    )
+    conn.execute(
+        "INSERT OR REPLACE INTO metadata (key, value) VALUES (?, ?)",
+        ("migrated_at", now),
+    )
+    conn.commit()
+
+    # Rename originals so migration won't re-run even without the metadata check
+    for path in (tokens_path, agents_path):
+        if os.path.exists(path):
+            try:
+                os.rename(path, path + ".migrated")
+            except OSError:
+                pass
+
+
+# ---------------------------------------------------------------------------
+# Core DB access
+# ---------------------------------------------------------------------------
+
+def init_db(tracking_dir: str) -> None:
+    """Create the database and tables. Safe to call repeatedly."""
+    os.makedirs(tracking_dir, exist_ok=True)
+    path = _db_path(tracking_dir)
+    conn = sqlite3.connect(path)
+    try:
+        try:
+            conn.execute("PRAGMA journal_mode=WAL")
+        except sqlite3.OperationalError:
+            conn.execute("PRAGMA journal_mode=DELETE")
+        conn.execute("PRAGMA synchronous=NORMAL")
+        conn.executescript(SCHEMA_SQL)
+        conn.commit()
+    finally:
+        conn.close()
+
+
+def get_db(tracking_dir: str) -> sqlite3.Connection:
+    """Open (or create) the database and return a connection.
+
+    Sets row_factory=Row, WAL mode, synchronous=NORMAL, and runs migration
+    if needed. Caller should use as context manager: ``with get_db(d) as conn:``.
+    """
+    path = _db_path(tracking_dir)
+    if not os.path.exists(path):
+        init_db(tracking_dir)
+    conn = sqlite3.connect(path)
+    conn.row_factory = sqlite3.Row
+    try:
+        conn.execute("PRAGMA journal_mode=WAL")
+    except sqlite3.OperationalError:
+        conn.execute("PRAGMA journal_mode=DELETE")
+    conn.execute("PRAGMA synchronous=NORMAL")
+    conn.executescript(SCHEMA_SQL)
+    _maybe_migrate(conn, tracking_dir)
+    return conn
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def upsert_turns(tracking_dir: str, entries: list[dict]) -> int:
+    """INSERT OR REPLACE turn entries. Returns number of rows affected."""
+    with get_db(tracking_dir) as conn:
+        _insert_turns(conn, entries)
+        conn.commit()
+    return len(entries)
+
+
+def append_agent(tracking_dir: str, entry: dict) -> None:
+    """Append a single agent entry."""
+    with get_db(tracking_dir) as conn:
+        _insert_agents(conn, [entry])
+        conn.commit()
+
+
+def get_all_turns(tracking_dir: str) -> list[dict]:
+    """Return all turn rows as dicts, ordered by date, session_id, turn_index."""
+    with get_db(tracking_dir) as conn:
+        rows = conn.execute(
+            "SELECT * FROM turns ORDER BY date, session_id, turn_index"
+        ).fetchall()
+    return [dict(r) for r in rows]
+
+
+def get_all_agents(tracking_dir: str) -> list[dict]:
+    """Return all agent rows as dicts (without the autoincrement id), ordered by id."""
+    with get_db(tracking_dir) as conn:
+        rows = conn.execute("SELECT * FROM agents ORDER BY id").fetchall()
+    result = []
+    for r in rows:
+        d = dict(r)
+        d.pop("id", None)
+        result.append(d)
+    return result
+
+
+def replace_session_skills(
+    tracking_dir: str, session_id: str, entries: list[dict]
+) -> None:
+    """Delete all skills for a session and insert replacements atomically."""
+    with get_db(tracking_dir) as conn:
+        conn.execute("DELETE FROM skills WHERE session_id = ?", (session_id,))
+        _insert_skills(conn, entries)
+        conn.commit()
+
+
+def get_all_skills(tracking_dir: str) -> list[dict]:
+    """Return all skill rows as dicts (without the autoincrement id), ordered by id."""
+    with get_db(tracking_dir) as conn:
+        rows = conn.execute("SELECT * FROM skills ORDER BY id").fetchall()
+    result = []
+    for r in rows:
+        d = dict(r)
+        d.pop("id", None)
+        result.append(d)
+    return result
+
+
+def count_turns_for_session(tracking_dir: str, session_id: str) -> int:
+    """Return the number of turns for a given session."""
+    with get_db(tracking_dir) as conn:
+        row = conn.execute(
+            "SELECT COUNT(*) FROM turns WHERE session_id = ?", (session_id,)
+        ).fetchone()
+    return row[0]
+
+
+def replace_session_turns(
+    tracking_dir: str, session_id: str, entries: list[dict]
+) -> None:
+    """Delete all turns for a session and insert replacements atomically."""
+    with get_db(tracking_dir) as conn:
+        conn.execute("DELETE FROM turns WHERE session_id = ?", (session_id,))
+        _insert_turns(conn, entries)
+        conn.commit()
+
+
+def patch_turn_duration(
+    tracking_dir: str, session_id: str, turn_index: int, duration: int
+) -> None:
+    """Update duration_seconds for a specific turn."""
+    with get_db(tracking_dir) as conn:
+        conn.execute(
+            "UPDATE turns SET duration_seconds = ? "
+            "WHERE session_id = ? AND turn_index = ?",
+            (duration, session_id, turn_index),
+        )
+        conn.commit()
+
+
+def get_session_turns(tracking_dir: str, session_id: str) -> list[dict]:
+    """Return turns for a specific session, ordered by turn_index."""
+    with get_db(tracking_dir) as conn:
+        rows = conn.execute(
+            "SELECT * FROM turns WHERE session_id = ? ORDER BY turn_index",
+            (session_id,),
+        ).fetchall()
+    return [dict(r) for r in rows]
+
+
+def export_json(
+    tracking_dir: str,
+    tokens_path: Optional[str] = None,
+    agents_path: Optional[str] = None,
+) -> None:
+    """Export turns and/or agents tables to JSON files."""
+    if tokens_path is not None:
+        data = get_all_turns(tracking_dir)
+        with open(tokens_path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2)
+            f.write("\n")
+
+    if agents_path is not None:
+        data = get_all_agents(tracking_dir)
+        with open(agents_path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2)
+            f.write("\n")
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    if len(sys.argv) < 3 or sys.argv[1] != "--init":
+        print(f"Usage: {sys.argv[0]} --init <tracking_dir>", file=sys.stderr)
+        sys.exit(1)
+    init_db(sys.argv[2])
+    print(f"Initialized {os.path.join(sys.argv[2], DB_NAME)}")

package/src/subagent-stop-hook.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+INPUT="$(cat)"
+
+# Extract fields from SubagentStop payload
+CWD="$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('cwd',''))" 2>/dev/null || true)"
+TRANSCRIPT="$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('agent_transcript_path',''))" 2>/dev/null || true)"
+SESSION_ID="$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('session_id',''))" 2>/dev/null || true)"
+AGENT_ID="$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('agent_id',''))" 2>/dev/null || true)"
+AGENT_TYPE="$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('agent_type','unknown'))" 2>/dev/null || true)"
+
+if [[ -z "$CWD" || -z "$TRANSCRIPT" || ! -f "$TRANSCRIPT" ]]; then exit 0; fi
+
+# Find project root (walk up to .git)
+PROJECT_ROOT="$CWD"
+while [[ "$PROJECT_ROOT" != "/" ]]; do
+  [[ -e "$PROJECT_ROOT/.git" ]] && break
+  PROJECT_ROOT="$(dirname "$PROJECT_ROOT")"
+done
+if [[ "$PROJECT_ROOT" == "/" ]]; then exit 0; fi
+
+TRACKING_DIR="$PROJECT_ROOT/.claude/tracking"
+# Only run if tracking is already initialized — don't auto-init from subagent hook
+if [[ ! -d "$TRACKING_DIR" ]]; then exit 0; fi
+
+# Parse token usage from subagent JSONL and write to SQLite
+python3 "$SCRIPT_DIR/write-agent.py" "$TRANSCRIPT" "$TRACKING_DIR" "$SESSION_ID" "$AGENT_ID" "$AGENT_TYPE"
+
+# Parse friction events from subagent JSONL
+python3 "$SCRIPT_DIR/parse_friction.py" "$TRANSCRIPT" "$TRACKING_DIR/friction.json" \
+  "$SESSION_ID" "$(basename "$PROJECT_ROOT")" "subagent" \
+  --agent-type "$AGENT_TYPE" --agent-id "$AGENT_ID" 2>/dev/null || true
+
+# Regenerate charts
+python3 "$SCRIPT_DIR/generate-charts.py" "$TRACKING_DIR" "$TRACKING_DIR/charts.html" 2>/dev/null || true