ccclub 0.3.2 → 0.3.3

package/dist/index.js

@@ -4,7 +4,7 @@
 import { Command, Option } from "commander";
 
 // src/commands/init.ts
-import { createInterface } from "readline/promises";
+import { createInterface as createInterface2 } from "readline/promises";
 import { stdin, stdout } from "process";
 import chalk4 from "chalk";
 import ora2 from "ora";
@@ -17,11 +17,31 @@ import { existsSync } from "fs";
 import { randomBytes } from "crypto";
 import { execSync } from "child_process";
 
+// ../shared/dist/types.js
+var AGENT_SOURCES = ["claude", "codex", "opencode", "amp", "pi"];
+var AGENT_LABELS = {
+  claude: "Claude",
+  codex: "Codex",
+  opencode: "OpenCode",
+  amp: "Amp",
+  pi: "pi-agent"
+};
+
 // ../shared/dist/constants.js
 var BLOCK_DURATION_MIN = 30;
 var BLOCK_DURATION_MS = BLOCK_DURATION_MIN * 60 * 1e3;
 var DEFAULT_API_URL = "https://ccclub.dev";
 var CLAUDE_PROJECTS_DIR = ".claude/projects";
+var CLAUDE_CONFIG_PROJECTS_DIR = ".config/claude/projects";
+var CLAUDE_CONFIG_DIR_ENV = "CLAUDE_CONFIG_DIR";
+var CODEX_HOME_ENV = "CODEX_HOME";
+var OPENCODE_DATA_DIR_ENV = "OPENCODE_DATA_DIR";
+var AMP_DATA_DIR_ENV = "AMP_DATA_DIR";
+var PI_AGENT_DIR_ENV = "PI_AGENT_DIR";
+var DEFAULT_CODEX_DIR = ".codex";
+var DEFAULT_OPENCODE_DIR = ".local/share/opencode";
+var DEFAULT_AMP_DIR = ".local/share/amp";
+var DEFAULT_PI_AGENT_SESSIONS_DIR = ".pi/agent/sessions";
 var CCCLUB_CONFIG_DIR = ".ccclub";
 var PLAN_PRICES = {
   pro: 20,
@@ -47,12 +67,25 @@ var MODEL_PRICING = {
   "claude-3-5-sonnet-20241022": { input: 3, output: 15, cacheCreation: 3.75, cacheRead: 0.3 },
   // Haiku
   "claude-haiku-4-5-20251001": { input: 1, output: 5, cacheCreation: 1.25, cacheRead: 0.1 },
-  "claude-3-5-haiku-20241022": { input: 0.8, output: 4, cacheCreation: 1, cacheRead: 0.08 }
+  "claude-3-5-haiku-20241022": { input: 0.8, output: 4, cacheCreation: 1, cacheRead: 0.08 },
+  // OpenAI GPT family fallbacks. Many agent logs provide exact costs; these are best-effort
+  // estimates for sources that only expose tokens.
+  "gpt-5": { input: 1.25, output: 10, cacheCreation: 0, cacheRead: 0.125 },
+  "gpt-5-mini": { input: 0.25, output: 2, cacheCreation: 0, cacheRead: 0.025 },
+  "gpt-5-nano": { input: 0.05, output: 0.4, cacheCreation: 0, cacheRead: 5e-3 }
 };
 var FAMILY_FALLBACK = {
   opus: MODEL_PRICING["claude-opus-4-6"],
   sonnet: MODEL_PRICING["claude-sonnet-4-5-20250929"],
-  haiku: MODEL_PRICING["claude-haiku-4-5-20251001"]
+  haiku: MODEL_PRICING["claude-haiku-4-5-20251001"],
+  "gpt-5-nano": MODEL_PRICING["gpt-5-nano"],
+  "gpt-5-mini": MODEL_PRICING["gpt-5-mini"],
+  "gpt-5": MODEL_PRICING["gpt-5"],
+  gpt: MODEL_PRICING["gpt-5"],
+  o3: MODEL_PRICING["gpt-5"],
+  o4: MODEL_PRICING["gpt-5"],
+  gemini: { input: 1.25, output: 10, cacheCreation: 0, cacheRead: 0.125 },
+  deepseek: { input: 0.27, output: 1.1, cacheCreation: 0, cacheRead: 0.07 }
 };
 function getPricing(model) {
   if (MODEL_PRICING[model])
@@ -64,9 +97,9 @@ function getPricing(model) {
   }
   return FAMILY_FALLBACK.sonnet;
 }
-function calculateCost(model, inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens) {
+function calculateCost(model, inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens, reasoningTokens = 0) {
   const pricing = getPricing(model);
-  return (inputTokens * pricing.input + outputTokens * pricing.output + cacheCreationTokens * pricing.cacheCreation + cacheReadTokens * pricing.cacheRead) / 1e6;
+  return (inputTokens * pricing.input + (outputTokens + reasoningTokens) * pricing.output + cacheCreationTokens * pricing.cacheCreation + cacheReadTokens * pricing.cacheRead) / 1e6;
 }
 
 // src/config.ts
@@ -204,81 +237,721 @@ function isHookInstalled() {
   }
 }
 
+// src/heartbeat.ts
+import { writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+import { existsSync as existsSync3 } from "fs";
+import { execFile } from "child_process";
+var PLIST_NAME = "dev.ccclub.sync";
+var LAUNCH_AGENTS_DIR = join3(homedir3(), "Library", "LaunchAgents");
+var PLIST_PATH = join3(LAUNCH_AGENTS_DIR, `${PLIST_NAME}.plist`);
+function getPlist() {
+  const logPath = join3(homedir3(), ".ccclub", "sync.log");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${PLIST_NAME}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>/usr/bin/env</string>
+    <string>npx</string>
+    <string>ccclub</string>
+    <string>sync</string>
+    <string>--silent</string>
+  </array>
+  <key>StartInterval</key>
+  <integer>300</integer>
+  <key>StandardOutPath</key>
+  <string>${logPath}</string>
+  <key>StandardErrorPath</key>
+  <string>${logPath}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin</string>
+  </dict>
+</dict>
+</plist>`;
+}
+async function installHeartbeat() {
+  if (process.platform !== "darwin") {
+    return false;
+  }
+  if (existsSync3(PLIST_PATH)) {
+    return true;
+  }
+  if (!existsSync3(LAUNCH_AGENTS_DIR)) {
+    await mkdir3(LAUNCH_AGENTS_DIR, { recursive: true });
+  }
+  await writeFile3(PLIST_PATH, getPlist());
+  try {
+    await new Promise((resolve2, reject) => {
+      execFile("launchctl", ["load", PLIST_PATH], (err) => err ? reject(err) : resolve2());
+    });
+  } catch {
+  }
+  return true;
+}
+function isHeartbeatInstalled() {
+  return existsSync3(PLIST_PATH);
+}
+
 // src/commands/sync.ts
-import { readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
-import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { join as join5 } from "path";
-import { homedir as homedir5 } from "os";
+import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join11 } from "path";
+import { homedir as homedir11 } from "os";
 import chalk2 from "chalk";
 import ora from "ora";
 
-// src/collector.ts
-import { readFile as readFile3 } from "fs/promises";
-import { join as join3 } from "path";
-import { homedir as homedir3 } from "os";
+// src/sources/amp.ts
+import { join as join5 } from "path";
+import { homedir as homedir5 } from "os";
+
+// src/sources/shared.ts
+import { createReadStream } from "fs";
+import { stat, readFile as readFile3 } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { resolve, join as join4 } from "path";
+import { createInterface } from "readline";
 import { glob } from "glob";
-async function collectUsageEntries() {
-  const projectsDir = join3(homedir3(), CLAUDE_PROJECTS_DIR);
-  const files = await glob("**/*.jsonl", { cwd: projectsDir, absolute: true });
-  if (files.length === 0) {
-    return { entries: [], humanTurns: [] };
+function resolveHomePath(path) {
+  if (path === "~") return homedir4();
+  if (path.startsWith("~/")) return join4(homedir4(), path.slice(2));
+  return path;
+}
+function parsePathList(value, fallback) {
+  const raw = value?.trim() ? value.split(",").map((p) => p.trim()).filter(Boolean) : fallback;
+  return Array.from(new Set(raw.map((p) => resolve(resolveHomePath(p)))));
+}
+async function existingDirectories(paths) {
+  const results = await Promise.all(
+    paths.map(async (path) => {
+      try {
+        return (await stat(path)).isDirectory() ? path : null;
+      } catch {
+        return null;
+      }
+    })
+  );
+  return results.filter((path) => path !== null);
+}
+async function globFiles(directories, pattern) {
+  const groups = await Promise.all(
+    directories.map((cwd) => glob(pattern, { cwd, absolute: true }).catch(() => []))
+  );
+  return groups.flat().sort();
+}
+async function readJsonFile(file) {
+  try {
+    return JSON.parse(await readFile3(file, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+async function readJsonlFile(file, onValue) {
+  const stream = createReadStream(file, { encoding: "utf-8" });
+  const rl = createInterface({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      await onValue(JSON.parse(trimmed), trimmed);
+    } catch {
+    }
+  }
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function asString(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function toIsoTimestamp(value) {
+  if (typeof value === "string") {
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date.toISOString();
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const ms = value < 1e10 ? value * 1e3 : value;
+    const date = new Date(ms);
+    return Number.isNaN(date.getTime()) ? null : date.toISOString();
+  }
+  return null;
+}
+
+// src/sources/amp.ts
+function getAmpDirs() {
+  const dirs = parsePathList(process.env[AMP_DATA_DIR_ENV], [join5(homedir5(), DEFAULT_AMP_DIR)]);
+  return existingDirectories(dirs);
+}
+function getAmpCacheTokens(messages, toMessageId) {
+  if (!Array.isArray(messages)) return { cacheCreationTokens: 0, cacheReadTokens: 0 };
+  for (const message of messages) {
+    const record = asRecord(message);
+    if (record?.role !== "assistant" || asNumber(record.messageId) !== toMessageId) continue;
+    const usage = asRecord(record.usage);
+    return {
+      cacheCreationTokens: asNumber(usage?.cacheCreationInputTokens),
+      cacheReadTokens: asNumber(usage?.cacheReadInputTokens)
+    };
+  }
+  return { cacheCreationTokens: 0, cacheReadTokens: 0 };
+}
+function parseAmpThread(data) {
+  const source = "amp";
+  const thread = asRecord(data);
+  const threadId = asString(thread?.id) ?? "unknown";
+  const usageLedger = asRecord(thread?.usageLedger);
+  const events = usageLedger?.events;
+  if (!Array.isArray(events)) return [];
+  const entries = [];
+  for (const rawEvent of events) {
+    const event = asRecord(rawEvent);
+    if (event == null) continue;
+    const timestamp = toIsoTimestamp(event.timestamp);
+    const model = asString(event.model);
+    const tokens = asRecord(event.tokens);
+    if (timestamp == null || model == null || tokens == null) continue;
+    const inputTokens = asNumber(tokens.input);
+    const outputTokens = asNumber(tokens.output);
+    const toMessageId = asNumber(event.toMessageId);
+    const { cacheCreationTokens, cacheReadTokens } = getAmpCacheTokens(thread?.messages, toMessageId);
+    if (inputTokens === 0 && outputTokens === 0 && cacheCreationTokens === 0 && cacheReadTokens === 0) {
+      continue;
+    }
+    const requestId = [
+      source,
+      threadId,
+      timestamp,
+      model,
+      inputTokens,
+      outputTokens,
+      cacheCreationTokens,
+      cacheReadTokens,
+      toMessageId
+    ].join(":");
+    entries.push({
+      source,
+      timestamp,
+      sessionId: threadId,
+      requestId,
+      model,
+      inputTokens,
+      outputTokens,
+      cacheCreationTokens,
+      cacheReadTokens,
+      totalTokens: inputTokens + outputTokens + cacheCreationTokens + cacheReadTokens,
+      costUSD: calculateCost(model, inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens)
+    });
   }
+  return entries;
+}
+async function collectAmpUsage() {
+  const source = "amp";
+  const dirs = await getAmpDirs();
+  const files = await globFiles(dirs.map((dir) => join5(dir, "threads")), "**/*.json");
   const entries = [];
-  const humanTurns = [];
+  const turns = [];
   const seen = /* @__PURE__ */ new Set();
-  const seenHuman = /* @__PURE__ */ new Set();
   for (const file of files) {
-    const content = await readFile3(file, "utf-8");
-    const lines = content.split("\n").filter((l) => l.trim());
-    for (const line of lines) {
-      let parsed;
-      try {
-        parsed = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      if (parsed.type === "user" && parsed.timestamp) {
-        const content2 = parsed.message?.content;
-        const isToolResult = Array.isArray(content2) && content2.length > 0 && content2.every((c) => c.type === "tool_result");
-        if (!isToolResult) {
-          const humanKey = `${parsed.sessionId || ""}:${parsed.timestamp}`;
-          if (!seenHuman.has(humanKey)) {
-            seenHuman.add(humanKey);
-            humanTurns.push(parsed.timestamp);
-          }
+    for (const entry of parseAmpThread(await readJsonFile(file))) {
+      const key = entry.requestId ?? `${source}:${entry.sessionId}:${entry.timestamp}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      entries.push(entry);
+      turns.push({ source, timestamp: entry.timestamp, key });
+    }
+  }
+  return { source, entries, turns, files: files.length, warnings: [] };
+}
+var ampCollector = {
+  source: "amp",
+  label: "Amp",
+  collect: collectAmpUsage
+};
+
+// src/sources/claude.ts
+import { join as join6, basename } from "path";
+import { homedir as homedir6 } from "os";
+function isProjectsPath(path) {
+  return basename(path) === "projects";
+}
+async function getClaudeProjectDirs() {
+  const envPaths = process.env[CLAUDE_CONFIG_DIR_ENV];
+  const basePaths = parsePathList(
+    envPaths,
+    [join6(homedir6(), CLAUDE_CONFIG_PROJECTS_DIR), join6(homedir6(), CLAUDE_PROJECTS_DIR)]
+  );
+  const candidates = envPaths?.trim() ? basePaths.flatMap((path) => isProjectsPath(path) ? [path] : [join6(path, "projects"), path]) : basePaths;
+  return existingDirectories(Array.from(new Set(candidates)));
+}
+function isClaudeUsageEntry(value) {
+  const entry = value;
+  return entry?.type === "assistant" && typeof entry.timestamp === "string" && entry.message?.usage != null;
+}
+function isClaudeHumanTurn(value) {
+  const entry = value;
+  if (entry?.type !== "user" || typeof entry.timestamp !== "string") return false;
+  const content = entry.message?.content;
+  return !(Array.isArray(content) && content.length > 0 && content.every((item) => asRecord(item)?.type === "tool_result"));
+}
+async function collectClaudeUsage() {
+  const source = "claude";
+  const projectDirs = await getClaudeProjectDirs();
+  const files = await globFiles(projectDirs, "**/*.jsonl");
+  const entries = [];
+  const turns = [];
+  const seen = /* @__PURE__ */ new Set();
+  const seenTurns = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    await readJsonlFile(file, (value) => {
+      if (isClaudeHumanTurn(value)) {
+        const timestamp2 = toIsoTimestamp(value.timestamp);
+        if (timestamp2 == null) return;
+        const sessionId2 = value.sessionId || "";
+        const key = `${source}:${sessionId2}:${timestamp2}`;
+        if (!seenTurns.has(key)) {
+          seenTurns.add(key);
+          turns.push({ source, timestamp: timestamp2, key });
         }
-        continue;
-      }
-      if (parsed.type !== "assistant" || !parsed.message?.usage) {
-        continue;
+        return;
       }
-      const usage = parsed.message.usage;
-      const requestId = parsed.requestId || "";
-      const sessionId = parsed.sessionId || "";
-      const dedupeKey = requestId ? `${sessionId}:${requestId}` : `${sessionId}:${parsed.timestamp}:${usage.input_tokens}:${usage.output_tokens}`;
-      if (seen.has(dedupeKey)) continue;
+      if (!isClaudeUsageEntry(value)) return;
+      const timestamp = toIsoTimestamp(value.timestamp);
+      if (timestamp == null) return;
+      const usage = value.message.usage;
+      const sessionId = value.sessionId || "";
+      const requestId = asString(value.requestId);
+      const dedupeKey = requestId ? `${source}:${sessionId}:${requestId}` : [
+        source,
+        sessionId,
+        timestamp,
+        usage.input_tokens,
+        usage.output_tokens,
+        usage.cache_creation_input_tokens ?? 0,
+        usage.cache_read_input_tokens ?? 0
+      ].join(":");
+      if (seen.has(dedupeKey)) return;
       seen.add(dedupeKey);
       const inputTokens = usage.input_tokens || 0;
       const outputTokens = usage.output_tokens || 0;
       const cacheCreationTokens = usage.cache_creation_input_tokens || 0;
       const cacheReadTokens = usage.cache_read_input_tokens || 0;
+      const model = value.message.model || "unknown";
+      const costUSD = value.costUSD && value.costUSD > 0 ? value.costUSD : calculateCost(model, inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens);
       entries.push({
-        timestamp: parsed.timestamp,
+        source,
+        timestamp,
         sessionId,
         requestId,
-        model: parsed.message.model || "unknown",
+        model,
         inputTokens,
         outputTokens,
         cacheCreationTokens,
         cacheReadTokens,
         totalTokens: inputTokens + outputTokens + cacheCreationTokens + cacheReadTokens,
-        costUSD: parsed.costUSD || 0
+        costUSD
       });
+    });
+  }
+  return { source, entries, turns, files: files.length, warnings: [] };
+}
+var claudeCollector = {
+  source: "claude",
+  label: "Claude",
+  collect: collectClaudeUsage
+};
+
+// src/sources/codex.ts
+import { join as join7, relative, sep } from "path";
+import { homedir as homedir7 } from "os";
+function getCodexSessionDirs() {
+  const homes = parsePathList(process.env[CODEX_HOME_ENV], [join7(homedir7(), DEFAULT_CODEX_DIR)]);
+  return existingDirectories(homes.map((home) => join7(home, "sessions")));
+}
+function normalizeRawUsage(value) {
+  const record = asRecord(value);
+  if (record == null) return null;
+  const inputTokens = asNumber(record.input_tokens);
+  const cachedInputTokens = asNumber(record.cached_input_tokens ?? record.cache_read_input_tokens);
+  const outputTokens = asNumber(record.output_tokens);
+  const reasoningTokens = asNumber(record.reasoning_output_tokens);
+  const fallbackTotal = inputTokens + outputTokens + reasoningTokens;
+  const totalTokens = asNumber(record.total_tokens) || fallbackTotal;
+  return { inputTokens, cachedInputTokens, outputTokens, reasoningTokens, totalTokens };
+}
+function subtractUsage(current, previous) {
+  return {
+    inputTokens: Math.max(current.inputTokens - (previous?.inputTokens ?? 0), 0),
+    cachedInputTokens: Math.max(current.cachedInputTokens - (previous?.cachedInputTokens ?? 0), 0),
+    outputTokens: Math.max(current.outputTokens - (previous?.outputTokens ?? 0), 0),
+    reasoningTokens: Math.max(current.reasoningTokens - (previous?.reasoningTokens ?? 0), 0),
+    totalTokens: Math.max(current.totalTokens - (previous?.totalTokens ?? 0), 0)
+  };
+}
+function extractModelFromPayload(payload) {
+  const payloadRecord = asRecord(payload);
+  const info = asRecord(payloadRecord?.info);
+  const metadata = asRecord(info?.metadata) ?? asRecord(payloadRecord?.metadata);
+  return asString(info?.model) ?? asString(info?.model_name) ?? asString(metadata?.model) ?? asString(payloadRecord?.model) ?? asString(payloadRecord?.model_name);
+}
+function sessionIdForFile(sessionDir, file) {
+  return relative(sessionDir, file).split(sep).join("/").replace(/\.jsonl$/i, "");
+}
+async function collectCodexUsage() {
+  const source = "codex";
+  const sessionDirs = await getCodexSessionDirs();
+  const files = await globFiles(sessionDirs, "**/*.jsonl");
+  const entries = [];
+  const turns = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const sessionDir of sessionDirs) {
+    const sessionFiles = files.filter((file) => file.startsWith(`${sessionDir}${sep}`));
+    for (const file of sessionFiles) {
+      const sessionId = sessionIdForFile(sessionDir, file);
+      let previousTotal = null;
+      let currentModel;
+      await readJsonlFile(file, (value) => {
+        const record = asRecord(value);
+        if (record == null) return;
+        const payload = asRecord(record.payload);
+        const type = asString(record.type);
+        if (type === "turn_context") {
+          currentModel = extractModelFromPayload(payload) ?? currentModel;
+          return;
+        }
+        if (type !== "event_msg" || payload?.type !== "token_count") return;
+        const timestamp = toIsoTimestamp(record.timestamp);
+        if (timestamp == null) return;
+        const info = asRecord(payload.info);
+        const lastUsage = normalizeRawUsage(info?.last_token_usage);
+        const totalUsage = normalizeRawUsage(info?.total_token_usage);
+        const rawUsage = lastUsage ?? (totalUsage == null ? null : subtractUsage(totalUsage, previousTotal));
+        if (totalUsage != null) previousTotal = totalUsage;
+        if (rawUsage == null) return;
+        currentModel = extractModelFromPayload(payload) ?? currentModel;
+        const model = currentModel ?? "gpt-5";
+        const cacheReadTokens = Math.min(rawUsage.cachedInputTokens, rawUsage.inputTokens);
+        const inputTokens = Math.max(rawUsage.inputTokens - cacheReadTokens, 0);
+        const totalTokens = rawUsage.totalTokens > 0 ? rawUsage.totalTokens : inputTokens + cacheReadTokens + rawUsage.outputTokens + rawUsage.reasoningTokens;
+        if (inputTokens === 0 && cacheReadTokens === 0 && rawUsage.outputTokens === 0 && rawUsage.reasoningTokens === 0) {
+          return;
+        }
+        const dedupeKey = [
+          source,
+          sessionId,
+          timestamp,
+          model,
+          inputTokens,
+          cacheReadTokens,
+          rawUsage.outputTokens,
+          rawUsage.reasoningTokens,
+          totalTokens
+        ].join(":");
+        if (seen.has(dedupeKey)) return;
+        seen.add(dedupeKey);
+        entries.push({
+          source,
+          timestamp,
+          sessionId,
+          requestId: dedupeKey,
+          model,
+          inputTokens,
+          outputTokens: rawUsage.outputTokens,
+          cacheCreationTokens: 0,
+          cacheReadTokens,
+          reasoningTokens: rawUsage.reasoningTokens,
+          totalTokens,
+          costUSD: calculateCost(model, inputTokens, rawUsage.outputTokens, 0, cacheReadTokens, rawUsage.reasoningTokens)
+        });
+        turns.push({ source, timestamp, key: dedupeKey });
+      });
+    }
+  }
+  return { source, entries, turns, files: files.length, warnings: [] };
+}
+var codexCollector = {
+  source: "codex",
+  label: "Codex",
+  collect: collectCodexUsage
+};
+
+// src/sources/opencode.ts
+import { join as join8 } from "path";
+import { homedir as homedir8 } from "os";
+function getOpenCodeDirs() {
+  const dirs = parsePathList(process.env[OPENCODE_DATA_DIR_ENV], [join8(homedir8(), DEFAULT_OPENCODE_DIR)]);
+  return existingDirectories(dirs);
+}
+function parseOpenCodeMessage(row) {
+  const source = "opencode";
+  const record = asRecord(row.data);
+  if (record == null) return null;
+  const tokens = asRecord(record.tokens);
+  const cache = asRecord(tokens?.cache);
+  const model = asString(record.modelID) ?? asString(record.model) ?? "unknown";
+  const providerID = asString(record.providerID) ?? "unknown";
+  if (model === "unknown" || tokens == null) return null;
+  const time = asRecord(record.time);
+  const timestamp = toIsoTimestamp(time?.created ?? time?.completed);
+  if (timestamp == null) return null;
+  const inputTokens = asNumber(tokens.input);
+  const outputTokens = asNumber(tokens.output);
+  const reasoningTokens = asNumber(tokens.reasoning);
+  const cacheCreationTokens = asNumber(cache?.write);
+  const cacheReadTokens = asNumber(cache?.read);
+  if (inputTokens === 0 && outputTokens === 0 && reasoningTokens === 0 && cacheCreationTokens === 0 && cacheReadTokens === 0) {
+    return null;
+  }
+  const sessionId = row.sessionId ?? asString(record.sessionID) ?? "unknown";
+  const costUSD = asNumber(record.cost) || calculateCost(
+    model,
+    inputTokens,
+    outputTokens,
+    cacheCreationTokens,
+    cacheReadTokens,
+    reasoningTokens
+  );
+  return {
+    source,
+    timestamp,
+    sessionId,
+    requestId: row.id,
+    model: providerID === "unknown" ? model : `${providerID}/${model}`,
+    inputTokens,
+    outputTokens,
+    cacheCreationTokens,
+    cacheReadTokens,
+    reasoningTokens,
+    totalTokens: inputTokens + outputTokens + cacheCreationTokens + cacheReadTokens + reasoningTokens,
+    costUSD
+  };
+}
+async function loadOpenCodeJsonRows(openCodeDirs) {
+  const messageDirs = openCodeDirs.map((dir) => join8(dir, "storage", "message"));
+  const files = await globFiles(await existingDirectories(messageDirs), "**/*.json");
+  const rows = [];
+  for (const file of files) {
+    const data = await readJsonFile(file);
+    const record = asRecord(data);
+    const id = asString(record?.id);
+    if (id == null) continue;
+    rows.push({ id, sessionId: asString(record?.sessionID), data });
+  }
+  return rows;
+}
+async function loadNodeSqlite() {
+  try {
+    return await import("sqlite");
+  } catch {
+    return null;
+  }
+}
+async function loadOpenCodeDbRows(openCodeDirs) {
+  const dbFiles = [
+    ...await globFiles(openCodeDirs, "opencode.db"),
+    ...await globFiles(openCodeDirs, "opencode-*.db")
+  ];
+  if (dbFiles.length === 0) return [];
+  const sqlite = await loadNodeSqlite();
+  if (sqlite == null) return [];
+  const rows = [];
+  for (const dbFile of Array.from(new Set(dbFiles))) {
+    let db;
+    try {
+      db = new sqlite.DatabaseSync(dbFile, { readOnly: true });
+      const result = db.prepare("SELECT id, session_id, data FROM message").all();
+      for (const raw of result) {
+        const id = asString(raw.id);
+        const dataText = asString(raw.data);
+        if (id == null || dataText == null) continue;
+        try {
+          rows.push({
+            id,
+            sessionId: asString(raw.session_id),
+            data: JSON.parse(dataText)
+          });
+        } catch {
+        }
+      }
+    } catch {
+    } finally {
+      try {
+        db?.close();
+      } catch {
+      }
     }
   }
-  entries.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
-  humanTurns.sort();
-  return { entries, humanTurns };
+  return rows;
+}
+async function collectOpenCodeUsage() {
+  const source = "opencode";
+  const openCodeDirs = await getOpenCodeDirs();
+  const [jsonRows, dbRows] = await Promise.all([
+    loadOpenCodeJsonRows(openCodeDirs),
+    loadOpenCodeDbRows(openCodeDirs)
+  ]);
+  const rows = [...dbRows, ...jsonRows];
+  const entries = [];
+  const turns = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    if (seen.has(row.id)) continue;
+    seen.add(row.id);
+    const entry = parseOpenCodeMessage(row);
+    if (entry == null) continue;
+    entries.push(entry);
+    turns.push({ source, timestamp: entry.timestamp, key: `${source}:${row.id}` });
+  }
+  return {
+    source,
+    entries,
+    turns,
+    files: jsonRows.length + dbRows.length,
+    warnings: []
+  };
+}
+var openCodeCollector = {
+  source: "opencode",
+  label: "OpenCode",
+  collect: collectOpenCodeUsage
+};
+
+// src/sources/pi.ts
+import { basename as basename2, join as join9 } from "path";
+import { homedir as homedir9 } from "os";
+function getPiSessionDirs() {
+  const dirs = parsePathList(process.env[PI_AGENT_DIR_ENV], [join9(homedir9(), DEFAULT_PI_AGENT_SESSIONS_DIR)]);
+  return existingDirectories(dirs);
+}
+function extractSessionId(file) {
+  const name = basename2(file, ".jsonl");
+  const index = name.indexOf("_");
+  return index === -1 ? name : name.slice(index + 1);
+}
+function extractProject(file) {
+  const parts = file.split(/[\\/]/g);
+  const sessionsIndex = parts.findIndex((part) => part === "sessions");
+  return sessionsIndex >= 0 ? parts[sessionsIndex + 1] ?? "unknown" : "unknown";
+}
+function normalizePiModel(model) {
+  return model == null ? "unknown" : `[pi] ${model}`;
+}
+async function collectPiUsage() {
+  const source = "pi";
+  const dirs = await getPiSessionDirs();
+  const files = await globFiles(dirs, "**/*.jsonl");
+  const entries = [];
+  const turns = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const sessionId = extractSessionId(file);
+    const project = extractProject(file);
+    await readJsonlFile(file, (value) => {
+      const record = asRecord(value);
+      const message = asRecord(record?.message);
+      const usage = asRecord(message?.usage);
+      const timestamp = toIsoTimestamp(record?.timestamp);
+      if (timestamp == null || usage == null || message?.role !== "assistant") return;
+      const inputTokens = asNumber(usage.input);
+      const outputTokens = asNumber(usage.output);
+      const cacheReadTokens = asNumber(usage.cacheRead);
+      const cacheCreationTokens = asNumber(usage.cacheWrite);
+      if (inputTokens === 0 && outputTokens === 0 && cacheReadTokens === 0 && cacheCreationTokens === 0) {
+        return;
+      }
+      const cost = asRecord(usage.cost);
+      const model = normalizePiModel(asString(message.model));
+      const totalTokens = asNumber(usage.totalTokens) || inputTokens + outputTokens + cacheCreationTokens + cacheReadTokens;
+      const key = [
+        source,
+        project,
+        sessionId,
+        timestamp,
+        model,
+        inputTokens,
+        outputTokens,
+        cacheCreationTokens,
+        cacheReadTokens,
+        totalTokens
+      ].join(":");
+      if (seen.has(key)) return;
+      seen.add(key);
+      entries.push({
+        source,
+        timestamp,
+        sessionId,
+        requestId: key,
+        model,
+        inputTokens,
+        outputTokens,
+        cacheCreationTokens,
+        cacheReadTokens,
+        totalTokens,
+        costUSD: asNumber(cost?.total)
+      });
+      turns.push({ source, timestamp, key });
+    });
+  }
+  return { source, entries, turns, files: files.length, warnings: [] };
+}
+var piCollector = {
+  source: "pi",
+  label: "pi-agent",
+  collect: collectPiUsage
+};
+
+// src/sources/index.ts
+var COLLECTORS = {
+  claude: claudeCollector,
+  codex: codexCollector,
+  opencode: openCodeCollector,
+  amp: ampCollector,
+  pi: piCollector
+};
+function isAgentSource(value) {
+  return AGENT_SOURCES.includes(value);
+}
+function parseSources(value) {
+  if (value == null || value.trim() === "") return [...AGENT_SOURCES];
+  const sources = value.split(",").map((source) => source.trim().toLowerCase()).filter((source) => isAgentSource(source));
+  return sources.length > 0 ? Array.from(new Set(sources)) : [...AGENT_SOURCES];
+}
+async function collectAllUsageEntries(options) {
+  const selectedSources = options?.sources ?? parseSources(process.env.CCCLUB_SOURCES);
+  const results = await Promise.all(
+    selectedSources.map(async (source) => {
+      const collector = COLLECTORS[source];
+      try {
+        return await collector.collect();
+      } catch (error) {
+        return {
+          source,
+          entries: [],
+          turns: [],
+          files: 0,
+          warnings: [`${AGENT_LABELS[source]}: ${error instanceof Error ? error.message : String(error)}`]
+        };
+      }
+    })
+  );
+  const entries = results.flatMap((result) => result.entries).sort(
+    (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+  );
+  const humanTurns = results.flatMap((result) => result.turns).sort(
+    (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+  );
+  const warnings = results.flatMap((result) => result.warnings);
+  return { entries, humanTurns, sources: results, warnings };
 }
 
 // src/aggregator.ts
@@ -288,9 +961,9 @@ function floorToBlock(date) {
   floored.setUTCMinutes(min - min % 30, 0, 0);
   return floored;
 }
-function aggregateToBlocks(entries, humanTurns = []) {
+function aggregateSourceToBlocks(source, entries, humanTurns) {
   if (entries.length === 0) return [];
-  const humanTurnMs = humanTurns.map((t) => new Date(t).getTime());
+  const humanTurnMs = humanTurns.map((t) => new Date(t.timestamp).getTime());
   const blocks = [];
   let blockStart = floorToBlock(new Date(entries[0].timestamp));
   let blockEnd = new Date(blockStart.getTime() + BLOCK_DURATION_MS);
@@ -315,6 +988,7 @@ function aggregateToBlocks(entries, humanTurns = []) {
     let outputTokens = 0;
     let cacheCreationTokens = 0;
     let cacheReadTokens = 0;
+    let reasoningTokens = 0;
     let totalTokens = 0;
     let costUSD = 0;
     for (const entry of currentBlock) {
@@ -322,6 +996,7 @@ function aggregateToBlocks(entries, humanTurns = []) {
       outputTokens += entry.outputTokens;
       cacheCreationTokens += entry.cacheCreationTokens;
       cacheReadTokens += entry.cacheReadTokens;
+      reasoningTokens += entry.reasoningTokens || 0;
       totalTokens += entry.totalTokens;
       models.add(entry.model);
       if (entry.costUSD > 0) {
@@ -332,17 +1007,20 @@ function aggregateToBlocks(entries, humanTurns = []) {
           entry.inputTokens,
           entry.outputTokens,
           entry.cacheCreationTokens,
-          entry.cacheReadTokens
+          entry.cacheReadTokens,
+          entry.reasoningTokens || 0
         );
       }
     }
     blocks.push({
+      source,
       blockStart: blockStart.toISOString(),
       blockEnd: blockEnd.toISOString(),
       inputTokens,
       outputTokens,
       cacheCreationTokens,
       cacheReadTokens,
+      reasoningTokens,
       totalTokens,
       costUSD: Math.round(costUSD * 1e4) / 1e4,
       models: Array.from(models),
@@ -363,6 +1041,34 @@ function aggregateToBlocks(entries, humanTurns = []) {
   flushBlock();
   return blocks;
 }
+function aggregateToBlocks(entries, humanTurns = []) {
+  if (entries.length === 0) return [];
+  const entriesBySource = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const group = entriesBySource.get(entry.source) ?? [];
+    group.push(entry);
+    entriesBySource.set(entry.source, group);
+  }
+  const turnsBySource = /* @__PURE__ */ new Map();
+  for (const turn of humanTurns) {
+    const group = turnsBySource.get(turn.source) ?? [];
+    group.push(turn);
+    turnsBySource.set(turn.source, group);
+  }
+  const blocks = [];
+  for (const [source, sourceEntries] of entriesBySource) {
+    blocks.push(
+      ...aggregateSourceToBlocks(
+        source,
+        sourceEntries.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()),
+        turnsBySource.get(source) ?? []
+      )
+    );
+  }
+  return blocks.sort(
+    (a, b) => new Date(a.blockStart).getTime() - new Date(b.blockStart).getTime() || (a.source ?? "claude").localeCompare(b.source ?? "claude")
+  );
+}
 
 // src/fetch-error.ts
 import chalk from "chalk";
@@ -394,15 +1100,15 @@ function formatFetchError(err) {
 // src/usage-limits.ts
 import { execSync as execSync2, exec } from "child_process";
 import { promisify } from "util";
-import { userInfo as userInfo2, homedir as homedir4 } from "os";
-import { join as join4 } from "path";
+import { userInfo as userInfo2, homedir as homedir10 } from "os";
+import { join as join10 } from "path";
 import { readFileSync as readFileSync2, writeFileSync } from "fs";
 var execAsync = promisify(exec);
 var debug = (...args) => {
   if (process.env.CCCLUB_DEBUG) console.error("[usage-debug]", ...args);
 };
 var CACHE_TTL_MS = 5 * 60 * 1e3;
-var CACHE_PATH = join4(homedir4(), CCCLUB_CONFIG_DIR, "usage-cache.json");
+var CACHE_PATH = join10(homedir10(), CCCLUB_CONFIG_DIR, "usage-cache.json");
 function readCache(allowStale = false) {
   try {
     const raw = readFileSync2(CACHE_PATH, "utf-8");
@@ -491,13 +1197,16 @@ async function fetchUsageLimits() {
 }
 
 // src/commands/sync.ts
-var SYNC_FORMAT_VERSION = "6";
+var SYNC_FORMAT_VERSION = "7";
 function getSyncVersionPath() {
-  return join5(homedir5(), CCCLUB_CONFIG_DIR, "sync-version");
+  return join11(homedir11(), CCCLUB_CONFIG_DIR, "sync-version");
+}
+function getLastSyncBySourcePath() {
+  return join11(homedir11(), CCCLUB_CONFIG_DIR, "last-sync-sources.json");
 }
 function needsFullSync() {
   const path = getSyncVersionPath();
-  if (!existsSync3(path)) return true;
+  if (!existsSync4(path)) return true;
   try {
     const stored = readFileSync3(path, "utf-8").trim();
     return stored !== SYNC_FORMAT_VERSION;
@@ -509,7 +1218,7 @@ var THROTTLE_MS = 5 * 60 * 1e3;
 async function syncCommand(options) {
   const timePath = getLastSyncTimePath();
   if (options.silent && !options.full) {
-    if (existsSync3(timePath)) {
+    if (existsSync4(timePath)) {
       try {
         const ts = parseInt(readFileSync3(timePath, "utf-8").trim(), 10);
         if (Date.now() - ts < THROTTLE_MS) return;
@@ -542,31 +1251,47 @@ async function doSync(firstSync = false, silent = false) {
   } : console.log;
   const spinner = silent ? null : ora("Collecting usage data...").start();
   try {
-    const [{ entries, humanTurns }, usageSnapshot] = await Promise.all([
-      collectUsageEntries(),
+    const [{ entries, humanTurns, sources, warnings }, usageSnapshot] = await Promise.all([
+      collectAllUsageEntries(),
       fetchUsageLimits().catch(() => null)
     ]);
-    if (spinner) spinner.text = `Found ${entries.length} entries`;
+    const activeSources = sources.filter((source) => source.entries.length > 0).map((source) => AGENT_LABELS[source.source]);
+    if (spinner) spinner.text = `Found ${entries.length} entries${activeSources.length > 0 ? ` from ${activeSources.join(", ")}` : ""}`;
     if (entries.length === 0) {
-      if (spinner) spinner.warn("No usage data found in ~/.claude/projects/");
+      if (spinner) spinner.warn("No usage data found for supported coding agents");
+      if (!silent && warnings.length > 0) {
+        for (const warning of warnings) log(chalk2.dim(`  ${warning}`));
+      }
       return;
     }
     const allBlocks = aggregateToBlocks(entries, humanTurns);
     const lastSyncPath = getLastSyncPath();
     let lastSync = null;
-    if (existsSync3(lastSyncPath)) {
+    if (existsSync4(lastSyncPath)) {
       lastSync = (await readFile4(lastSyncPath, "utf-8")).trim() || null;
     }
+    let lastSyncBySource = {};
+    if (existsSync4(getLastSyncBySourcePath())) {
+      try {
+        lastSyncBySource = JSON.parse(await readFile4(getLastSyncBySourcePath(), "utf-8"));
+      } catch {
+        lastSyncBySource = {};
+      }
+    }
     let blocksToSync;
     if (lastSync && !firstSync) {
-      const lastSyncTime = new Date(lastSync).getTime();
-      blocksToSync = allBlocks.filter((b) => new Date(b.blockStart).getTime() >= lastSyncTime);
+      blocksToSync = allBlocks.filter((b) => {
+        const source = b.source ?? "claude";
+        const sourceLastSync = lastSyncBySource[source] ?? lastSync;
+        return new Date(b.blockStart).getTime() >= new Date(sourceLastSync).getTime();
+      });
     } else {
       blocksToSync = allBlocks;
     }
     if (blocksToSync.length === 0) {
       if (spinner) spinner.succeed("Already up to date");
-      await writeFile3(getSyncVersionPath(), SYNC_FORMAT_VERSION);
+      await writeFile4(getLastSyncBySourcePath(), JSON.stringify(getLatestBlockStartBySource(allBlocks), null, 2));
+      await writeFile4(getSyncVersionPath(), SYNC_FORMAT_VERSION);
       if (usageSnapshot) {
         fetch(`${config.apiUrl}/api/usage`, {
           method: "POST",
@@ -598,27 +1323,42 @@ async function doSync(firstSync = false, silent = false) {
     }
     const data = await res.json();
     const latest = blocksToSync[blocksToSync.length - 1];
-    await writeFile3(lastSyncPath, latest.blockStart);
-    await writeFile3(getSyncVersionPath(), SYNC_FORMAT_VERSION);
-    await writeFile3(getLastSyncTimePath(), String(Date.now()));
+    await writeFile4(lastSyncPath, latest.blockStart);
+    await writeFile4(getLastSyncBySourcePath(), JSON.stringify(getLatestBlockStartBySource(allBlocks), null, 2));
+    await writeFile4(getSyncVersionPath(), SYNC_FORMAT_VERSION);
+    await writeFile4(getLastSyncTimePath(), String(Date.now()));
     const totalTokens = blocksToSync.reduce((s, b) => s + b.totalTokens, 0);
     const totalCost = blocksToSync.reduce((s, b) => s + b.costUSD, 0);
     if (spinner) {
       spinner.succeed(`Synced ${data.synced} blocks`);
       log(chalk2.dim(`  Tokens: ${totalTokens.toLocaleString()}  Cost: $${totalCost.toFixed(4)}`));
+      if (warnings.length > 0) {
+        for (const warning of warnings) log(chalk2.dim(`  ${warning}`));
+      }
     }
   } catch (err) {
     if (spinner) spinner.fail(`Sync error: ${formatFetchError(err)}`);
     if (silent) throw err;
   }
 }
+function getLatestBlockStartBySource(blocks) {
+  const latest = {};
+  for (const block of blocks) {
+    const source = block.source ?? "claude";
+    if (!AGENT_SOURCES.includes(source)) continue;
+    if (latest[source] == null || block.blockStart > latest[source]) {
+      latest[source] = block.blockStart;
+    }
+  }
+  return latest;
+}
 
 // src/global-install.ts
 import { exec as exec2 } from "child_process";
 import chalk3 from "chalk";
 function run(cmd) {
-  return new Promise((resolve) => {
-    exec2(cmd, (err, stdout5) => resolve(err ? "" : stdout5.trim()));
+  return new Promise((resolve2) => {
+    exec2(cmd, (err, stdout5) => resolve2(err ? "" : stdout5.trim()));
   });
 }
 async function ensureGlobalInstall() {
@@ -645,10 +1385,14 @@ async function initCommand() {
       const hookOk = await installHook();
       if (hookOk) console.log(chalk4.green("  Auto-sync hook installed!"));
     }
+    if (!isHeartbeatInstalled()) {
+      const heartbeatOk = await installHeartbeat();
+      if (heartbeatOk) console.log(chalk4.green("  Background sync installed!"));
+    }
     console.log(chalk4.dim('\n  Run "ccclub" to see the leaderboard'));
     return;
   }
-  const rl = createInterface({ input: stdin, output: stdout });
+  const rl = createInterface2({ input: stdin, output: stdout });
   try {
     const defaultName = getDefaultDisplayName();
     const prompt = defaultName ? chalk4.bold(`Your display name (${defaultName}): `) : chalk4.bold("Your display name: ");
@@ -686,11 +1430,17 @@ async function initCommand() {
       displayName: displayName.trim(),
       groups: [data.groupCode]
     });
-    const hookOk = await installHook();
+    const [hookOk, heartbeatOk] = await Promise.all([
+      installHook(),
+      installHeartbeat()
+    ]);
     spinner.succeed("ccclub initialized!");
     if (!hookOk) {
       console.log(chalk4.dim('  Tip: run "ccclub hook" to set up auto-sync'));
     }
+    if (!heartbeatOk) {
+      console.log(chalk4.dim('  Tip: run "ccclub sync" manually to refresh non-Claude agent usage'));
+    }
     console.log("");
     console.log(chalk4.bold("  Invite friends to compete:"));
     console.log("");
@@ -712,7 +1462,7 @@ function printQuickStart() {
 }
 
 // src/commands/join.ts
-import { createInterface as createInterface2 } from "readline/promises";
+import { createInterface as createInterface3 } from "readline/promises";
 import { stdin as stdin2, stdout as stdout2 } from "process";
 import chalk5 from "chalk";
 import ora3 from "ora";
@@ -725,7 +1475,7 @@ async function joinCommand(inviteCode) {
     token = config.token;
     displayName = config.displayName;
   } else {
-    const rl = createInterface2({ input: stdin2, output: stdout2 });
+    const rl = createInterface3({ input: stdin2, output: stdout2 });
     try {
       const defaultName = getDefaultDisplayName();
       const prompt = defaultName ? chalk5.bold(`Your display name (${defaultName}): `) : chalk5.bold("Your display name: ");
@@ -791,16 +1541,16 @@ import Table from "cli-table3";
 import ora4 from "ora";
 
 // src/update-check.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync4 } from "fs";
-import { join as join6 } from "path";
-import { homedir as homedir6 } from "os";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync5 } from "fs";
+import { join as join12 } from "path";
+import { homedir as homedir12 } from "os";
 var CHECK_INTERVAL_MS = 12 * 60 * 60 * 1e3;
-var CHECK_FILE = join6(homedir6(), CCCLUB_CONFIG_DIR, "last-update-check");
+var CHECK_FILE = join12(homedir12(), CCCLUB_CONFIG_DIR, "last-update-check");
 var pendingCheck = null;
 function startUpdateCheck(currentVersion) {
   if (process.argv.includes("--silent") || process.argv.includes("-s")) return;
   try {
-    if (existsSync4(CHECK_FILE)) {
+    if (existsSync5(CHECK_FILE)) {
       const ts = parseInt(readFileSync4(CHECK_FILE, "utf-8").trim(), 10);
       if (Date.now() - ts < CHECK_INTERVAL_MS) return;
     }
@@ -836,6 +1586,7 @@ var ACTIVE_THRESHOLD_MS = 15 * 60 * 1e3;
 async function rankCommand(options) {
   const config = await requireConfig();
   if (!isHookInstalled()) await installHook();
+  if (!isHeartbeatInstalled()) await installHeartbeat();
   if (needsFullSync()) {
     await doSync(true, true);
   }
@@ -932,7 +1683,7 @@ async function rankCommand(options) {
       if (activityData) renderActivity(activityData, range);
       if (i < groupResults.length - 1) console.log("");
     }
-    console.log(chalk6.dim("\n  Tokens = input + output ") + chalk6.yellow("(cache excluded)") + chalk6.dim(". Use ") + chalk6.white("--cache") + chalk6.dim(" to include cache tokens."));
+    console.log(chalk6.dim("\n  Tokens = input + output + reasoning ") + chalk6.yellow("(cache excluded)") + chalk6.dim(". Use ") + chalk6.white("--cache") + chalk6.dim(" to include cache tokens."));
     const update = await getUpdateResult();
     if (update) {
       console.log(chalk6.yellow("\n  Update available") + chalk6.dim(`: ${update.current} \u2192 ${update.latest}  Run `) + chalk6.cyan("npm i -g ccclub@latest"));
@@ -978,14 +1729,21 @@ function printGroup(data, code, period, config, showCache = false, showAll = fal
   const hiddenCount = data.rankings.length - activeRankings.length;
   const hasPlan = activeRankings.some((r) => r.plan);
   const hasUsage = activeRankings.some((r) => r.usageSnapshot);
+  const hasAgents = activeRankings.some(
+    (r) => r.agents && r.agents.length > 0 && !(r.agents.length === 1 && r.agents[0] === "claude")
+  );
   const head = ["#", "Name", "Cost", "Tokens"];
   const hasActive = activeRankings.some((r) => r.lastSync && now - new Date(r.lastSync).getTime() < ACTIVE_THRESHOLD_MS);
   const widths = [5, hasActive ? 30 : 20, 12, 10];
+  if (hasAgents) {
+    head.splice(2, 0, "Agents");
+    widths.splice(2, 0, 16);
+  }
   if (hasPlan) {
     head.push("Monthly ROI");
     widths.push(15);
   }
-  head.push("Chats", "$/Chat");
+  head.push("Turns", "$/Turn");
   widths.push(8, 9);
   if (hasUsage) {
     head.push("Usage 7d");
@@ -998,7 +1756,7 @@ function printGroup(data, code, period, config, showCache = false, showAll = fal
   });
   for (const entry of activeRankings) {
     const isMe = entry.userId === config.userId;
-    const tokens = showCache ? entry.totalTokens : entry.inputTokens + entry.outputTokens;
+    const tokens = showCache ? entry.totalTokens : entry.inputTokens + entry.outputTokens + (entry.reasoningTokens || 0);
     const marker = isMe ? chalk6.green("\u2192") : " ";
     const isActive = entry.lastSync && now - new Date(entry.lastSync).getTime() < ACTIVE_THRESHOLD_MS;
     const id = (s) => s;
@@ -1007,10 +1765,12 @@ function printGroup(data, code, period, config, showCache = false, showAll = fal
     const displayName = isActive ? `${entry.displayName} ${chalk6.green("(active)")}` : entry.displayName;
     const row = [
       `${marker}${c(String(entry.rank))}`,
-      nameC(displayName),
-      c(`$${entry.costUSD.toFixed(2)}`),
-      c(formatTokens(tokens))
+      nameC(displayName)
     ];
+    if (hasAgents) {
+      row.push(c(formatAgents(entry.agents)));
+    }
+    row.push(c(`$${entry.costUSD.toFixed(2)}`), c(formatTokens(tokens)));
     if (hasPlan) {
       if (entry.plan && entry.plan !== "api") {
         const price = PLAN_PRICES[entry.plan];
@@ -1052,6 +1812,10 @@ function printGroup(data, code, period, config, showCache = false, showAll = fal
     }
   }
 }
+function formatAgents(agents) {
+  if (!agents || agents.length === 0) return "\u2014";
+  return agents.map((agent) => AGENT_LABELS[agent] ?? agent).join(", ");
+}
 var SPARK_CHARS = "\u2581\u2582\u2583\u2584\u2585\u2586\u2587";
 function renderActivity(data, range) {
   const active = data.series.filter((s) => s.blocks.length > 0);
@@ -1219,38 +1983,49 @@ async function showDataCommand() {
   console.log(chalk8.bold("\n  What ccclub uploads:\n"));
   console.log(chalk8.dim("  Only aggregated 30-minute block summaries. No conversation content,"));
   console.log(chalk8.dim("  no file paths, no project names, no session details.\n"));
-  const { entries, humanTurns } = await collectUsageEntries();
+  const { entries, humanTurns, sources, warnings } = await collectAllUsageEntries();
   const blocks = aggregateToBlocks(entries, humanTurns);
   if (blocks.length === 0) {
-    console.log(chalk8.yellow("  No usage data found in ~/.claude/projects/"));
+    console.log(chalk8.yellow("  No usage data found for supported coding agents."));
+    for (const warning of warnings) console.log(chalk8.dim(`  ${warning}`));
     return;
   }
   console.log(chalk8.dim(`  Total entries found: ${entries.length}`));
   console.log(chalk8.dim(`  Aggregated into: ${blocks.length} blocks
 `));
+  console.log(chalk8.bold("  Sources:\n"));
+  for (const source of sources.filter((s) => s.entries.length > 0)) {
+    console.log(chalk8.dim(`    ${AGENT_LABELS[source.source]}: ${source.entries.length.toLocaleString()} entries from ${source.files.toLocaleString()} files/records`));
+  }
+  console.log("");
   const recent = blocks.slice(-5);
   console.log(chalk8.bold("  Last 5 blocks (this is exactly what gets uploaded):\n"));
   for (const block of recent) {
-    console.log(chalk8.cyan(`  ${block.blockStart.slice(0, 16)} \u2192 ${block.blockEnd.slice(11, 16)}`));
+    console.log(chalk8.cyan(`  ${AGENT_LABELS[block.source ?? "claude"]} \xB7 ${block.blockStart.slice(0, 16)} \u2192 ${block.blockEnd.slice(11, 16)}`));
     console.log(chalk8.dim(`    input: ${block.inputTokens.toLocaleString()}  output: ${block.outputTokens.toLocaleString()}  cache_create: ${block.cacheCreationTokens.toLocaleString()}  cache_read: ${block.cacheReadTokens.toLocaleString()}`));
-    console.log(chalk8.dim(`    cost: $${block.costUSD.toFixed(4)}  calls: ${block.entryCount}  models: ${block.models.join(", ")}`));
+    if (block.reasoningTokens) {
+      console.log(chalk8.dim(`    reasoning: ${block.reasoningTokens.toLocaleString()}`));
+    }
+    console.log(chalk8.dim(`    cost: $${block.costUSD.toFixed(4)}  calls: ${block.entryCount}  turns: ${block.chatCount || 0}  models: ${block.models.join(", ")}`));
   }
   const totalInput = blocks.reduce((s, b) => s + b.inputTokens, 0);
   const totalOutput = blocks.reduce((s, b) => s + b.outputTokens, 0);
+  const totalReasoning = blocks.reduce((s, b) => s + (b.reasoningTokens || 0), 0);
+  const totalCache = blocks.reduce((s, b) => s + b.cacheCreationTokens + b.cacheReadTokens, 0);
   const totalCost = blocks.reduce((s, b) => s + b.costUSD, 0);
   console.log(chalk8.bold(`
-  All-time total: ${(totalInput + totalOutput).toLocaleString()} tokens \xB7 $${totalCost.toFixed(2)}`));
-  console.log(chalk8.dim(`    input: ${totalInput.toLocaleString()}  output: ${totalOutput.toLocaleString()}`));
+  All-time total: ${(totalInput + totalOutput + totalReasoning).toLocaleString()} non-cache tokens \xB7 $${totalCost.toFixed(2)}`));
+  console.log(chalk8.dim(`    input: ${totalInput.toLocaleString()}  output: ${totalOutput.toLocaleString()}  reasoning: ${totalReasoning.toLocaleString()}  cache: ${totalCache.toLocaleString()}`));
 }
 
 // src/commands/group.ts
-import { createInterface as createInterface3 } from "readline/promises";
+import { createInterface as createInterface4 } from "readline/promises";
 import { stdin as stdin3, stdout as stdout3 } from "process";
 import chalk9 from "chalk";
 import ora6 from "ora";
 async function createGroupCommand() {
   const config = await requireConfig();
-  const rl = createInterface3({ input: stdin3, output: stdout3 });
+  const rl = createInterface4({ input: stdin3, output: stdout3 });
   try {
     const name = await rl.question(chalk9.bold("Group name: "));
     if (!name.trim()) {
@@ -1294,7 +2069,7 @@ async function createGroupCommand() {
 }
 
 // src/commands/leave.ts
-import { createInterface as createInterface4 } from "readline/promises";
+import { createInterface as createInterface5 } from "readline/promises";
 import { stdin as stdin4, stdout as stdout4 } from "process";
 import chalk10 from "chalk";
 import ora7 from "ora";
@@ -1318,7 +2093,7 @@ async function leaveCommand(code) {
     for (let i = 0; i < config.groups.length; i++) {
       console.log(`    ${i + 1}. ${config.groups[i]}`);
     }
-    const rl2 = createInterface4({ input: stdin4, output: stdout4 });
+    const rl2 = createInterface5({ input: stdin4, output: stdout4 });
     try {
       const input = await rl2.question(chalk10.bold("\n  Leave which group? (number): "));
       const idx = parseInt(input.trim(), 10) - 1;
@@ -1331,7 +2106,7 @@ async function leaveCommand(code) {
       rl2.close();
     }
   }
-  const rl = createInterface4({ input: stdin4, output: stdout4 });
+  const rl = createInterface5({ input: stdin4, output: stdout4 });
   try {
     const answer = await rl.question(chalk10.bold(`  Leave group ${targetCode}? [y/N] `));
     if (answer.trim().toLowerCase() !== "y") {
@@ -1385,10 +2160,10 @@ async function hookCommand() {
 }
 
 // src/index.ts
-var VERSION = "0.3.2";
+var VERSION = "0.3.3";
 startUpdateCheck(VERSION);
 var program = new Command();
-program.name("ccclub").description("Claude Code leaderboard among friends").version(VERSION, "-v, -V, --version");
+program.name("ccclub").description("Coding agent usage leaderboard among friends").version(VERSION, "-v, -V, --version");
 program.command("rank", { isDefault: true, hidden: true }).description("Show leaderboard").option("-d, --days [days]", "Time window: 1 | 7 | 30 | all (default: today)").addOption(new Option("-p, --period [period]").hideHelp()).option("-g, --group <code>", "Group invite code").option("--global", "Show global public ranking").option("--cache", "Include cache tokens in count").option("--all", "Show all members including those with no activity").action(rankCommand);
 program.command("init").description("Create a group and get started (first-time setup)").action(initCommand);
 program.command("join").description("Join a group with a 6-letter invite code").argument("[invite-code]", "6-character invite code").action((code) => {

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "ccclub",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "type": "module",
-  "description": "Claude Code leaderboard among friends",
+  "description": "Coding agent usage leaderboard among friends",
   "bin": {
     "ccclub": "dist/index.js"
   },