usagelens 0.1.0 → 0.3.0

package/README.md

@@ -12,20 +12,44 @@ That's it — it scans your local data, starts a server on <http://localhost:431
 
 - **Tokens, est. cost, sessions, cache hit-rate, streak** — with deltas vs the prior period
 - **Daily activity** bar chart and a **when-you-work** hour × weekday heatmap (hover for details)
-- **Tool breakdown** (Claude / Codex / Cursor) and **model mix** with per-model estimated cost
-- **Top projects** — which repos consume the most AI
-- **Session shape** (quick / standard / deep / marathon) with averages
-- **Cache effectiveness** trend and estimated savings
-- **Code authorship** (from Cursor) — AI-authored vs human lines over time
+- **Tool breakdown** (Claude / Codex / Cursor / Antigravity) and **model mix** with per-model estimated cost
+- **Cost per shipped code** — AI spend mapped to real git commits & lines (`$/commit`, `$/1K lines`, per project)
+- **Cost efficiency & model routing** — premium (Opus) share, output/input leverage, and estimated savings if routine turns were routed to a cheaper tier
+- **Tool usage** — how often Bash / Edit / Read / etc. are called
+- **Top projects**, **session shape**, **cache effectiveness**, and **code authorship** (Cursor)
+- **Budgets** — month-to-date spend vs a configured monthly budget, with straight-line projection
+- **Live refresh** — re-scan your data without restarting; **multi-account** aware
 
 ## Options
 
 ```bash
-usagelens                # start on :4319 and open the browser
-usagelens --port 8080    # custom port
-usagelens --no-open      # don't auto-open the browser
+usagelens                       # start on :4319 (loopback only) and open the browser
+usagelens --port 8080           # custom port
+usagelens --no-open             # don't auto-open the browser
+usagelens report                # print a markdown usage report to stdout
+usagelens report --json         # machine-readable report (pipe to jq, CI, Slack)
+usagelens report --range 7d     # 7d | 30d | 90d
 ```
 
+## Config (optional) — `~/.usagelens.json`
+
+```json
+{
+  "sources": [
+    { "tool": "claude", "dir": "~/.claude",          "label": "work@company.com" },
+    { "tool": "claude", "dir": "~/.claude-personal", "label": "me@personal.com" }
+  ],
+  "pricing": { "opus": { "input": 12, "output": 60 } },
+  "budget":  { "monthlyUsd": 500, "monthlyTokens": 2000000000 },
+  "git": true
+}
+```
+
+- **sources** — point at multiple config dirs to track multiple accounts (each labeled).
+- **pricing** — override the estimated per-model $/Mtoken rates.
+- **budget** — enables the budget panel + projection.
+- **git** — set `false` to skip the git correlation (cost-per-shipped-code).
+
 ## Data sources
 
 Read-only, from your machine:
@@ -39,7 +63,7 @@ Tools detected without usable local usage data (Gemini, GitHub Copilot, Ollama)
 ## Notes
 
 - **Cost is estimated** — list price × tokens ("API-equivalent value"), not a bill. If you're on a subscription, treat it as a proxy for usage.
-- Nothing is written to your tool directories, and nothing leaves your machine.
+- Nothing is written to your tool directories, and nothing leaves your machine. The server binds to **loopback (127.0.0.1) only**.
 - Requires **Node ≥ 22.5** (uses the built-in `node:sqlite`).
 
 ## License

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "usagelens",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Local dashboard for your AI coding usage across Claude Code, Codex CLI, and Cursor. Reads your machine's local data and serves an interactive dashboard on localhost. Read-only, offline, zero runtime dependencies.",
   "type": "module",
   "bin": {
@@ -31,5 +31,13 @@
     "cli"
   ],
   "author": "Aayush Jain",
-  "license": "MIT"
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aayushGofynd/usagelens.git"
+  },
+  "homepage": "https://github.com/aayushGofynd/usagelens#readme",
+  "bugs": {
+    "url": "https://github.com/aayushGofynd/usagelens/issues"
+  }
 }

package/src/lib/accounts.mjs

@@ -0,0 +1,68 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, join } from 'node:path';
+
+const HOME = homedir();
+
+function readJson(path) {
+  try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; }
+}
+
+// Decode the payload of a JWT without verifying (local, read-only, best-effort).
+function jwtPayload(token) {
+  try {
+    const seg = String(token).split('.')[1];
+    const json = Buffer.from(seg.replace(/-/g, '+').replace(/_/g, '/'), 'base64').toString('utf8');
+    return JSON.parse(json);
+  } catch { return null; }
+}
+
+// Claude: oauthAccount lives in a .claude.json near the config/projects dir.
+export function claudeAccount(root) {
+  const candidates = [
+    join(root, '.claude.json'),
+    join(dirname(root), '.claude.json'),      // <root>/projects -> <root>/.claude.json
+    root.replace(/\/?$/, '') + '.json',       // ~/.claude-work -> ~/.claude-work.json
+    join(HOME, '.claude.json'),
+  ];
+  for (const c of candidates) {
+    const j = readJson(c);
+    const oa = j?.oauthAccount;
+    if (oa?.emailAddress) return oa.emailAddress;
+  }
+  return null;
+}
+
+// Codex: email from the id_token JWT, else account_id, from auth.json.
+export function codexAccount(root) {
+  for (const c of [join(root, 'auth.json'), join(HOME, '.codex', 'auth.json')]) {
+    const j = readJson(c);
+    if (!j) continue;
+    const p = jwtPayload(j.tokens?.id_token);
+    const email = p?.email || p?.['https://api.openai.com/profile']?.email;
+    if (email) return email;
+    const acct = j.tokens?.account_id;
+    if (acct) return `openai:${String(acct).slice(0, 8)}`;
+  }
+  return null;
+}
+
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+
+// Antigravity (Gemini): display name from the VS Code state DB auth status.
+export function antigravityAccount() {
+  const db = join(HOME, 'Library', 'Application Support', 'Antigravity', 'User', 'globalStorage', 'state.vscdb');
+  if (!existsSync(db)) return null;
+  try {
+    const { DatabaseSync } = require('node:sqlite');
+    const d = new DatabaseSync(db, { readOnly: true });
+    const row = d.prepare("SELECT value FROM ItemTable WHERE key='antigravityAuthStatus'").get();
+    d.close();
+    const v = row && JSON.parse(row.value);
+    return v?.name || v?.email || null;
+  } catch { return null; }
+}
+
+// Fallback label when no identity can be derived.
+export function fallbackAccount(dir) { return basename(dir) || 'local'; }

package/src/lib/adapters.mjs

@@ -1,137 +1,199 @@
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { createRequire } from 'node:module';
 import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
-import { costOf } from './pricing.mjs';
+import { costOf, setPricingOverrides } from './pricing.mjs';
+import { antigravityAccount, claudeAccount, codexAccount, fallbackAccount } from './accounts.mjs';
+import { loadConfig } from './config.mjs';
 
 const HOME = homedir();
+const require = createRequire(import.meta.url);
+const expand = (p) => (p.startsWith('~') ? join(HOME, p.slice(1)) : p);
 
-function walk(dir) {
+function walk(dir, ext) {
   if (!existsSync(dir)) return [];
   const out = [];
   for (const name of readdirSync(dir)) {
     let p = join(dir, name), st;
     try { st = statSync(p); } catch { continue; }
-    if (st.isDirectory()) out.push(...walk(p));
-    else if (name.endsWith('.jsonl')) out.push(p);
+    if (st.isDirectory()) out.push(...walk(p, ext));
+    else if (!ext || name.endsWith(ext)) out.push(p);
   }
   return out;
 }
 
 // ---------- Claude ----------
-export function loadClaude() {
-  const root = join(HOME, '.claude', 'projects');
-  if (!existsSync(root)) return { events: [], commits: [], status: { tool: 'claude', available: false, note: 'no ~/.claude/projects' } };
-  const events = [];
-  for (const f of walk(root)) {
-    let text;
-    try { text = readFileSync(f, 'utf8'); } catch { continue; }
+export function loadClaude(dir, account) {
+  const root = dir ?? join(HOME, '.claude', 'projects');
+  if (!existsSync(root)) return { events: [], commits: [], activity: [], status: { tool: 'claude', account, available: false, note: 'no projects dir' } };
+  const events = [], toolcalls = [];
+  for (const f of walk(root, '.jsonl')) {
+    let text; try { text = readFileSync(f, 'utf8'); } catch { continue; }
     for (const line of text.split('\n')) {
       if (!line.trim()) continue;
-      let row;
-      try { row = JSON.parse(line); } catch { continue; }
+      let row; try { row = JSON.parse(line); } catch { continue; }
       if (row.type !== 'assistant') continue;
       const m = row.message, u = m?.usage;
       if (!u || !m?.model) continue;
       const cwd = row.cwd ?? 'unknown';
+      // tool_use blocks in the assistant message content
+      if (Array.isArray(m.content)) {
+        for (const b of m.content) {
+          if (b?.type === 'tool_use' && b.name) toolcalls.push({ tool: 'claude', account, timestamp: row.timestamp, name: b.name });
+        }
+      }
       const t = {
-        inputTokens: u.input_tokens ?? 0,
-        outputTokens: u.output_tokens ?? 0,
-        cacheReadTokens: u.cache_read_input_tokens ?? 0,
-        cacheCreateTokens: u.cache_creation_input_tokens ?? 0,
+        inputTokens: u.input_tokens ?? 0, outputTokens: u.output_tokens ?? 0,
+        cacheReadTokens: u.cache_read_input_tokens ?? 0, cacheCreateTokens: u.cache_creation_input_tokens ?? 0,
       };
       events.push({
-        tool: 'claude', model: m.model, project: basename(cwd), projectPath: cwd,
+        tool: 'claude', account, model: m.model, project: basename(cwd), projectPath: cwd,
         gitBranch: row.gitBranch || undefined, timestamp: row.timestamp,
         sessionId: row.sessionId ?? basename(f, '.jsonl'), ...t, costUsd: costOf(m.model, t),
       });
     }
   }
-  const last = events.reduce((a, e) => (!a || e.timestamp > a ? e.timestamp : a), undefined);
-  return { events, commits: [], status: { tool: 'claude', available: true, lastActivity: last, count: events.length } };
+  return { events, commits: [], activity: [], toolcalls, status: statusOf('claude', account, events) };
 }
 
 // ---------- Codex ----------
-export function loadCodex() {
-  const base = join(HOME, '.codex');
-  const files = ['sessions', 'archived_sessions'].flatMap((r) => walk(join(base, r)));
-  if (files.length === 0) return { events: [], commits: [], status: { tool: 'codex', available: false, note: 'no ~/.codex sessions' } };
+export function loadCodex(dir, account) {
+  const base = dir ?? join(HOME, '.codex');
+  const files = ['sessions', 'archived_sessions'].flatMap((r) => walk(join(base, r), '.jsonl'));
+  if (files.length === 0) return { events: [], commits: [], activity: [], status: { tool: 'codex', account, available: false, note: 'no sessions' } };
   const events = [];
   for (const f of files) {
-    let text;
-    try { text = readFileSync(f, 'utf8'); } catch { continue; }
+    let text; try { text = readFileSync(f, 'utf8'); } catch { continue; }
     let model = 'gpt-5', cwd = 'unknown', sessionId = basename(f, '.jsonl');
     for (const line of text.split('\n')) {
       if (!line.trim()) continue;
-      let row;
-      try { row = JSON.parse(line); } catch { continue; }
+      let row; try { row = JSON.parse(line); } catch { continue; }
       const p = row.payload ?? row;
-      // Codex sessions nest the real event type inside event_msg/response_item payloads.
       const kind = (row.type === 'event_msg' || row.type === 'response_item') ? (p.type ?? row.type) : row.type;
       if (kind === 'session_meta') { cwd = p.cwd ?? cwd; sessionId = p.id ?? sessionId; }
       else if (kind === 'turn_context') { if (p.model) model = p.model; if (p.cwd) cwd = p.cwd; }
       else if (kind === 'token_count') {
-        const last = p.info?.last_token_usage;
-        if (!last) continue;
+        const last = p.info?.last_token_usage; if (!last) continue;
         const cached = last.cached_input_tokens ?? 0;
         const t = {
-          inputTokens: Math.max(0, (last.input_tokens ?? 0) - cached),
-          outputTokens: last.output_tokens ?? 0,
+          inputTokens: Math.max(0, (last.input_tokens ?? 0) - cached), outputTokens: last.output_tokens ?? 0,
           cacheReadTokens: cached, cacheCreateTokens: 0,
         };
         if (t.inputTokens + t.outputTokens + t.cacheReadTokens === 0) continue;
         events.push({
-          tool: 'codex', model, project: basename(cwd), projectPath: cwd,
+          tool: 'codex', account, model, project: basename(cwd), projectPath: cwd,
           timestamp: row.timestamp, sessionId, ...t, costUsd: costOf(model, t),
         });
       }
     }
   }
-  const last = events.reduce((a, e) => (!a || e.timestamp > a ? e.timestamp : a), undefined);
-  return { events, commits: [], status: { tool: 'codex', available: true, lastActivity: last, count: events.length } };
+  return { events, commits: [], activity: [], status: statusOf('codex', account, events) };
 }
 
 // ---------- Cursor ----------
-export function loadCursor() {
-  const path = join(HOME, '.cursor', 'ai-tracking', 'ai-code-tracking.db');
-  if (!existsSync(path)) return { events: [], commits: [], status: { tool: 'cursor', available: false, note: 'no cursor ai-tracking db' } };
+export function loadCursor(dir, account) {
+  const path = join(dir ?? join(HOME, '.cursor'), 'ai-tracking', 'ai-code-tracking.db');
+  if (!existsSync(path)) return { events: [], commits: [], activity: [], status: { tool: 'cursor', account, available: false, note: 'no ai-tracking db' } };
   const commits = [];
   try {
     const { DatabaseSync } = require('node:sqlite');
     const db = new DatabaseSync(path, { readOnly: true });
-    const rows = db.prepare(
-      'SELECT commitHash, branchName, scoredAt, linesAdded, v1AiPercentage, v2AiPercentage FROM scored_commits'
-    ).all();
+    const rows = db.prepare('SELECT commitHash, branchName, scoredAt, linesAdded, v1AiPercentage, v2AiPercentage FROM scored_commits').all();
     for (const r of rows) {
       const total = r.linesAdded ?? 0;
       const aiPct = Number(r.v2AiPercentage ?? r.v1AiPercentage ?? 0) || 0;
       const aiLines = Math.round((total * aiPct) / 100);
       commits.push({
-        tool: 'cursor', timestamp: new Date(Number(r.scoredAt)).toISOString(),
+        tool: 'cursor', account, timestamp: new Date(Number(r.scoredAt)).toISOString(),
         commitHash: r.commitHash, branchName: r.branchName ?? 'unknown',
         totalLines: total, aiLines, humanLines: Math.max(0, total - aiLines), aiPct,
       });
     }
     db.close();
   } catch (e) {
-    return { events: [], commits: [], status: { tool: 'cursor', available: false, note: 'cursor db unreadable: ' + e.message } };
+    return { events: [], commits: [], activity: [], status: { tool: 'cursor', account, available: false, note: 'db unreadable: ' + e.message } };
   }
   const last = commits.reduce((a, c) => (!a || c.timestamp > a ? c.timestamp : a), undefined);
-  return { events: [], commits, status: { tool: 'cursor', available: true, lastActivity: last, count: commits.length } };
+  return { events: [], commits, activity: [], status: { tool: 'cursor', account, available: true, lastActivity: last, count: commits.length, kind: 'authorship' } };
 }
 
-// require shim for ESM (node:sqlite import)
-import { createRequire } from 'node:module';
-const require = createRequire(import.meta.url);
+// ---------- Antigravity (Gemini) — activity only, no tokens ----------
+export function loadAntigravity(dir, account) {
+  const base = dir ?? join(HOME, '.gemini', 'antigravity');
+  if (!existsSync(base)) return { events: [], commits: [], activity: [], status: { tool: 'antigravity', account, available: false, note: 'not installed' } };
+  const activity = [];
+  // conversations = sessions
+  for (const f of walk(join(base, 'conversations'), '.pb')) {
+    let ts; try { ts = new Date(statSync(f).mtimeMs).toISOString(); } catch { continue; }
+    activity.push({ tool: 'antigravity', account, kind: 'session', project: 'antigravity', timestamp: ts });
+  }
+  // code_tracker = AI-touched files, project = workspace dir (minus trailing hash)
+  for (const root of ['active', 'history']) {
+    const rd = join(base, 'code_tracker', root);
+    if (!existsSync(rd)) continue;
+    for (const ws of readdirSync(rd)) {
+      const wsDir = join(rd, ws);
+      let st; try { st = statSync(wsDir); } catch { continue; }
+      if (!st.isDirectory()) continue;
+      const project = ws.replace(/_[0-9a-f]{40}$/, '') || 'antigravity';
+      for (const f of walk(wsDir)) {
+        const m = basename(f).match(/_(\d{14})-/);
+        let ts;
+        if (m) { const d = m[1]; ts = `${d.slice(0, 4)}-${d.slice(4, 6)}-${d.slice(6, 8)}T${d.slice(8, 10)}:${d.slice(10, 12)}:${d.slice(12, 14)}`; }
+        else { try { ts = new Date(statSync(f).mtimeMs).toISOString(); } catch { continue; } }
+        activity.push({ tool: 'antigravity', account, kind: 'file', project, timestamp: ts });
+      }
+    }
+  }
+  const last = activity.reduce((a, e) => (!a || e.timestamp > a ? e.timestamp : a), undefined);
+  return { events: [], commits: [], activity, status: { tool: 'antigravity', account, available: activity.length > 0, lastActivity: last, count: activity.length, kind: 'activity' } };
+}
+
+function statusOf(tool, account, events) {
+  const last = events.reduce((a, e) => (!a || e.timestamp > a ? e.timestamp : a), undefined);
+  return { tool, account, available: events.length > 0, lastActivity: last, count: events.length, kind: 'tokens' };
+}
+
+// ---------- source composition ----------
+function defaultSources() {
+  return [
+    { tool: 'claude', dir: join(HOME, '.claude', 'projects'), account: claudeAccount(join(HOME, '.claude', 'projects')) },
+    { tool: 'codex', dir: join(HOME, '.codex'), account: codexAccount(join(HOME, '.codex')) },
+    { tool: 'cursor', dir: join(HOME, '.cursor'), account: 'cursor (local)' },
+    { tool: 'antigravity', dir: join(HOME, '.gemini', 'antigravity'), account: antigravityAccount() },
+  ];
+}
+
+const LOADERS = { claude: loadClaude, codex: loadCodex, cursor: loadCursor, antigravity: loadAntigravity };
 
 export function loadAll() {
-  const events = [], commits = [], statuses = [];
-  for (const fn of [loadClaude, loadCodex, loadCursor]) {
-    try { const r = fn(); events.push(...r.events); commits.push(...r.commits); statuses.push(r.status); }
-    catch (e) { statuses.push({ tool: fn.name.replace('load', '').toLowerCase(), available: false, note: e.message }); }
+  const cfg = loadConfig();
+  setPricingOverrides(cfg.pricing);
+  const sources = (cfg.sources
+    ? cfg.sources.map((s) => ({ tool: s.tool, dir: expand(s.dir ?? ''), account: s.label ?? s.account ?? null }))
+    : null) ?? defaultSources();
+  const events = [], commits = [], activity = [], toolcalls = [], statuses = [];
+  const accounts = new Set();
+  const projectPaths = new Map(); // project name -> real filesystem path (for git correlation)
+  for (const s of sources) {
+    const loader = LOADERS[s.tool];
+    if (!loader) { statuses.push({ tool: s.tool, available: false, note: 'unknown tool' }); continue; }
+    const account = s.account || fallbackAccount(s.dir);
+    try {
+      const r = loader(s.dir, account);
+      events.push(...r.events); commits.push(...r.commits); activity.push(...(r.activity ?? []));
+      if (r.toolcalls) toolcalls.push(...r.toolcalls);
+      for (const e of r.events) if (e.projectPath && e.projectPath !== 'unknown') projectPaths.set(e.project, e.projectPath);
+      statuses.push(r.status);
+      if (r.status.available) accounts.add(account);
+    } catch (e) { statuses.push({ tool: s.tool, account, available: false, note: e.message }); }
   }
-  // detect-only tools with no parseable usage
-  for (const [tool, rel] of [['gemini', '.gemini'], ['copilot', '.copilot'], ['ollama', '.ollama']]) {
-    if (existsSync(join(HOME, rel))) statuses.push({ tool, available: false, note: 'detected, no usage metrics exposed' });
+  // tools present on disk but exposing no usable local usage
+  for (const [tool, rel, note] of [
+    ['copilot', '.copilot', 'no local usage (editor/cloud only)'],
+    ['ollama', '.ollama', 'no logged inference calls (server pings only)'],
+  ]) {
+    if (existsSync(join(HOME, rel))) statuses.push({ tool, available: false, note });
   }
-  return { events, commits, statuses };
+  return { events, commits, activity, toolcalls, statuses, accounts: [...accounts].sort(), projectPaths, config: cfg };
 }

package/src/lib/aggregate.mjs

@@ -1,4 +1,6 @@
 import { savingsOf } from './pricing.mjs';
+import { budgetStatus, efficiency, modelRouting, toolUsage } from './analytics.mjs';
+import { gitCorrelation } from './git.mjs';
 
 const MS_DAY = 86_400_000;
 const DAYS = { '7d': 7, '30d': 30, '90d': 90 };
@@ -141,11 +143,42 @@ function authorship(commits) {
   };
 }
 
-export function buildPayload(ds, range, now) {
+function activitySummary(activity) {
+  const byProject = new Map();
+  const byDay = new Set();
+  let sessions = 0, files = 0;
+  for (const a of activity) {
+    if (a.kind === 'session') sessions += 1; else files += 1;
+    byProject.set(a.project, (byProject.get(a.project) ?? 0) + 1);
+    byDay.add(localDayKey(a.timestamp));
+  }
+  return {
+    total: activity.length, sessions, files, activeDays: byDay.size,
+    byProject: [...byProject.entries()].map(([key, count]) => ({ key, count })).sort((a, b) => b.count - a.count).slice(0, 8),
+  };
+}
+
+// Computed on demand (shells out to git across repos) — see /api/git.
+export async function gitReport(ds, range, now, account) {
+  const win = rangeWindow(range, now);
+  const evAll = account && account !== 'all' ? ds.events.filter((e) => e.account === account) : ds.events;
+  const cur = evAll.filter((e) => inWin(e.timestamp, win));
+  const cfg = ds.config ?? { git: true };
+  return gitCorrelation(cur, ds.projectPaths ?? new Map(), win, cfg.git !== false);
+}
+
+export function buildPayload(ds, range, now, account) {
   const win = rangeWindow(range, now), prior = priorWindow(range, now);
-  const cur = ds.events.filter((e) => inWin(e.timestamp, win));
-  const prev = ds.events.filter((e) => inWin(e.timestamp, prior));
-  const commits = ds.commits.filter((c) => inWin(c.timestamp, win));
+  const pick = (arr) => (account && account !== 'all' ? arr.filter((x) => x.account === account) : arr);
+  const evAll = pick(ds.events), coAll = pick(ds.commits), acAll = pick(ds.activity ?? []);
+  const cur = evAll.filter((e) => inWin(e.timestamp, win));
+  const prev = evAll.filter((e) => inWin(e.timestamp, prior));
+  const commits = coAll.filter((c) => inWin(c.timestamp, win));
+  const activity = acAll.filter((a) => inWin(a.timestamp, win));
+  const toolcalls = (account && account !== 'all' ? (ds.toolcalls ?? []).filter((t) => t.account === account) : (ds.toolcalls ?? []))
+    .filter((t) => inWin(t.timestamp, win));
+  const lastAll = [...cur.map((e) => e.timestamp), ...commits.map((c) => c.timestamp), ...activity.map((a) => a.timestamp)];
+  const cfg = ds.config ?? { git: true, budget: null };
   return {
     summary: summarize(cur, prev),
     breakdowns: { byTool: group(cur, (e) => e.tool), byModel: group(cur, (e) => e.model), byProject: group(cur, (e) => e.project, 12) },
@@ -153,7 +186,14 @@ export function buildPayload(ds, range, now) {
     heatmap: heatmap(cur),
     sessions: sessionShape(cur),
     authorship: authorship(commits),
+    activity: activitySummary(activity),
+    efficiency: efficiency(cur),
+    routing: modelRouting(cur),
+    toolUsage: toolUsage(toolcalls),
+    gitEnabled: cfg.git !== false,   // git correlation is computed on demand via /api/git
+    budget: budgetStatus(account && account !== 'all' ? evAll : ds.events, cfg.budget, now),
     tools: ds.statuses,
-    meta: { range, generatedAt: now.toISOString(), lastActivity: cur.reduce((a, e) => (!a || e.timestamp > a ? e.timestamp : a), undefined) },
+    accounts: ds.accounts ?? [],
+    meta: { range, account: account ?? 'all', generatedAt: now.toISOString(), lastActivity: lastAll.reduce((a, t) => (!a || t > a ? t : a), undefined) },
   };
 }

package/src/lib/analytics.mjs

@@ -0,0 +1,73 @@
+import { priceFor } from './pricing.mjs';
+
+const tokensOf = (e) => e.inputTokens + e.outputTokens + e.cacheReadTokens + e.cacheCreateTokens;
+const costAt = (p, e) =>
+  (e.inputTokens * p.input + e.outputTokens * p.output + e.cacheCreateTokens * p.cacheWrite + e.cacheReadTokens * p.cacheRead) / 1e6;
+
+// Leverage & waste signals from token events.
+export function efficiency(events) {
+  const input = events.reduce((a, e) => a + e.inputTokens, 0);
+  const output = events.reduce((a, e) => a + e.outputTokens, 0);
+  const cost = events.reduce((a, e) => a + e.costUsd, 0);
+  // "thrash": a turn with large uncached input but tiny output (context churn / re-reading)
+  const thrash = events.filter((e) => e.inputTokens > 20_000 && e.outputTokens < 300);
+  return {
+    outputPerInput: input ? output / input : 0,
+    costPerMOutput: output ? cost / (output / 1e6) : 0,
+    avgTokensPerMsg: events.length ? events.reduce((a, e) => a + tokensOf(e), 0) / events.length : 0,
+    thrashCount: thrash.length,
+    thrashCostUsd: thrash.reduce((a, e) => a + e.costUsd, 0),
+  };
+}
+
+// How much of spend is on premium models, and estimated savings if "routine" turns
+// (short outputs) were routed to a cheaper tier (Sonnet-equivalent pricing).
+export function modelRouting(events) {
+  const sonnet = priceFor('sonnet');
+  const premium = /opus/i;
+  let premiumCost = 0, totalCost = 0, routineCount = 0, savings = 0;
+  for (const e of events) {
+    totalCost += e.costUsd;
+    if (premium.test(e.model)) {
+      premiumCost += e.costUsd;
+      if (e.outputTokens < 800) { // routine / trivial turn
+        routineCount += 1;
+        savings += Math.max(0, e.costUsd - costAt(sonnet, e));
+      }
+    }
+  }
+  return {
+    premiumSharePct: totalCost ? (premiumCost / totalCost) * 100 : 0,
+    routineCount,
+    estRoutingSavingsUsd: savings,
+  };
+}
+
+// Tool-call frequency (from transcript tool_use blocks).
+export function toolUsage(toolcalls) {
+  const map = new Map();
+  for (const t of toolcalls) map.set(t.name, (map.get(t.name) ?? 0) + 1);
+  const top = [...map.entries()].map(([key, count]) => ({ key, count })).sort((a, b) => b.count - a.count);
+  return { total: toolcalls.length, top: top.slice(0, 10) };
+}
+
+// Month-to-date budget tracking + straight-line projection.
+export function budgetStatus(events, budget, now) {
+  if (!budget) return null;
+  const y = now.getFullYear(), m = now.getMonth();
+  const mtd = events.filter((e) => { const d = new Date(e.timestamp); return d.getFullYear() === y && d.getMonth() === m; });
+  const spendUsd = mtd.reduce((a, e) => a + e.costUsd, 0);
+  const spendTokens = mtd.reduce((a, e) => a + tokensOf(e), 0);
+  const dayOfMonth = now.getDate();
+  const daysInMonth = new Date(y, m + 1, 0).getDate();
+  const project = (v) => (dayOfMonth ? (v / dayOfMonth) * daysInMonth : v);
+  return {
+    monthlyUsd: budget.monthlyUsd ?? null,
+    monthlyTokens: budget.monthlyTokens ?? null,
+    spendUsd, spendTokens,
+    projectedUsd: project(spendUsd), projectedTokens: project(spendTokens),
+    usdPct: budget.monthlyUsd ? (spendUsd / budget.monthlyUsd) * 100 : null,
+    tokensPct: budget.monthlyTokens ? (spendTokens / budget.monthlyTokens) * 100 : null,
+    dayOfMonth, daysInMonth,
+  };
+}

package/src/lib/config.mjs

@@ -0,0 +1,32 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const HOME = homedir();
+
+// ~/.usagelens.json — all optional:
+// {
+//   "sources": [ { "tool": "claude", "dir": "~/.claude", "label": "work@x.com" } ],
+//   "pricing": { "opus": { "input": 15, "output": 75, "cacheWrite": 18.75, "cacheRead": 1.5 } },
+//   "budget":  { "monthlyUsd": 500, "monthlyTokens": 2000000000 },
+//   "git":     true,
+//   "planUsd": 200
+// }
+let cached;
+export function loadConfig() {
+  if (cached) return cached;
+  const path = join(HOME, '.usagelens.json');
+  let raw = {};
+  if (existsSync(path)) {
+    try { raw = JSON.parse(readFileSync(path, 'utf8')); } catch { raw = {}; }
+  }
+  cached = {
+    sources: Array.isArray(raw.sources) ? raw.sources : null,
+    pricing: raw.pricing && typeof raw.pricing === 'object' ? raw.pricing : {},
+    budget: raw.budget && typeof raw.budget === 'object' ? raw.budget : null,
+    git: raw.git !== false, // default on
+    planUsd: typeof raw.planUsd === 'number' ? raw.planUsd : null,
+    configPath: existsSync(path) ? path : null,
+  };
+  return cached;
+}

package/src/lib/git.mjs

@@ -0,0 +1,72 @@
+import { execFile } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+const tokensOf = (e) => e.inputTokens + e.outputTokens + e.cacheReadTokens + e.cacheCreateTokens;
+const iso = (d) => d.toISOString();
+
+function isRepo(dir) {
+  try { return existsSync(join(dir, '.git')); } catch { return false; }
+}
+
+// Commits + lines changed in a repo within [start,end], authored by anyone.
+async function repoStats(dir, start, end) {
+  try {
+    const { stdout: out } = await execFileAsync('git', [
+      '-C', dir, 'log', `--since=${iso(start)}`, `--until=${iso(end)}`,
+      '--no-merges', '--numstat', '--pretty=format:%x01%H',
+    ], { encoding: 'utf8', timeout: 6000, maxBuffer: 1 << 24 });
+    let commits = 0, added = 0, deleted = 0;
+    for (const line of out.split('\n')) {
+      if (line.startsWith('\x01')) { commits += 1; continue; }
+      const m = line.split('\t');
+      if (m.length === 3) { added += Number(m[0]) || 0; deleted += Number(m[1]) || 0; }
+    }
+    return { commits, linesChanged: added + deleted };
+  } catch { return null; }
+}
+
+// Correlate AI token spend per project with real git activity in the window.
+// Async + parallel across repos (each repo's `git log` runs concurrently).
+export async function gitCorrelation(events, projectPaths, window, enabled) {
+  if (!enabled) return { available: false, note: 'disabled in config', rows: [], totals: null };
+  const byProject = new Map();
+  for (const e of events) {
+    const cur = byProject.get(e.project) ?? { costUsd: 0, tokens: 0 };
+    cur.costUsd += e.costUsd; cur.tokens += tokensOf(e); byProject.set(e.project, cur);
+  }
+  // top projects by cost, so we bound how many git calls we make
+  const top = [...byProject.entries()].sort((a, b) => b[1].costUsd - a[1].costUsd).slice(0, 15);
+  const candidates = top
+    .map(([project, agg]) => ({ project, agg, dir: projectPaths.get?.(project) ?? projectPaths[project] }))
+    .filter((c) => c.dir && isRepo(c.dir));
+  const stats = await Promise.all(candidates.map((c) => repoStats(c.dir, window.start, window.end)));
+  const rows = [];
+  let anyRepo = false;
+  candidates.forEach((c, i) => {
+    const st = stats[i];
+    if (!st) return;
+    anyRepo = true;
+    rows.push({
+      project: c.project, costUsd: c.agg.costUsd, tokens: c.agg.tokens,
+      commits: st.commits, linesChanged: st.linesChanged,
+      usdPerCommit: st.commits ? c.agg.costUsd / st.commits : null,
+      usdPerKLine: st.linesChanged ? c.agg.costUsd / (st.linesChanged / 1000) : null,
+    });
+  });
+  rows.sort((a, b) => b.costUsd - a.costUsd);
+  const totals = rows.reduce((t, r) => ({
+    costUsd: t.costUsd + r.costUsd, commits: t.commits + r.commits, linesChanged: t.linesChanged + r.linesChanged,
+  }), { costUsd: 0, commits: 0, linesChanged: 0 });
+  return {
+    available: anyRepo, note: anyRepo ? null : 'no git repos found for active projects',
+    rows,
+    totals: anyRepo ? {
+      ...totals,
+      usdPerCommit: totals.commits ? totals.costUsd / totals.commits : null,
+      usdPerKLine: totals.linesChanged ? totals.costUsd / (totals.linesChanged / 1000) : null,
+    } : null,
+  };
+}

package/src/lib/pricing.mjs

@@ -8,8 +8,16 @@ const TABLE = [
 ];
 const DEFAULT = { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 };
 
+// Optional per-key overrides from ~/.usagelens.json, e.g. { "opus": { "input": 12 } }
+let OVERRIDES = {};
+export function setPricingOverrides(o) { OVERRIDES = o && typeof o === 'object' ? o : {}; }
+
 export function priceFor(model) {
-  return (TABLE.find((r) => r.m.test(model || ''))?.p) ?? DEFAULT;
+  const base = (TABLE.find((r) => r.m.test(model || ''))?.p) ?? DEFAULT;
+  for (const key in OVERRIDES) {
+    if (new RegExp(key, 'i').test(model || '')) return { ...base, ...OVERRIDES[key] };
+  }
+  return base;
 }
 
 export function costOf(model, t) {

package/src/lib/report.mjs

@@ -0,0 +1,44 @@
+const tok = (n) => n >= 1e9 ? (n / 1e9).toFixed(2) + 'B' : n >= 1e6 ? (n / 1e6).toFixed(1) + 'M' : n >= 1e3 ? (n / 1e3).toFixed(1) + 'K' : String(Math.round(n));
+const usd = (n) => n >= 1000 ? '$' + (n / 1000).toFixed(1) + 'K' : '$' + n.toFixed(2);
+const pct = (n) => (n >= 0 ? '+' : '') + n.toFixed(1) + '%';
+
+export function reportText(p) {
+  const s = p.summary, L = [];
+  L.push(`# usagelens · last ${p.meta.range}`);
+  L.push('');
+  L.push(`You wrote **${tok(s.totalTokens)} tokens** across **${s.sessions} sessions** (${s.messages} messages, ${s.activeDays} active days, streak ${s.currentStreak}d).`);
+  L.push('');
+  L.push(`- Est. cost: **${usd(s.costUsd)}** (${pct(s.deltas.costPct)} vs prior)`);
+  L.push(`- Tokens: ${tok(s.totalTokens)} (${pct(s.deltas.tokensPct)} vs prior)`);
+  L.push(`- Cache hit: ${(s.cacheHitRate * 100).toFixed(0)}% · saved ${usd(s.cacheSavingsUsd)}`);
+  L.push('');
+  L.push('## Tools');
+  for (const t of p.breakdowns.byTool) L.push(`- ${t.key}: ${tok(t.tokens)} · ${usd(t.costUsd)} · ${t.sharePct.toFixed(0)}%`);
+  L.push('');
+  L.push('## Models');
+  for (const m of p.breakdowns.byModel.slice(0, 6)) L.push(`- ${m.key}: ${m.sharePct.toFixed(1)}% · ${usd(m.costUsd)}`);
+  L.push('');
+  L.push('## Top projects');
+  for (const pr of p.breakdowns.byProject.slice(0, 8)) L.push(`- ${pr.key}: ${tok(pr.tokens)} · ${usd(pr.costUsd)}`);
+  L.push('');
+  L.push('## Efficiency');
+  L.push(`- Output/input leverage: ${p.efficiency.outputPerInput.toFixed(2)}×`);
+  L.push(`- Premium (Opus) share: ${p.routing.premiumSharePct.toFixed(0)}%`);
+  L.push(`- Est. routing savings: ${usd(p.routing.estRoutingSavingsUsd)} (${p.routing.routineCount} routine turns → Sonnet)`);
+  L.push('');
+  if (p.git.available) {
+    L.push('## Cost per shipped code (git)');
+    const g = p.git.totals;
+    L.push(`- ${usd(g.costUsd)} across ${g.commits} commits, ${tok(g.linesChanged)} lines`);
+    L.push(`- ${g.usdPerCommit != null ? usd(g.usdPerCommit) : '—'} / commit · ${g.usdPerKLine != null ? usd(g.usdPerKLine) : '—'} / 1K lines`);
+    for (const r of p.git.rows.slice(0, 6)) L.push(`  - ${r.project}: ${usd(r.costUsd)} · ${r.commits}c · ${r.usdPerCommit != null ? usd(r.usdPerCommit) + '/c' : '—'}`);
+    L.push('');
+  }
+  if (p.toolUsage.total) {
+    L.push('## Tool usage');
+    for (const t of p.toolUsage.top.slice(0, 8)) L.push(`- ${t.key}: ${t.count}`);
+    L.push('');
+  }
+  L.push(`_Generated ${p.meta.generatedAt} · cost is estimated API-equivalent, not a bill._`);
+  return L.join('\n') + '\n';
+}

package/src/public/app.js

@@ -50,6 +50,18 @@ function barRow(label, right, pctWidth, color) {
   ]);
 }
 
+function budgetRow(label, value, ofText, pct, proj) {
+  const p = pct ?? 0;
+  const color = p >= 100 ? 'var(--warn)' : p >= 80 ? 'var(--c2)' : 'var(--good)';
+  return el('div', { class: 'barRow' }, [
+    el('div', { class: 'top' }, [
+      el('span', {}, `${label} ${value} `),
+      el('span', { class: 'r' }, `${ofText} · ${p.toFixed(0)}% · ${proj}`),
+    ]),
+    el('div', { class: 'track' }, [el('div', { class: 'fill', style: `width:${Math.min(100, Math.max(1, p))}%;background:${color}` })]),
+  ]);
+}
+
 // SVG bar chart (daily tokens)
 function barChart(data, h = 170) {
   const w = 1000, pad = 4, max = Math.max(1, ...data.map((d) => d.tokens));
@@ -133,6 +145,50 @@ function panel(titleText, meta, body) {
   return el('div', { class: 'card' }, [head, body]);
 }
 
+// ---- git cost-per-shipped-code: on-demand, cached per range ----
+const gitState = {}; // range -> computed git result
+function renderGitBody(g) {
+  if (!g.available) return el('div', { class: 'csub' }, g.note || 'no git repos found for active projects');
+  const t = g.totals;
+  return el('div', {}, [
+    el('div', { class: 'statPair', style: 'margin-bottom:12px' }, [
+      el('div', {}, [el('div', { class: 'k' }, '$ / COMMIT'), el('div', { class: 'v' }, t.usdPerCommit != null ? fmtUsd(t.usdPerCommit) : '—')]),
+      el('div', {}, [el('div', { class: 'k' }, '$ / 1K LINES'), el('div', { class: 'v' }, t.usdPerKLine != null ? fmtUsd(t.usdPerKLine) : '—')]),
+      el('div', {}, [el('div', { class: 'k' }, 'COMMITS'), el('div', { class: 'v' }, fmtInt(t.commits))]),
+      el('div', {}, [el('div', { class: 'k' }, 'LINES SHIPPED'), el('div', { class: 'v' }, fmtTok(t.linesChanged))]),
+    ]),
+    ...g.rows.map((r) => el('div', { class: 'barRow' }, [
+      el('div', { class: 'top' }, [
+        el('span', {}, r.project),
+        el('span', { class: 'r' }, `${fmtUsd(r.costUsd)} · ${fmtInt(r.commits)}c · ${r.usdPerCommit != null ? fmtUsd(r.usdPerCommit) + '/c' : '—'}`),
+      ]),
+      el('div', { class: 'track' }, [el('div', { class: 'fill', style: `width:${(r.costUsd / (g.rows[0].costUsd || 1)) * 100}%;background:var(--c1)` })]),
+    ])),
+  ]);
+}
+function gitPanel(d) {
+  const body = el('div', {});
+  const fillButton = () => {
+    body.innerHTML = '';
+    if (!d.gitEnabled) { body.append(el('div', { class: 'csub' }, 'git correlation disabled in config')); return; }
+    const btn = el('button', { class: 'bigbtn' }, '⚡ Compute cost-per-shipped-code');
+    const note = el('div', { class: 'csub', style: 'margin-top:10px' }, 'Maps AI spend to real git commits & lines in your repos. Runs `git log` locally — takes a few seconds.');
+    btn.addEventListener('click', async () => {
+      btn.disabled = true; btn.textContent = 'Computing… (scanning repos)';
+      try {
+        const g = await (await fetch('/api/git?range=' + range)).json();
+        gitState[range] = g; body.innerHTML = ''; body.append(renderGitBody(g));
+      } catch (e) {
+        btn.disabled = false; btn.textContent = '⚡ Compute cost-per-shipped-code';
+      }
+    });
+    body.append(btn, note);
+  };
+  if (gitState[range]) body.append(renderGitBody(gitState[range]));
+  else fillButton();
+  return panel('COST PER SHIPPED CODE · GIT × AI SPEND', 'AI $ mapped to real commits & lines · on-demand', body);
+}
+
 function render(d) {
   const app = $('#app'); app.innerHTML = '';
   const s = d.summary, rng = d.meta.range;
@@ -208,6 +264,37 @@ function render(d) {
   ]);
   app.append(el('div', { class: 'grid two' }, [panel('SESSION SHAPE', 'by token size', shBody), panel('CACHE EFFECTIVENESS', 'daily hit rate', cacheBody)]));
 
+  // budget (only if configured)
+  if (d.budget && (d.budget.monthlyUsd || d.budget.monthlyTokens)) {
+    const b = d.budget;
+    const rows = [];
+    if (b.monthlyUsd) rows.push(budgetRow('SPEND (MTD)', fmtUsd(b.spendUsd), `of ${fmtUsd(b.monthlyUsd)}`, b.usdPct, `proj ${fmtUsd(b.projectedUsd)}`));
+    if (b.monthlyTokens) rows.push(budgetRow('TOKENS (MTD)', fmtTok(b.spendTokens), `of ${fmtTok(b.monthlyTokens)}`, b.tokensPct, `proj ${fmtTok(b.projectedTokens)}`));
+    app.append(el('div', { class: 'grid' }, [panel('BUDGET', `day ${b.dayOfMonth}/${b.daysInMonth} this month`, el('div', {}, rows))]));
+  }
+
+  // cost per shipped code (git) — on-demand (shells out to git; ~seconds)
+  app.append(el('div', { class: 'grid' }, [gitPanel(d)]));
+
+  // efficiency + routing, and tool usage
+  const eff = d.efficiency, rt = d.routing;
+  const effBody = el('div', {}, [
+    el('div', { style: 'font-size:30px;font-weight:700;color:var(--good)' }, fmtUsd(rt.estRoutingSavingsUsd)),
+    el('div', { class: 'csub', style: 'margin-bottom:12px' }, `est. saved if ${fmtInt(rt.routineCount)} routine Opus turns routed to Sonnet`),
+    el('div', { class: 'statPair' }, [
+      el('div', {}, [el('div', { class: 'k' }, 'PREMIUM SHARE'), el('div', { class: 'v' }, rt.premiumSharePct.toFixed(0) + '%')]),
+      el('div', {}, [el('div', { class: 'k' }, 'OUTPUT/INPUT'), el('div', { class: 'v' }, eff.outputPerInput.toFixed(2) + '×')]),
+      el('div', {}, [el('div', { class: 'k' }, '$ / 1M OUT'), el('div', { class: 'v' }, fmtUsd(eff.costPerMOutput))]),
+    ]),
+    el('div', { class: 'csub', style: 'margin-top:10px' }, `${fmtInt(eff.thrashCount)} thrash turns (big input, tiny output) · ${fmtUsd(eff.thrashCostUsd)}`),
+  ]);
+  const tu = d.toolUsage;
+  const maxTu = tu.top[0]?.count || 1;
+  const tuBody = tu.total === 0
+    ? el('div', { class: 'csub' }, 'no tool-call data in range')
+    : el('div', {}, tu.top.map((t) => barRow(t.key, fmtInt(t.count), (t.count / maxTu) * 100, 'var(--c4)')));
+  app.append(el('div', { class: 'grid two' }, [panel('COST EFFICIENCY · MODEL ROUTING', 'where spend could shrink', effBody), panel('TOOL USAGE', `${fmtInt(tu.total)} calls`, tuBody)]));
+
   // authorship
   let authBody;
   if (d.authorship.totalCommits === 0) authBody = el('div', { class: 'csub' }, 'No Cursor commit data in this range.');
@@ -217,9 +304,28 @@ function render(d) {
   ]);
   app.append(el('div', { class: 'grid' }, [panel('CODE AUTHORSHIP · CURSOR', 'weekly AI vs human lines', authBody)]));
 
+  // activity (Antigravity / Gemini) — count-only signal, no tokens
+  if (d.activity && d.activity.total > 0) {
+    const maxA = d.activity.byProject[0]?.count || 1;
+    const actBody = el('div', {}, [
+      el('div', { class: 'statPair', style: 'margin-bottom:10px' }, [
+        el('div', {}, [el('div', { class: 'k' }, 'SESSIONS'), el('div', { class: 'v' }, fmtInt(d.activity.sessions))]),
+        el('div', {}, [el('div', { class: 'k' }, 'AI-TOUCHED FILES'), el('div', { class: 'v' }, fmtInt(d.activity.files))]),
+        el('div', {}, [el('div', { class: 'k' }, 'ACTIVE DAYS'), el('div', { class: 'v' }, fmtInt(d.activity.activeDays))]),
+      ]),
+      ...d.activity.byProject.map((p) => barRow(p.key, `${fmtInt(p.count)}`, (p.count / maxA) * 100, 'var(--c5)')),
+    ]);
+    app.append(el('div', { class: 'grid' }, [panel('ACTIVITY · ANTIGRAVITY (GEMINI)', 'sessions & AI-touched files · no token data', actBody)]));
+  }
+
   // tool chips
-  const chips = el('div', { class: 'tools' }, d.tools.map((t) =>
-    el('div', { class: 'chip ' + (t.available ? 'on' : ''), html: `<span class="d" style="background:${t.available ? 'var(--good)' : 'var(--line)'};width:8px;height:8px;border-radius:50%;display:inline-block"></span><b>${esc(t.tool)}</b> ${t.available ? (t.count != null ? fmtInt(t.count) + ' records' : 'active') : esc(t.note || 'no data')}` })));
+  const kindLabel = { tokens: 'tokens', authorship: 'code lines', activity: 'activity' };
+  const chips = el('div', { class: 'tools' }, d.tools.map((t) => {
+    const detail = t.available
+      ? `${t.count != null ? fmtInt(t.count) + ' ' + (kindLabel[t.kind] || 'records') : 'active'}${t.account ? ' · ' + esc(t.account) : ''}`
+      : esc(t.note || 'no data');
+    return el('div', { class: 'chip ' + (t.available ? 'on' : ''), html: `<span class="d" style="background:${t.available ? 'var(--good)' : 'var(--line)'};width:8px;height:8px;border-radius:50%;display:inline-block"></span><b>${esc(t.tool)}</b> ${detail}` });
+  }));
   app.append(el('div', {}, [el('div', { class: 'clabel', style: 'margin-top:8px' }, 'TOOLS DETECTED'), chips]));
   app.append(el('div', { class: 'foot' }, `Generated ${new Date(d.meta.generatedAt).toLocaleString()} · read-only from ~/.claude, ~/.codex, ~/.cursor · cost is estimated API-equivalent, not a bill`));
 }
@@ -227,7 +333,7 @@ function render(d) {
 let range = '30d';
 async function load() {
   try {
-    const r = await fetch('/api/dashboard?range=' + range);
+    const r = await fetch(`/api/dashboard?range=${range}&account=all`);
     render(await r.json());
   } catch (e) { $('#app').innerHTML = '<div class="loading">Failed: ' + e.message + '</div>'; }
 }
@@ -237,4 +343,11 @@ $('#toggle').addEventListener('click', (e) => {
   [...$('#toggle').children].forEach((c) => c.classList.toggle('on', c === b));
   $('#app').innerHTML = '<div class="loading">Loading…</div>'; load();
 });
+$('#refresh').addEventListener('click', async () => {
+  const btn = $('#refresh'); btn.disabled = true; btn.textContent = '⟳ Scanning…';
+  for (const k in gitState) delete gitState[k]; // git cache is stale after a re-scan
+  try { await fetch('/api/refresh'); } catch {}
+  await load();
+  btn.disabled = false; btn.textContent = '⟳ Refresh';
+});
 load();

package/src/public/index.html

@@ -22,6 +22,10 @@
   h1.hero b{color:var(--accent);font-weight:600;font-variant-numeric:tabular-nums}
   .heroSub{color:var(--sub);font-size:14px;margin:0}
   .heroSub b{color:var(--ink);font-weight:600}
+  .controls{display:flex;gap:10px;align-items:center;flex-wrap:wrap}
+  #refresh{font-family:var(--mono);font-size:13px;color:var(--sub);background:var(--panel);border:1px solid var(--line);border-radius:10px;padding:7px 12px;cursor:pointer}
+  #refresh:hover{color:var(--accent);border-color:var(--accent)}
+  #refresh:disabled{opacity:.5;cursor:wait}
   .toggle{display:inline-flex;gap:2px;background:var(--panel);border:1px solid var(--line);border-radius:10px;padding:3px}
   .toggle button{border:0;background:transparent;color:var(--sub);font-weight:600;font-size:13px;
     padding:6px 14px;border-radius:7px;cursor:pointer;font-family:var(--mono)}
@@ -63,6 +67,8 @@
   .chip b{color:var(--ink)} .chip.on b{color:var(--good)} .chip .d{margin-right:6px}
   .foot{margin-top:22px;font-size:12px;color:var(--sub);font-family:var(--mono)}
   .loading{padding:60px;text-align:center;color:var(--sub)}
+  .bigbtn{font-family:var(--mono);font-size:14px;font-weight:600;color:#fff;background:var(--accent);border:0;border-radius:10px;padding:12px 20px;cursor:pointer}
+  .bigbtn:hover{filter:brightness(1.08)} .bigbtn:disabled{opacity:.6;cursor:wait}
   svg{display:block;width:100%;overflow:visible}
   .tip{fill:var(--sub);font-size:9px;font-family:var(--mono)}
 </style>
@@ -71,10 +77,13 @@
 <div class="wrap">
   <div class="row">
     <div class="eyebrow" id="eyebrow">ANALYTICS · LAST 30 DAYS</div>
-    <div class="toggle" id="toggle">
-      <button data-r="7d">7d</button>
-      <button data-r="30d" class="on">30d</button>
-      <button data-r="90d">90d</button>
+    <div class="controls">
+      <button id="refresh" title="Re-scan local data">⟳ Refresh</button>
+      <div class="toggle" id="toggle">
+        <button data-r="7d">7d</button>
+        <button data-r="30d" class="on">30d</button>
+        <button data-r="90d">90d</button>
+      </div>
     </div>
   </div>
   <div id="app"><div class="loading">Reading your local AI data…</div></div>

package/src/server.mjs

@@ -13,7 +13,7 @@ import { platform } from 'node:os';
 import { extname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { loadAll } from './lib/adapters.mjs';
-import { buildPayload } from './lib/aggregate.mjs';
+import { buildPayload, gitReport } from './lib/aggregate.mjs';
 
 const PUBLIC = join(fileURLToPath(new URL('.', import.meta.url)), 'public');
 const MIME = { '.html': 'text/html', '.js': 'text/javascript', '.css': 'text/css', '.json': 'application/json', '.svg': 'image/svg+xml' };
@@ -27,23 +27,72 @@ function parseArgs(argv) {
   return o;
 }
 
+function scan(quiet) {
+  const t0 = Date.now();
+  const ds = loadAll();
+  if (!quiet) {
+    process.stdout.write(`usagelens · loaded ${ds.events.length} usage events + ${ds.commits.length} commits + ${ds.activity.length} activity in ${Date.now() - t0}ms\n`);
+    process.stdout.write(`usagelens · accounts: ${ds.accounts.join(', ') || 'none'}\n`);
+    for (const s of ds.statuses) process.stdout.write(`   ${s.available ? '✓' : '·'} ${s.tool}${s.count != null ? ` (${s.count})` : ''}${s.note ? ' — ' + s.note : ''}\n`);
+  }
+  return ds;
+}
+
+// ---- headless report mode: `usagelens report [--json] [--range 30d] ----
+if (process.argv[2] === 'report') {
+  const args = process.argv.slice(3);
+  const json = args.includes('--json');
+  const ri = args.indexOf('--range');
+  const range = ri >= 0 && ['7d', '30d', '90d'].includes(args[ri + 1]) ? args[ri + 1] : '30d';
+  const { reportText } = await import('./lib/report.mjs');
+  const ds = scan(true);
+  const now = new Date();
+  const payload = buildPayload(ds, range, now, 'all');
+  payload.git = await gitReport(ds, range, now, 'all'); // report includes git (CLI can afford it)
+  process.stdout.write(json ? JSON.stringify(payload, null, 2) + '\n' : reportText(payload));
+  process.exit(0);
+}
+
 const { port, open } = parseArgs(process.argv.slice(2));
 
-process.stdout.write('usagelens · scanning ~/.claude, ~/.codex, ~/.cursor …\n');
-const t0 = Date.now();
-const dataset = loadAll();
-process.stdout.write(`usagelens · loaded ${dataset.events.length} usage events + ${dataset.commits.length} commits in ${Date.now() - t0}ms\n`);
-for (const s of dataset.statuses) process.stdout.write(`   ${s.available ? '✓' : '·'} ${s.tool}${s.count != null ? ` (${s.count})` : ''}${s.note ? ' — ' + s.note : ''}\n`);
+process.stdout.write('usagelens · scanning Claude, Codex, Cursor, Antigravity …\n');
+let dataset = scan(false);
+
+const gitCache = new Map();  // key `range|account` -> JSON string; cleared on refresh
+const dashCache = new Map(); // same; snapshot valid until next refresh
 
 const server = createServer((req, res) => {
   const url = new URL(req.url ?? '/', 'http://localhost');
   if (url.pathname === '/api/dashboard') {
     const rq = url.searchParams.get('range');
     const range = ['7d', '30d', '90d'].includes(rq) ? rq : '30d';
-    const body = JSON.stringify(buildPayload(dataset, range, new Date()));
+    const account = url.searchParams.get('account') || 'all';
+    const key = `${range}|${account}`;
+    let body = dashCache.get(key);
+    if (!body) { body = JSON.stringify(buildPayload(dataset, range, new Date(), account)); dashCache.set(key, body); }
     res.writeHead(200, { 'content-type': 'application/json' }).end(body);
     return;
   }
+  if (url.pathname === '/api/git') {
+    const rq = url.searchParams.get('range');
+    const range = ['7d', '30d', '90d'].includes(rq) ? rq : '30d';
+    const account = url.searchParams.get('account') || 'all';
+    const key = `${range}|${account}`;
+    if (gitCache.has(key)) { res.writeHead(200, { 'content-type': 'application/json' }).end(gitCache.get(key)); return; }
+    gitReport(dataset, range, new Date(), account).then((g) => {
+      const body = JSON.stringify(g);
+      gitCache.set(key, body);
+      res.writeHead(200, { 'content-type': 'application/json' }).end(body);
+    }).catch((e) => { res.writeHead(500, { 'content-type': 'application/json' }).end(JSON.stringify({ available: false, note: 'git error: ' + e.message, rows: [] })); });
+    return;
+  }
+  if (url.pathname === '/api/refresh') {
+    dataset = scan(true);
+    gitCache.clear();
+    dashCache.clear();
+    res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify({ ok: true, events: dataset.events.length }));
+    return;
+  }
   const name = url.pathname === '/' ? 'index.html' : url.pathname.replace(/^\/+/, '').replace(/\.\./g, '');
   const file = join(PUBLIC, name);
   if (existsSync(file) && statSync(file).isFile()) {
@@ -54,7 +103,8 @@ const server = createServer((req, res) => {
   }
 });
 
-server.listen(port, () => {
+// Bind to loopback only — the dashboard exposes your usage/projects/cost.
+server.listen(port, '127.0.0.1', () => {
   const link = `http://localhost:${port}`;
   process.stdout.write(`\nusagelens · dashboard → ${link}\n`);
   if (open) {