ai-usage-analyzer 0.2.1 → 0.3.0

package/bin/ai-usage.js

@@ -7,7 +7,8 @@ import { loadAll, dateRange } from '../src/loaders.js';
 import { overall } from '../src/aggregate.js';
 import {
   renderHeader, renderDetections, renderOverview,
-  renderPerProject, renderPerMonth, renderPerWeek,
+  renderPerProject, renderPerTool, renderPerToolPerMonth,
+  renderPerMonth, renderPerWeek,
   renderTopSessions, renderNotes,
 } from '../src/render.js';
 import { renderMarkdown } from '../src/markdown.js';
@@ -23,6 +24,12 @@ const topN = (() => {
   const v = parseInt(args[i + 1], 10);
   return Number.isFinite(v) && v > 0 ? v : 5;
 })();
+const yearFilter = (() => {
+  const i = args.indexOf('--year');
+  if (i < 0) return null;
+  const v = parseInt(args[i + 1], 10);
+  return Number.isFinite(v) && v > 1970 && v < 3000 ? v : null;
+})();
 
 if (showHelp) {
   console.log(`
@@ -36,9 +43,11 @@ Options:
   --json             Output machine-readable JSON instead of TUI
   --markdown, --md   Output as a Markdown report (GitHub-flavored tables)
   --top N            Show top N heaviest sessions (default: 5)
+  --year YYYY        Filter records to a single year (e.g. --year 2026)
 
 Examples:
   ai-usage                       # default TUI
+  ai-usage --year 2026           # TUI, only 2026 sessions
   ai-usage --json | jq .summary  # pipe to jq
   ai-usage --md > report.md      # save as markdown
   ai-usage --top 20              # show top 20 sessions
@@ -49,7 +58,7 @@ Environment overrides (per-tool data path):
   AI_USAGE_PATHS_JSON='{"codex":"/custom/path",...}'
 
 Supported tools:
-  • Claude Code    — ~/.claude/projects  (presence only)
+  • Claude Code    — ~/.claude/projects  (tokens from per-message usage)
   • Codex          — ~/.codex/sessions      (tokens from token_count events)
   • OpenCode       — ~/.local/share/opencode/opencode.db  (tokens + cost)
   • MimoCode       — ~/.local/share/mimocode/mimocode.db  (tokens + cost)
@@ -68,7 +77,14 @@ if (jsonOut && mdOut) {
 async function main() {
   const t0 = Date.now();
   const detections = detectAll();
-  const { records, errors } = await loadAll(detections);
+  const { records: allRecords, errors } = await loadAll(detections);
+
+  // Apply --year filter before any aggregation so dateRange and totals
+  // reflect the filtered set.
+  const records = yearFilter !== null
+    ? allRecords.filter(r => r.month && r.month.startsWith(`${yearFilter}-`))
+    : allRecords;
+
   const range = dateRange(records);
   const tot = overall(records);
 
@@ -78,6 +94,7 @@ async function main() {
       summary: tot,
       dateRange: range,
       sessions: records,
+      filter: yearFilter !== null ? { year: yearFilter } : null,
       errors,
       generatedAt: new Date().toISOString(),
       durationMs: Date.now() - t0,
@@ -109,6 +126,8 @@ async function main() {
     sections.push(
       renderOverview(records, detections),
       renderPerProject(records),
+      renderPerTool(records),
+      renderPerToolPerMonth(records),
       renderPerMonth(records),
       renderPerWeek(records),
       renderTopSessions(records, topN),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-usage-analyzer",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "TUI analyzer for local AI coding agent token usage. Auto-detects Claude Code, Codex, OpenCode, MimoCode, Copilot, Antigravity, and Gemini.",
   "type": "module",
   "packageManager": "pnpm@10.33.0",

package/src/aggregate.js

@@ -2,8 +2,8 @@
 
 const MONTH_NAMES = {
   '01': 'Jan', '02': 'Feb', '03': 'Mar', '04': 'Apr',
-  '05': 'Mei', '06': 'Jun', '07': 'Jul', '08': 'Agu',
-  '09': 'Sep', '10': 'Okt', '11': 'Nov', '12': 'Des',
+  '05': 'May', '06': 'Jun', '07': 'Jul', '08': 'Aug',
+  '09': 'Sep', '10': 'Oct', '11': 'Nov', '12': 'Dec',
 };
 
 function sum(arr, key) {
@@ -38,13 +38,23 @@ function summarize(records) {
   };
 }
 
+function toolBreakdown(records) {
+  const byTool = {};
+  for (const r of records) {
+    byTool[r.tool] = (byTool[r.tool] || 0) + r.tokensTotal;
+  }
+  return byTool;
+}
+
 export function perProject(records) {
-  const m = groupBy(records, r => `${r.tool}\u0001${r.project}`);
+  // One row per project — tool mix is shown via the stacked bar / byTool,
+  // not as a separate column. Detailed per-tool-per-project breakdown
+  // is no longer surfaced here; the "Per Tool per Month" section is the
+  // place to see per-tool data over time.
+  const m = groupBy(records, r => r.project);
   const out = [];
-  for (const [k, arr] of m) {
-    const [tool, project] = k.split('\u0001');
-    const s = summarize(arr);
-    out.push({ tool, project, ...s });
+  for (const [project, arr] of m) {
+    out.push({ project, ...summarize(arr), byTool: toolBreakdown(arr) });
   }
   return out.sort((a, b) => b.tokensTotal - a.tokensTotal);
 }
@@ -53,11 +63,7 @@ export function perMonth(records) {
   const m = groupBy(records, r => r.month);
   const out = [];
   for (const [month, arr] of m) {
-    const byTool = {};
-    for (const r of arr) {
-      byTool[r.tool] = (byTool[r.tool] || 0) + r.tokensTotal;
-    }
-    out.push({ month, ...summarize(arr), byTool });
+    out.push({ month, ...summarize(arr), byTool: toolBreakdown(arr) });
   }
   return out.sort((a, b) => a.month.localeCompare(b.month));
 }
@@ -66,11 +72,7 @@ export function perWeek(records) {
   const m = groupBy(records, r => r.week);
   const out = [];
   for (const [week, arr] of m) {
-    const byTool = {};
-    for (const r of arr) {
-      byTool[r.tool] = (byTool[r.tool] || 0) + r.tokensTotal;
-    }
-    out.push({ week, ...summarize(arr), byTool });
+    out.push({ week, ...summarize(arr), byTool: toolBreakdown(arr) });
   }
   return out.sort((a, b) => a.week.localeCompare(b.week));
 }
@@ -84,6 +86,19 @@ export function perTool(records) {
   return out.sort((a, b) => b.tokensTotal - a.tokensTotal);
 }
 
+export function perToolPerMonth(records) {
+  // Cross-tab: one row per (tool, month). Lets you see how a single tool's
+  // usage is distributed across months — and avoids the hardcoded OC/CX/MM
+  // column problem in the per-month table.
+  const m = groupBy(records, r => `${r.tool}\u0001${r.month}`);
+  const out = [];
+  for (const [k, arr] of m) {
+    const [tool, month] = k.split('\u0001');
+    out.push({ tool, month, ...summarize(arr) });
+  }
+  return out.sort((a, b) => b.tokensTotal - a.tokensTotal);
+}
+
 export function overall(records) {
   return summarize(records);
 }

package/src/detectors.js

@@ -1,33 +1,14 @@
 // Auto-detect AI coding agent data directories.
 //
-// Strategy:
-//   1. Honor $AI_USAGE_PATHS_JSON if set (JSON map of { toolKey: "/abs/path" })
-//   2. Honor per-tool env var (e.g. $CLAUDE_HOME, $CODEX_HOME, $OPENCODE_HOME)
-//   3. Probe well-known locations per platform (mac/linux) relative to $HOME
-//   4. Return a status for each tool: 'present' | 'absent' | 'disabled'
-//
-// Tools that share the opencode SQLite schema are auto-registered.
-
-import { existsSync, statSync, readdirSync } from 'node:fs';
-import { join, isAbsolute } from 'node:path';
-import { homedir, platform } from 'node:os';
-import { env, exitCode } from 'node:process';
-import { createRequire } from 'node:module';
-const require = createRequire(import.meta.url);
-
-const HOME = homedir();
-const OS = platform(); // 'darwin' | 'linux' | 'win32'
+// All tool configuration (paths, env vars, kinds, display metadata) lives
+// in src/tools.js. This file only orchestrates: probe paths, apply user
+// overrides, and project each tool's metadata into the detection result.
 
-// macOS Application Support helper
-const APP_SUPPORT = OS === 'darwin'
-  ? join(HOME, 'Library', 'Application Support')
-  : process.env.XDG_DATA_HOME
-    ? join(process.env.XDG_DATA_HOME, '..')  // XDG_DATA_HOME/../ = ~/.local/share
-    : join(HOME, '.local', 'share');
+import { existsSync } from 'node:fs';
+import { isAbsolute } from 'node:path';
+import { env } from 'node:process';
+import { TOOLS, TOOL_ORDER } from './tools.js';
 
-const CONFIG_HOME = process.env.XDG_CONFIG_HOME || join(HOME, '.config');
-
-// Probe = array of candidate paths; first one that exists wins.
 function firstExisting(paths) {
   for (const p of paths) {
     if (p && existsSync(p)) return p;
@@ -35,236 +16,17 @@ function firstExisting(paths) {
   return null;
 }
 
-function isFile(p) {
-  try { return statSync(p).isFile(); } catch { return false; }
-}
-function isDir(p) {
-  try { return statSync(p).isDirectory(); } catch { return false; }
+function safeParseJSON(s) {
+  try { return JSON.parse(s); } catch { return {}; }
 }
 
-// ---------------------------------------------------------------------------
-// Detector definitions. Each entry returns:
-//   { key, name, kind, status, path, count, details }
-// ---------------------------------------------------------------------------
-
-const DETECTORS = [
-  // -----------------------------------------------------------------------
-  // Claude Code
-  // -----------------------------------------------------------------------
-  {
-    key: 'claude',
-    name: 'Claude Code',
-    kind: 'jsonl',
-    envVar: 'CLAUDE_HOME',
-    candidatePaths: () => [
-      env.CLAUDE_HOME
-        ? join(env.CLAUDE_HOME, 'projects')
-        : join(HOME, '.claude', 'projects'),
-    ],
-    count: (p) => {
-      if (!p) return 0;
-      let n = 0;
-      function walk(dir) {
-        try {
-          for (const e of readdirSync(dir, { withFileTypes: true })) {
-            const full = join(dir, e.name);
-            if (e.isDirectory()) walk(full);
-            else if (e.isFile() && e.name.endsWith('.jsonl')) n++;
-          }
-        } catch {}
-      }
-      walk(p);
-      return n;
-    },
-    hasTokens: false,  // transcripts only contain text, no token counts
-    description: '~/.claude/projects/*/<UUID>.jsonl  (no token data stored locally)',
-  },
-
-  // -----------------------------------------------------------------------
-  // Codex
-  // -----------------------------------------------------------------------
-  {
-    key: 'codex',
-    name: 'Codex',
-    kind: 'jsonl-rollout',
-    envVar: 'CODEX_HOME',
-    candidatePaths: () => [
-      env.CODEX_HOME || join(HOME, '.codex', 'sessions'),
-    ],
-    count: (p) => {
-      if (!p) return 0;
-      let n = 0;
-      function walk(dir) {
-        try {
-          for (const e of readdirSync(dir, { withFileTypes: true })) {
-            const full = join(dir, e.name);
-            if (e.isDirectory()) walk(full);
-            else if (e.isFile() && e.name.startsWith('rollout-') && e.name.endsWith('.jsonl')) n++;
-          }
-        } catch {}
-      }
-      walk(p);
-      return n;
-    },
-    hasTokens: true,
-    description: '~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl',
-  },
-
-  // -----------------------------------------------------------------------
-  // OpenCode
-  // -----------------------------------------------------------------------
-  {
-    key: 'opencode',
-    name: 'OpenCode',
-    kind: 'sqlite',
-    envVar: 'OPENCODE_HOME',
-    candidatePaths: () => [
-      env.OPENCODE_HOME
-        ? join(env.OPENCODE_HOME, 'opencode.db')
-        : join(HOME, '.local', 'share', 'opencode', 'opencode.db'),
-    ],
-    count: (p) => {
-      if (!p) return 0;
-      try {
-        const { DatabaseSync } = require('node:sqlite');
-        const db = new DatabaseSync(p, { readOnly: true });
-        return db.prepare('SELECT COUNT(*) AS c FROM session').get().c;
-      } catch { return 0; }
-    },
-    hasTokens: true,
-    description: '~/.local/share/opencode/opencode.db  (tokens + cost)',
-  },
-
-  // -----------------------------------------------------------------------
-  // MimoCode (same schema as OpenCode)
-  // -----------------------------------------------------------------------
-  {
-    key: 'mimocode',
-    name: 'MimoCode',
-    kind: 'sqlite',
-    envVar: 'MIMOCODE_HOME',
-    candidatePaths: () => [
-      env.MIMOCODE_HOME
-        ? join(env.MIMOCODE_HOME, 'mimocode.db')
-        : join(HOME, '.local', 'share', 'mimocode', 'mimocode.db'),
-    ],
-    count: (p) => {
-      if (!p) return 0;
-      try {
-        const { DatabaseSync } = require('node:sqlite');
-        const db = new DatabaseSync(p, { readOnly: true });
-        return db.prepare('SELECT COUNT(*) AS c FROM session').get().c;
-      } catch { return 0; }
-    },
-    hasTokens: true,
-    description: '~/.local/share/mimocode/mimocode.db  (tokens + cost)',
-  },
-
-  // -----------------------------------------------------------------------
-  // GitHub Copilot CLI
-  // -----------------------------------------------------------------------
-  {
-    key: 'copilot',
-    name: 'GitHub Copilot',
-    kind: 'jsonl-events',
-    envVar: 'COPILOT_HOME',
-    candidatePaths: () => {
-      const base = env.COPILOT_HOME || join(HOME, '.copilot');
-      return [
-        join(base, 'session-state'),
-        base,
-      ];
-    },
-    count: (p) => {
-      if (!p) return 0;
-      let n = 0;
-      function walk(dir) {
-        try {
-          for (const e of readdirSync(dir, { withFileTypes: true })) {
-            const full = join(dir, e.name);
-            if (e.isDirectory()) walk(full);
-            else if (e.isFile() && e.name.endsWith('.jsonl')) n++;
-          }
-        } catch {}
-      }
-      walk(p);
-      return n;
-    },
-    hasTokens: false,
-    description: '~/.copilot/session-state/*/events.jsonl  (no token data)',
-  },
-
-  // -----------------------------------------------------------------------
-  // Antigravity (VS Code variant) - mostly cache; no token data
-  // -----------------------------------------------------------------------
-  {
-    key: 'antigravity',
-    name: 'Antigravity',
-    kind: 'dir',
-    envVar: 'ANTIGRAVITY_HOME',
-    candidatePaths: () => {
-      const base = env.ANTIGRAVITY_HOME || join(APP_SUPPORT, 'Antigravity');
-      return [
-        base,
-        join(HOME, '.antigravity'),
-      ];
-    },
-    count: (p) => {
-      if (!p) return 0;
-      let n = 0;
-      try {
-        for (const e of readdirSync(p)) {
-          const full = join(p, e);
-          if (statSync(full).isDirectory()) n++;
-        }
-      } catch {}
-      return n;
-    },
-    hasTokens: false,
-    description: '~/Library/Application Support/Antigravity  (no token data)',
-  },
-
-  // -----------------------------------------------------------------------
-  // Gemini CLI
-  // -----------------------------------------------------------------------
-  {
-    key: 'gemini',
-    name: 'Gemini CLI',
-    kind: 'protobuf',
-    envVar: 'GEMINI_HOME',
-    candidatePaths: () => {
-      const base = env.GEMINI_HOME || join(HOME, '.gemini');
-      return [
-        join(base, 'antigravity', 'conversations'),
-        join(base, 'conversations'),
-      ];
-    },
-    count: (p) => {
-      if (!p) return 0;
-      let n = 0;
-      try {
-        for (const f of readdirSync(p)) {
-          if (f.endsWith('.pb')) n++;
-        }
-      } catch {}
-      return n;
-    },
-    hasTokens: false,
-    description: '~/.gemini/antigravity/conversations/*.pb  (binary, no token data)',
-  },
-];
-
-// ---------------------------------------------------------------------------
-// Public: run all detectors
-// ---------------------------------------------------------------------------
-
 export function detectAll(opts = {}) {
   const override = opts.override || (env.AI_USAGE_PATHS_JSON
     ? safeParseJSON(env.AI_USAGE_PATHS_JSON)
     : {});
 
   const results = [];
-  for (const def of DETECTORS) {
+  for (const def of TOOLS) {
     let candidatePaths = def.candidatePaths();
 
     // Apply override if user supplied one
@@ -292,12 +54,4 @@ export function detectAll(opts = {}) {
   return results;
 }
 
-function safeParseJSON(s) {
-  try { return JSON.parse(s); } catch { return {}; }
-}
-
-// ---------------------------------------------------------------------------
-// Public: just keys in order (for stable UI columns)
-// ---------------------------------------------------------------------------
-
-export const TOOL_ORDER = DETECTORS.map(d => d.key);
+export { TOOL_ORDER };

package/src/loaders.js

@@ -207,6 +207,113 @@ function walkJsonl(root, prefix) {
   return out;
 }
 
+// Walks Claude's projects/ tree. Top-level .jsonl files are sessions; files
+// under any `subagents/` subdir are deliberately skipped (their usage is
+// already represented in the parent session's assistant messages).
+function walkClaudeSessions(root) {
+  const out = [];
+  function walk(dir) {
+    let entries;
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      const full = join(dir, e.name);
+      if (e.isDirectory()) {
+        if (e.name === 'subagents') continue;
+        walk(full);
+      } else if (e.isFile() && e.name.endsWith('.jsonl')) {
+        out.push(full);
+      }
+    }
+  }
+  walk(root);
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Claude Code JSONL loader
+// ---------------------------------------------------------------------------
+//
+// Each top-level file under projects/<encoded-cwd>/<UUID>.jsonl is one session.
+// Per assistant line, `message.usage` carries the per-turn token counts; we
+// dedupe by `message.id` (Claude Code emits streaming duplicates) and sum
+// across unique messages. cwd / model / timestamp come from the line itself.
+
+async function loadClaudeJsonl(rootDir) {
+  const records = [];
+  const errors = [];
+  const files = walkClaudeSessions(rootDir);
+
+  for (const f of files) {
+    try {
+      const rec = await parseClaudeSession(f);
+      if (rec) records.push(rec);
+    } catch (e) {
+      errors.push(`${f}: ${e.message}`);
+    }
+  }
+  return { records, errors };
+}
+
+async function parseClaudeSession(path) {
+  const sessionId = path.split('/').pop().replace('.jsonl', '');
+  const seenIds = new Set();
+  let cwd = '';
+  let model = '';
+  let firstTs = null;
+
+  let tokensInput = 0;
+  let tokensOutput = 0;
+  let tokensCacheRead = 0;
+  let tokensCacheWrite = 0;
+
+  const stream = createReadStream(path, { encoding: 'utf8' });
+  const rl = createInterface({ input: stream, crlfDelay: Infinity });
+  for await (const line of rl) {
+    if (!line) continue;
+    let ev;
+    try { ev = JSON.parse(line); } catch { continue; }
+    if (ev.type !== 'assistant') continue;
+    const msg = ev.message || {};
+    const usage = msg.usage;
+    if (!usage) continue;
+    const id = msg.id;
+    if (id) {
+      if (seenIds.has(id)) continue;
+      seenIds.add(id);
+    }
+    if (!cwd && typeof ev.cwd === 'string') cwd = ev.cwd;
+    if (!model && typeof msg.model === 'string') model = msg.model;
+    const ts = parseIsoMs(ev.timestamp);
+    if (firstTs === null && ts !== null) firstTs = ts;
+    tokensInput += usage.input_tokens || 0;
+    tokensOutput += usage.output_tokens || 0;
+    tokensCacheRead += usage.cache_read_input_tokens || 0;
+    tokensCacheWrite += usage.cache_creation_input_tokens || 0;
+  }
+
+  const tot = tokensInput + tokensOutput + tokensCacheRead + tokensCacheWrite;
+  if (tot === 0) return null;
+  const ts = firstTs ?? Date.now();
+
+  return {
+    tool: 'claude',
+    sessionId,
+    project: compactHome(cwd),
+    title: '',
+    week: isoWeekKey(ts),
+    month: monthKey(ts),
+    ts,
+    tokensInput,
+    tokensOutput,
+    tokensCacheRead,
+    tokensCacheWrite,
+    tokensReasoning: 0,
+    tokensTotal: tot,
+    cost: 0,
+    model,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Public: load all session records for given detectors
 // ---------------------------------------------------------------------------
@@ -226,8 +333,12 @@ export async function loadAll(detections) {
       const r = await loadCodexRollouts(d.path);
       all.push(...r.records);
       if (r.errors) errors.push(...r.errors);
+    } else if (d.key === 'claude') {
+      const r = await loadClaudeJsonl(d.path);
+      all.push(...r.records);
+      if (r.errors) errors.push(...r.errors);
     }
-    // For other tools (claude, copilot, antigravity, gemini), we only have
+    // For other tools (copilot, antigravity, gemini), we only have
     // presence info — no token data to load.
   }
   return { records: all, errors };

package/src/markdown.js

@@ -3,9 +3,10 @@
 // copies cleanly into issues, PRs, Notion, etc.
 
 import {
-  perProject, perMonth, perWeek, perTool, overall, topSessions, tokenBreakdown,
+  perProject, perMonth, perWeek, perTool, perToolPerMonth, overall, topSessions, tokenBreakdown,
   MONTH_NAMES,
 } from './aggregate.js';
+import { getToolBarChar, TOOLS } from './tools.js';
 
 // ---------------------------------------------------------------------------
 // Number formatting helpers (re-implemented locally to avoid TUI deps)
@@ -41,6 +42,29 @@ function bar(value, max, width) {
   return '█'.repeat(filled) + '░'.repeat(width - filled);
 }
 
+// Markdown has no color, so each tool's stacked-bar segment is shown with
+// a distinct block character. The character for each tool is defined in
+// src/tools.js alongside its color.
+function stackedBar(byTool, width) {
+  const total = Object.values(byTool).reduce((a, b) => a + b, 0);
+  if (total <= 0 || width <= 0) return ' '.repeat(Math.max(0, width));
+  const entries = Object.entries(byTool)
+    .filter(([, v]) => v > 0)
+    .sort((a, b) => b[1] - a[1]);
+  let out = '';
+  let x = 0;
+  for (let i = 0; i < entries.length; i++) {
+    const [tool, value] = entries[i];
+    const segW = i === entries.length - 1
+      ? width - x
+      : Math.round((value / total) * width);
+    if (segW <= 0) continue;
+    out += getToolBarChar(tool).repeat(segW);
+    x += segW;
+  }
+  return out;
+}
+
 function pct(x) { return (x * 100).toFixed(1) + '%'; }
 
 function mdEscape(s) {
@@ -151,15 +175,53 @@ export function renderMarkdown({
   // Per Project ---------------------------------------------------------
   const projects = perProject(records);
   if (projects.length > 0) {
-    const max = projects[0].tokensTotal;
     out.push(`## Per Project`);
     out.push(``);
-    out.push(`| Tool | Project | Sessions | Input | Output | Cache | Total | Dist |`);
-    out.push(`|---|---|---:|---:|---:|---:|---:|---|`);
+    out.push(`| Project | Sessions | Input | Output | Cache | Total | Dist |`);
+    out.push(`|---|---:|---:|---:|---:|---:|---|`);
     for (const p of projects) {
       const cache = p.tokensCacheRead + p.tokensCacheWrite;
       const proj = compactHome(p.project);
-      out.push(`| ${mdEscape(p.tool)} | \`${mdEscape(proj)}\` | ${fmtInt(p.n)} | ${fmtCompact(p.tokensInput)} | ${fmtCompact(p.tokensOutput)} | ${fmtCompact(cache)} | ${fmtCompact(p.tokensTotal)} | ${bar(p.tokensTotal, max, 20)} |`);
+      out.push(`| \`${mdEscape(proj)}\` | ${fmtInt(p.n)} | ${fmtCompact(p.tokensInput)} | ${fmtCompact(p.tokensOutput)} | ${fmtCompact(cache)} | ${fmtCompact(p.tokensTotal)} | ${stackedBar(p.byTool, 20)} |`);
+    }
+    out.push(``);
+    const legend = TOOLS
+      .filter(t => t.hasTokens)
+      .map(t => `\`${t.barChar}\` ${t.label}`)
+      .join(' · ');
+    out.push(`_Bar legend: ${legend} · \`·\` other_`);
+    out.push(``);
+  }
+
+  // Per Tool ------------------------------------------------------------
+  const toolRows = perTool(records);
+  if (toolRows.length > 0) {
+    const max = toolRows[0].tokensTotal;
+    out.push(`## Per Tool`);
+    out.push(``);
+    out.push(`| Tool | Sessions | Input | Output | Cache | Total | Cost | Avg/sess | Dist |`);
+    out.push(`|---|---:|---:|---:|---:|---:|---:|---:|---|`);
+    for (const p of toolRows) {
+      const cache = p.tokensCacheRead + p.tokensCacheWrite;
+      out.push(`| ${mdEscape(p.tool)} | ${fmtInt(p.n)} | ${fmtCompact(p.tokensInput)} | ${fmtCompact(p.tokensOutput)} | ${fmtCompact(cache)} | ${fmtCompact(p.tokensTotal)} | ${fmtCost(p.cost)} | ${fmtCompact(p.avg)} | ${bar(p.tokensTotal, max, 20)} |`);
+    }
+    out.push(``);
+  }
+
+  // Per Tool per Month ---------------------------------------------------
+  const tpmRows = perToolPerMonth(records);
+  if (tpmRows.length > 0) {
+    const max = tpmRows[0].tokensTotal;
+    out.push(`## Per Tool per Month`);
+    out.push(``);
+    out.push(`| Tool | Month | Sessions | Input | Output | Cache | Total | Dist |`);
+    out.push(`|---|---|---:|---:|---:|---:|---:|---|`);
+    for (const p of tpmRows) {
+      const cache = p.tokensCacheRead + p.tokensCacheWrite;
+      const yyyy = p.month.slice(0, 4);
+      const mm = p.month.slice(5, 7);
+      const label = `${MONTH_NAMES[mm] || mm} ${yyyy}`;
+      out.push(`| ${mdEscape(p.tool)} | ${label} | ${fmtInt(p.n)} | ${fmtCompact(p.tokensInput)} | ${fmtCompact(p.tokensOutput)} | ${fmtCompact(cache)} | ${fmtCompact(p.tokensTotal)} | ${bar(p.tokensTotal, max, 18)} |`);
     }
     out.push(``);
   }
@@ -167,16 +229,15 @@ export function renderMarkdown({
   // Per Month -----------------------------------------------------------
   const months = perMonth(records);
   if (months.length > 0) {
-    const max = Math.max(...months.map(m => m.tokensTotal));
     out.push(`## Per Month`);
     out.push(``);
-    out.push(`| Month | Sessions | Input | Output | Total | OC | CX | MM | Dist |`);
-    out.push(`|---|---:|---:|---:|---:|---:|---:|---:|---|`);
+    out.push(`| Month | Sessions | Input | Output | Total | Dist |`);
+    out.push(`|---|---:|---:|---:|---:|---|`);
     for (const m of months) {
       const yyyy = m.month.slice(0, 4);
       const mm = m.month.slice(5, 7);
       const label = `${MONTH_NAMES[mm] || mm} ${yyyy}`;
-      out.push(`| ${label} | ${fmtInt(m.n)} | ${fmtCompact(m.tokensInput)} | ${fmtCompact(m.tokensOutput)} | ${fmtCompact(m.tokensTotal)} | ${m.byTool.opencode ? fmtCompact(m.byTool.opencode) : '—'} | ${m.byTool.codex ? fmtCompact(m.byTool.codex) : '—'} | ${m.byTool.mimocode ? fmtCompact(m.byTool.mimocode) : '—'} | ${bar(m.tokensTotal, max, 20)} |`);
+      out.push(`| ${label} | ${fmtInt(m.n)} | ${fmtCompact(m.tokensInput)} | ${fmtCompact(m.tokensOutput)} | ${fmtCompact(m.tokensTotal)} | ${stackedBar(m.byTool, 20)} |`);
     }
     out.push(``);
   }
@@ -184,13 +245,12 @@ export function renderMarkdown({
   // Per Week ------------------------------------------------------------
   const weeks = perWeek(records);
   if (weeks.length > 0) {
-    const max = Math.max(...weeks.map(w => w.tokensTotal));
     out.push(`## Per Week`);
     out.push(``);
-    out.push(`| Week | Sessions | Input | Output | Total | OC | CX | MM | Dist |`);
-    out.push(`|---|---:|---:|---:|---:|---:|---:|---:|---|`);
+    out.push(`| Week | Sessions | Input | Output | Total | Dist |`);
+    out.push(`|---|---:|---:|---:|---:|---|`);
     for (const w of weeks) {
-      out.push(`| ${w.week} | ${fmtInt(w.n)} | ${fmtCompact(w.tokensInput)} | ${fmtCompact(w.tokensOutput)} | ${fmtCompact(w.tokensTotal)} | ${w.byTool.opencode ? fmtCompact(w.byTool.opencode) : '—'} | ${w.byTool.codex ? fmtCompact(w.byTool.codex) : '—'} | ${w.byTool.mimocode ? fmtCompact(w.byTool.mimocode) : '—'} | ${bar(w.tokensTotal, max, 18)} |`);
+      out.push(`| ${w.week} | ${fmtInt(w.n)} | ${fmtCompact(w.tokensInput)} | ${fmtCompact(w.tokensOutput)} | ${fmtCompact(w.tokensTotal)} | ${stackedBar(w.byTool, 18)} |`);
     }
     out.push(``);
   }

package/src/render.js

@@ -6,9 +6,10 @@ import boxen from 'boxen';
 import gradient from 'gradient-string';
 import process from 'node:process';
 import {
-  perProject, perMonth, perWeek, perTool, overall, topSessions, tokenBreakdown,
+  perProject, perMonth, perWeek, perTool, perToolPerMonth, overall, topSessions, tokenBreakdown,
   MONTH_NAMES,
 } from './aggregate.js';
+import { getToolColor } from './tools.js';
 
 // ---------------------------------------------------------------------------
 // Terminal width detection
@@ -63,34 +64,45 @@ export function fmtCost(n) {
 // Color helpers
 // ---------------------------------------------------------------------------
 
-const TOOL_COLORS = {
-  opencode: 'cyan',
-  codex: 'magenta',
-  mimocode: 'yellow',
-  claude: 'blue',
-  copilot: 'green',
-  antigravity: 'red',
-  gemini: 'gray',
-};
-
-export function toolColor(t) { return TOOL_COLORS[t] || 'white'; }
-export function colorize(t, c) { return chalk.hex(toHex(c))(t); }
-
-function toHex(name) {
-  const m = {
-    red: '#ff5555', green: '#50fa7b', yellow: '#f1fa8c',
-    blue: '#8be9fd', magenta: '#ff79c6', cyan: '#8be9fd',
-    white: '#f8f8f2', gray: '#6272a4',
-  };
-  return m[name] || '#ffffff';
-}
+export function toolColor(t) { return getToolColor(t); }
+export function colorize(t, c) { return chalk.hex(c)(t); }
+
+// Cool-to-warm gradient: small bars feel subtle, large bars pop.
+const BAR_GRADIENT = gradient(['#3b82f6', '#14b8a6', '#f1fa8c', '#ff9e64']);
 
-function bar(value, max, width, color) {
+function bar(value, max, width) {
   if (max <= 0) return ' '.repeat(width);
   const pct = Math.max(0, Math.min(1, value / max));
   const filled = Math.round(pct * width);
   const empty = width - filled;
-  return chalk.hex(toHex(color))('█'.repeat(filled)) + chalk.gray('░'.repeat(empty));
+  if (filled === 0) return chalk.gray('░'.repeat(width));
+  return BAR_GRADIENT('█'.repeat(filled)) + chalk.gray('░'.repeat(empty));
+}
+
+// Stacked bar — one segment per tool, widths proportional to that tool's
+// share of the row's total. Used wherever a row spans multiple tools
+// (per-project / per-month / per-week). Single-tool rows are just one
+// colored segment; no change in feel.
+function stackedBar(byTool, width) {
+  const total = Object.values(byTool).reduce((a, b) => a + b, 0);
+  if (total <= 0 || width <= 0) return ' '.repeat(Math.max(0, width));
+  const entries = Object.entries(byTool)
+    .filter(([, v]) => v > 0)
+    .sort((a, b) => b[1] - a[1]);
+  let out = '';
+  let x = 0;
+  for (let i = 0; i < entries.length; i++) {
+    const [tool, value] = entries[i];
+    // Last segment fills the remaining width so rounding doesn't leave
+    // a visible gap or overshoot.
+    const segW = i === entries.length - 1
+      ? width - x
+      : Math.round((value / total) * width);
+    if (segW <= 0) continue;
+    out += chalk.hex(toolColor(tool))('█'.repeat(segW));
+    x += segW;
+  }
+  return out;
 }
 
 function shortModel(m) {
@@ -250,23 +262,60 @@ function pct(x) { return (x * 100).toFixed(1) + '%'; }
 export function renderPerProject(records) {
   const items = perProject(records);
   if (items.length === 0) return '';
-  const max = items[0].tokensTotal;
   const barW = NARROW ? 10 : 18;
 
   // Narrow mode: drop In/Out/Cache columns, just show n + Total + Dist
   const head = NARROW
-    ? [chalk.bold('Tool'), chalk.bold('Project'), chalk.bold('n'),
+    ? [chalk.bold('Project'), chalk.bold('n'),
        chalk.bold('Total'), chalk.bold('Dist')]
-    : [chalk.bold('Tool'), chalk.bold('Project'), chalk.bold('n'),
+    : [chalk.bold('Project'), chalk.bold('n'),
        chalk.bold('In'), chalk.bold('Out'),
        chalk.bold('Cache'), chalk.bold('Total'), chalk.bold('Dist')];
   const t = new Table({ head, style: { head: [], border: [] } });
 
+  for (const p of items) {
+    const cache = p.tokensCacheRead + p.tokensCacheWrite;
+    const row = [truncEnd(p.project, NARROW ? 28 : 40), fmtInt(p.n)];
+    if (!NARROW) {
+      row.push(
+        fmtCompact(p.tokensInput),
+        fmtCompact(p.tokensOutput),
+        fmtCompact(cache),
+      );
+    }
+    row.push(fmtCompact(p.tokensTotal), stackedBar(p.byTool, barW));
+    t.push(row);
+  }
+  return boxen(t.toString(), {
+    title: chalk.bold('Per Project'),
+    borderStyle: 'round',
+    borderColor: 'cyan',
+    padding: { top: 0, bottom: 0, left: 1, right: 1 },
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Per Tool (detailed — complements the brief summary in Overview)
+// ---------------------------------------------------------------------------
+
+export function renderPerTool(records) {
+  const items = perTool(records);
+  if (items.length === 0) return '';
+  const max = items[0].tokensTotal;
+  const barW = NARROW ? 10 : 18;
+
+  const head = NARROW
+    ? [chalk.bold('Tool'), chalk.bold('n'),
+       chalk.bold('Total'), chalk.bold('Cost'), chalk.bold('Avg/sess'), chalk.bold('Dist')]
+    : [chalk.bold('Tool'), chalk.bold('n'),
+       chalk.bold('Input'), chalk.bold('Output'), chalk.bold('Cache'),
+       chalk.bold('Total'), chalk.bold('Cost'), chalk.bold('Avg/sess'), chalk.bold('Dist')];
+  const t = new Table({ head, style: { head: [], border: [] } });
+
   for (const p of items) {
     const cache = p.tokensCacheRead + p.tokensCacheWrite;
     const row = [
       colorize(p.tool, toolColor(p.tool)),
-      truncEnd(p.project, NARROW ? 26 : 38),
       fmtInt(p.n),
     ];
     if (!NARROW) {
@@ -278,12 +327,63 @@ export function renderPerProject(records) {
     }
     row.push(
       fmtCompact(p.tokensTotal),
-      bar(p.tokensTotal, max, barW, toolColor(p.tool)),
+      fmtCost(p.cost),
+      fmtCompact(p.avg),
+      bar(p.tokensTotal, max, barW),
     );
     t.push(row);
   }
   return boxen(t.toString(), {
-    title: chalk.bold('Per Project'),
+    title: chalk.bold('Per Tool'),
+    borderStyle: 'round',
+    borderColor: 'magenta',
+    padding: { top: 0, bottom: 0, left: 1, right: 1 },
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Per Tool per Month (cross-tab — one row per (tool, month))
+// ---------------------------------------------------------------------------
+
+export function renderPerToolPerMonth(records) {
+  const items = perToolPerMonth(records);
+  if (items.length === 0) return '';
+  const max = items[0].tokensTotal;
+  const barW = NARROW ? 8 : 16;
+
+  const head = NARROW
+    ? [chalk.bold('Tool'), chalk.bold('Month'), chalk.bold('n'),
+       chalk.bold('Total'), chalk.bold('Dist')]
+    : [chalk.bold('Tool'), chalk.bold('Month'), chalk.bold('n'),
+       chalk.bold('Input'), chalk.bold('Output'), chalk.bold('Cache'),
+       chalk.bold('Total'), chalk.bold('Dist')];
+  const t = new Table({ head, style: { head: [], border: [] } });
+
+  for (const p of items) {
+    const cache = p.tokensCacheRead + p.tokensCacheWrite;
+    const yyyy = p.month.slice(0, 4);
+    const mm = p.month.slice(5, 7);
+    const monthLabel = `${MONTH_NAMES[mm] || mm} ${yyyy}`;
+    const row = [
+      colorize(p.tool, toolColor(p.tool)),
+      chalk.bold(monthLabel),
+      fmtInt(p.n),
+    ];
+    if (!NARROW) {
+      row.push(
+        fmtCompact(p.tokensInput),
+        fmtCompact(p.tokensOutput),
+        fmtCompact(cache),
+      );
+    }
+    row.push(
+      fmtCompact(p.tokensTotal),
+      bar(p.tokensTotal, max, barW),
+    );
+    t.push(row);
+  }
+  return boxen(t.toString(), {
+    title: chalk.bold('Per Tool per Month'),
     borderStyle: 'round',
     borderColor: 'cyan',
     padding: { top: 0, bottom: 0, left: 1, right: 1 },
@@ -297,64 +397,42 @@ export function renderPerProject(records) {
 export function renderPerMonth(records) {
   const items = perMonth(records);
   if (items.length === 0) return '';
-  const max = Math.max(...items.map(p => p.tokensTotal));
   const barW = NARROW ? 10 : 16;
-  const t1 = perTool(records);
 
-  // Narrow mode: drop the byTool columns (OC/CX/MM), keep core metrics
-  const head = NARROW
-    ? [chalk.bold('Month'), chalk.bold('n'),
-       chalk.bold('Input'), chalk.bold('Output'),
-       chalk.bold('Total'), chalk.bold('Dist')]
-    : [chalk.bold('Month'), chalk.bold('n'),
-       chalk.bold('Input'), chalk.bold('Output'),
-       chalk.bold('Total'), chalk.bold('OC'),
-       chalk.bold('CX'), chalk.bold('MM'), chalk.bold('Dist')];
+  const head = [
+    chalk.bold('Month'), chalk.bold('n'),
+    chalk.bold('Input'), chalk.bold('Output'),
+    chalk.bold('Total'), chalk.bold('Dist'),
+  ];
   const t = new Table({ head, style: { head: [], border: [] } });
 
   for (const p of items) {
     const yyyy = p.month.slice(0, 4);
     const mm = p.month.slice(5, 7);
     const label = `${MONTH_NAMES[mm] || mm} ${yyyy}`;
-    const row = [
+    t.push([
       chalk.bold(label),
       fmtInt(p.n),
       fmtCompact(p.tokensInput),
       fmtCompact(p.tokensOutput),
       fmtCompact(p.tokensTotal),
-    ];
-    if (!NARROW) {
-      row.push(
-        p.byTool.opencode ? fmtCompact(p.byTool.opencode) : chalk.dim('—'),
-        p.byTool.codex ? fmtCompact(p.byTool.codex) : chalk.dim('—'),
-        p.byTool.mimocode ? fmtCompact(p.byTool.mimocode) : chalk.dim('—'),
-      );
-    }
-    row.push(bar(p.tokensTotal, max, barW, 'green'));
-    t.push(row);
+      stackedBar(p.byTool, barW),
+    ]);
   }
 
   // TOTAL row
   const tot = overall(records);
-  const totalRow = [
+  t.push([
     chalk.bgGray.white.bold(' TOTAL '),
     chalk.bgGray.white.bold(fmtInt(records.length)),
     chalk.bgGray.white.bold(fmtCompact(tot.tokensInput)),
     chalk.bgGray.white.bold(fmtCompact(tot.tokensOutput)),
     chalk.bgGray.white.bold(fmtCompact(tot.tokensTotal)),
-  ];
-  if (!NARROW) {
-    totalRow.push(
-      chalk.bgGray.white.bold(fmtCompact(t1.find(p => p.tool === 'opencode')?.tokensTotal || 0)),
-      chalk.bgGray.white.bold(fmtCompact(t1.find(p => p.tool === 'codex')?.tokensTotal || 0)),
-      chalk.bgGray.white.bold(fmtCompact(t1.find(p => p.tool === 'mimocode')?.tokensTotal || 0)),
-    );
-  }
-  totalRow.push('');
-  t.push(totalRow);
+    '',
+  ]);
 
   return boxen(t.toString(), {
-    title: chalk.bold('Per Bulan (Monthly)'),
+    title: chalk.bold('Per Month'),
     borderStyle: 'round',
     borderColor: 'green',
     padding: { top: 0, bottom: 0, left: 1, right: 1 },
@@ -368,60 +446,38 @@ export function renderPerMonth(records) {
 export function renderPerWeek(records) {
   const items = perWeek(records);
   if (items.length === 0) return '';
-  const max = Math.max(...items.map(p => p.tokensTotal));
   const barW = NARROW ? 10 : 14;
-  const t1 = perTool(records);
 
-  const head = NARROW
-    ? [chalk.bold('ISO Week'), chalk.bold('n'),
-       chalk.bold('Input'), chalk.bold('Output'),
-       chalk.bold('Total'), chalk.bold('Dist')]
-    : [chalk.bold('ISO Week'), chalk.bold('n'),
-       chalk.bold('Input'), chalk.bold('Output'),
-       chalk.bold('Total'), chalk.bold('OC'),
-       chalk.bold('CX'), chalk.bold('MM'), chalk.bold('Dist')];
+  const head = [
+    chalk.bold('ISO Week'), chalk.bold('n'),
+    chalk.bold('Input'), chalk.bold('Output'),
+    chalk.bold('Total'), chalk.bold('Dist'),
+  ];
   const t = new Table({ head, style: { head: [], border: [] } });
 
   for (const p of items) {
-    const dominantTool = Object.entries(p.byTool).sort((a, b) => b[1] - a[1])[0]?.[0] || 'opencode';
-    const row = [
+    t.push([
       chalk.bold(p.week),
       fmtInt(p.n),
       fmtCompact(p.tokensInput),
       fmtCompact(p.tokensOutput),
       fmtCompact(p.tokensTotal),
-    ];
-    if (!NARROW) {
-      row.push(
-        p.byTool.opencode ? fmtCompact(p.byTool.opencode) : chalk.dim('—'),
-        p.byTool.codex ? fmtCompact(p.byTool.codex) : chalk.dim('—'),
-        p.byTool.mimocode ? fmtCompact(p.byTool.mimocode) : chalk.dim('—'),
-      );
-    }
-    row.push(bar(p.tokensTotal, max, barW, toolColor(dominantTool)));
-    t.push(row);
+      stackedBar(p.byTool, barW),
+    ]);
   }
   // TOTAL row
   const tot = overall(records);
-  const totalRow = [
+  t.push([
     chalk.bgGray.white.bold(' TOTAL '),
     chalk.bgGray.white.bold(fmtInt(records.length)),
     chalk.bgGray.white.bold(fmtCompact(tot.tokensInput)),
     chalk.bgGray.white.bold(fmtCompact(tot.tokensOutput)),
     chalk.bgGray.white.bold(fmtCompact(tot.tokensTotal)),
-  ];
-  if (!NARROW) {
-    totalRow.push(
-      chalk.bgGray.white.bold(fmtCompact(t1.find(p => p.tool === 'opencode')?.tokensTotal || 0)),
-      chalk.bgGray.white.bold(fmtCompact(t1.find(p => p.tool === 'codex')?.tokensTotal || 0)),
-      chalk.bgGray.white.bold(fmtCompact(t1.find(p => p.tool === 'mimocode')?.tokensTotal || 0)),
-    );
-  }
-  totalRow.push('');
-  t.push(totalRow);
+    '',
+  ]);
 
   return boxen(t.toString(), {
-    title: chalk.bold('Per Minggu (Weekly)'),
+    title: chalk.bold('Per Week'),
     borderStyle: 'round',
     borderColor: 'magenta',
     padding: { top: 0, bottom: 0, left: 1, right: 1 },

package/src/tools.js

@@ -0,0 +1,259 @@
+// Single source of truth for every AI coding tool this analyzer supports.
+//
+// Each tool entry describes both:
+//   - How to find it on disk (kind, envVar, candidatePaths, count)
+//   - How to render it in the report (name, label, color, barChar)
+//
+// To add a new tool, append one entry to TOOLS. If the tool exposes token
+// data, also wire a loader branch in src/loaders.js.
+
+import { statSync, readdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir, platform } from 'node:os';
+import { env } from 'node:process';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+
+const HOME = homedir();
+const OS = platform(); // 'darwin' | 'linux' | 'win32'
+
+const APP_SUPPORT = OS === 'darwin'
+  ? join(HOME, 'Library', 'Application Support')
+  : env.XDG_DATA_HOME
+    ? join(env.XDG_DATA_HOME, '..')  // XDG_DATA_HOME/../ = ~/.local/share
+    : join(HOME, '.local', 'share');
+
+// ---------------------------------------------------------------------------
+// Reusable count helpers
+// ---------------------------------------------------------------------------
+
+function countJsonlRecursive(dir) {
+  if (!dir) return 0;
+  let n = 0;
+  function walk(d) {
+    try {
+      for (const e of readdirSync(d, { withFileTypes: true })) {
+        const full = join(d, e.name);
+        if (e.isDirectory()) walk(full);
+        else if (e.isFile() && e.name.endsWith('.jsonl')) n++;
+      }
+    } catch {}
+  }
+  walk(dir);
+  return n;
+}
+
+function countSqliteRows(dbPath) {
+  if (!dbPath) return 0;
+  try {
+    const { DatabaseSync } = require('node:sqlite');
+    const db = new DatabaseSync(dbPath, { readOnly: true });
+    return db.prepare('SELECT COUNT(*) AS c FROM session').get().c;
+  } catch { return 0; }
+}
+
+function countSubdirs(dir) {
+  if (!dir) return 0;
+  let n = 0;
+  try {
+    for (const e of readdirSync(dir)) {
+      const full = join(dir, e);
+      if (statSync(full).isDirectory()) n++;
+    }
+  } catch {}
+  return n;
+}
+
+function countProtobuf(dir) {
+  if (!dir) return 0;
+  let n = 0;
+  try {
+    for (const f of readdirSync(dir)) {
+      if (f.endsWith('.pb')) n++;
+    }
+  } catch {}
+  return n;
+}
+
+// ---------------------------------------------------------------------------
+// Tool definitions
+// ---------------------------------------------------------------------------
+
+export const TOOLS = [
+  // -----------------------------------------------------------------------
+  // Claude Code
+  // -----------------------------------------------------------------------
+  {
+    key: 'claude',
+    name: 'Claude Code',
+    label: 'claude',
+    color: '#ff9e64',     // orange
+    barChar: '█',
+    kind: 'jsonl',
+    envVar: 'CLAUDE_HOME',
+    candidatePaths: () => [
+      env.CLAUDE_HOME
+        ? join(env.CLAUDE_HOME, 'projects')
+        : join(HOME, '.claude', 'projects'),
+    ],
+    count: countJsonlRecursive,
+    hasTokens: true,
+    description: '~/.claude/projects/*/<UUID>.jsonl  (per-message usage in assistant lines)',
+  },
+
+  // -----------------------------------------------------------------------
+  // Codex
+  // -----------------------------------------------------------------------
+  {
+    key: 'codex',
+    name: 'Codex',
+    label: 'codex',
+    color: '#87ceeb',     // sky blue
+    barChar: '▓',
+    kind: 'jsonl-rollout',
+    envVar: 'CODEX_HOME',
+    candidatePaths: () => [
+      env.CODEX_HOME || join(HOME, '.codex', 'sessions'),
+    ],
+    count: countJsonlRecursive,
+    hasTokens: true,
+    description: '~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl',
+  },
+
+  // -----------------------------------------------------------------------
+  // OpenCode
+  // -----------------------------------------------------------------------
+  {
+    key: 'opencode',
+    name: 'OpenCode',
+    label: 'opencode',
+    color: '#f8f8f2',     // white
+    barChar: '▒',
+    kind: 'sqlite',
+    envVar: 'OPENCODE_HOME',
+    candidatePaths: () => [
+      env.OPENCODE_HOME
+        ? join(env.OPENCODE_HOME, 'opencode.db')
+        : join(HOME, '.local', 'share', 'opencode', 'opencode.db'),
+    ],
+    count: countSqliteRows,
+    hasTokens: true,
+    description: '~/.local/share/opencode/opencode.db  (tokens + cost)',
+  },
+
+  // -----------------------------------------------------------------------
+  // MimoCode (same schema as OpenCode)
+  // -----------------------------------------------------------------------
+  {
+    key: 'mimocode',
+    name: 'MimoCode',
+    label: 'mimocode',
+    color: '#f1fa8c',     // yellow
+    barChar: '░',
+    kind: 'sqlite',
+    envVar: 'MIMOCODE_HOME',
+    candidatePaths: () => [
+      env.MIMOCODE_HOME
+        ? join(env.MIMOCODE_HOME, 'mimocode.db')
+        : join(HOME, '.local', 'share', 'mimocode', 'mimocode.db'),
+    ],
+    count: countSqliteRows,
+    hasTokens: true,
+    description: '~/.local/share/mimocode/mimocode.db  (tokens + cost)',
+  },
+
+  // -----------------------------------------------------------------------
+  // GitHub Copilot CLI (presence only)
+  // -----------------------------------------------------------------------
+  {
+    key: 'copilot',
+    name: 'GitHub Copilot',
+    label: 'copilot',
+    color: '#3b82f6',     // deep blue
+    barChar: '·',
+    kind: 'jsonl-events',
+    envVar: 'COPILOT_HOME',
+    candidatePaths: () => {
+      const base = env.COPILOT_HOME || join(HOME, '.copilot');
+      return [
+        join(base, 'session-state'),
+        base,
+      ];
+    },
+    count: countJsonlRecursive,
+    hasTokens: false,
+    description: '~/.copilot/session-state/*/events.jsonl  (no token data)',
+  },
+
+  // -----------------------------------------------------------------------
+  // Antigravity (VS Code variant) - mostly cache; no token data
+  // -----------------------------------------------------------------------
+  {
+    key: 'antigravity',
+    name: 'Antigravity',
+    label: 'antigravity',
+    color: '#ff5555',     // red
+    barChar: '·',
+    kind: 'dir',
+    envVar: 'ANTIGRAVITY_HOME',
+    candidatePaths: () => [
+      env.ANTIGRAVITY_HOME || APP_SUPPORT + '/Antigravity',
+      join(HOME, '.antigravity'),
+    ],
+    count: countSubdirs,
+    hasTokens: false,
+    description: '~/Library/Application Support/Antigravity  (no token data)',
+  },
+
+  // -----------------------------------------------------------------------
+  // Gemini CLI
+  // -----------------------------------------------------------------------
+  {
+    key: 'gemini',
+    name: 'Gemini CLI',
+    label: 'gemini',
+    color: '#14b8a6',     // teal
+    barChar: '·',
+    kind: 'protobuf',
+    envVar: 'GEMINI_HOME',
+    candidatePaths: () => {
+      const base = env.GEMINI_HOME || join(HOME, '.gemini');
+      return [
+        join(base, 'antigravity', 'conversations'),
+        join(base, 'conversations'),
+      ];
+    },
+    count: countProtobuf,
+    hasTokens: false,
+    description: '~/.gemini/antigravity/conversations/*.pb  (binary, no token data)',
+  },
+];
+
+// ---------------------------------------------------------------------------
+// Lookup helpers — consumers should use these instead of indexing TOOLS
+// directly so the null-handling stays in one place.
+// ---------------------------------------------------------------------------
+
+const TOOL_BY_KEY = new Map(TOOLS.map(t => [t.key, t]));
+const FALLBACK_COLOR = '#ffffff';
+const FALLBACK_BAR_CHAR = '·';
+
+export function getTool(key) {
+  return TOOL_BY_KEY.get(key) || null;
+}
+
+export function getToolColor(key) {
+  return TOOL_BY_KEY.get(key)?.color ?? FALLBACK_COLOR;
+}
+
+export function getToolBarChar(key) {
+  return TOOL_BY_KEY.get(key)?.barChar ?? FALLBACK_BAR_CHAR;
+}
+
+export function getToolLabel(key) {
+  return TOOL_BY_KEY.get(key)?.label ?? key;
+}
+
+// Stable UI column order — derived from TOOLS so adding a tool only
+// requires one edit in this file.
+export const TOOL_ORDER = TOOLS.map(t => t.key);