@vibescore/tracker 0.0.7 → 0.0.8

package/README.md

@@ -13,7 +13,11 @@ _Real-time AI Analytics for Codex CLI_
 
 [**English**](README.md) • [**中文说明**](README.zh-CN.md)
 
-[**Documentation**](docs/) • [**Dashboard**](dashboard/) • [**Backend API**](BACKEND_API.md)
+[**Documentation**](docs/) • [**Dashboard**](dashboard/) • [**Backend API**](BACKEND_API.md) • [**Dashboard API**](docs/dashboard/api.md)
+
+<br/>
+
+<img src="docs/screenshots/dashboard.png" width="900" alt="VibeScore Dashboard Preview"/>
 
 </div>
 
@@ -36,39 +40,51 @@ We believe your code and thoughts are your own. VibeScore is built with strict p
 
 ## 🚀 Key Features
 
-- 📡 **Live Sniffer**: Real-time interception of Codex CLI pipes using low-level hooks to capture every completion event.
+- 📡 **Live Sniffer & Auto-Sync**: Real-time interception of Codex CLI pipes with **automatic background synchronization**. Once initialized, your tokens are tracked and synced without any manual commands.
 - 🧭 **Multi-source Ingestion**: Supports Codex CLI and Every Code (tagged as `source=every-code`) without modifying Every Code.
 - 📊 **Matrix Dashboard**: A high-performance React + Vite dashboard featuring heatmaps, trend charts, and live logs.
 - ⚡ **AI Analytics**: Deep analysis of Input/Output tokens, with dedicated tracking for Cached and Reasoning components.
 - 🔒 **Identity Core**: Robust authentication and permission management to secure your development data.
 
+### 🌌 Visual Preview
+
+<img src="docs/screenshots/landing.png" width="900" alt="VibeScore Landing Preview"/>
+
 ## 🛠️ Quick Start
 
 ### Installation
 
-Initialize your environment with a single command:
+Initialize your environment once and forget it. VibeScore handles all synchronization in the background automatically.
 
 ```bash
 npx --yes @vibescore/tracker init
 ```
 
-Note: If `~/.code/config.toml` exists (or `CODE_HOME`), `init` also configures Every Code `notify` automatically; it will not create the file when missing.
+Note: If `~/.code/config.toml` exists (or `CODE_HOME`), `init` also configures Every Code `notify` automatically. No further user intervention is required for data sync.
 
 ### Sync & Status
 
+````bash
+While sync happens automatically, you can manually trigger a synchronization or check status anytime:
+
 ```bash
-# Sync latest local session data
+# Manually sync latest local session data (Optional)
 npx --yes @vibescore/tracker sync
 
 # Check current link status
 npx --yes @vibescore/tracker status
-```
+````
 
 ### Sources
 
 - Codex CLI logs: `~/.codex/sessions/**/rollout-*.jsonl` (override with `CODEX_HOME`)
 - Every Code logs: `~/.code/sessions/**/rollout-*.jsonl` (override with `CODE_HOME`)
 
+## 🔧 Environment Variables
+
+- `VIBESCORE_HTTP_TIMEOUT_MS`: CLI HTTP timeout in ms (default `20000`, `0` disables, clamped to `1000..120000`).
+- `VITE_VIBESCORE_HTTP_TIMEOUT_MS`: Dashboard request timeout in ms (default `15000`, `0` disables, clamped to `1000..30000`).
+
 ## 🧰 Troubleshooting
 
 ### Streak shows 0 days while totals look correct

package/README.zh-CN.md

@@ -13,7 +13,11 @@ _Codex CLI 实时 AI 分析工具_
 
 [**English**](README.md) • [**中文说明**](README.zh-CN.md)
 
-[**文档**](docs/) • [**控制台**](dashboard/) • [**后端接口**](BACKEND_API.md)
+[**文档**](docs/) • [**控制台**](dashboard/) • [**后端接口**](BACKEND_API.md) • [**Dashboard API**](docs/dashboard/api.md)
+
+<br/>
+
+<img src="docs/screenshots/dashboard.png" width="900" alt="VibeScore 控制台预览"/>
 
 </div>
 
@@ -36,39 +40,51 @@ _Codex CLI 实时 AI 分析工具_
 
 ## 🚀 核心功能
 
-- 📡 **Live Sniffer (实时嗅探)**: 实时监听 Codex CLI 管道，通过底层 Hook 捕获每一次补全事件。
+- 📡 **自动嗅探与同步 (Auto-Sync)**: 实时监听 Codex CLI 管道并具备**全自动后台同步**功能。初始化后，你的 Token 产出将自动追踪并同步，无需手动执行脚本。
 - 🧭 **多来源采集**：支持 Codex CLI 与 Every Code（标记为 `source=every-code`），无需修改 Every Code 客户端。
 - 📊 **Matrix Dashboard (矩阵控制台)**: 基于 React + Vite 的高性能仪表盘，具备热力图、趋势图与实时日志。
 - ⚡ **AI Analytics (AI 分析)**: 深度分析 Input/Output Token，支持缓存 (Cached) 与推理 (Reasoning) 部分的分离监控。
 - 🔒 **Identity Core (身份核心)**: 完备的身份验证与权限管理，保护你的开发数据资产。
 
+### 🌌 视觉预览
+
+<img src="docs/screenshots/landing.png" width="900" alt="VibeScore 落地页预览"/>
+
 ## 🛠️ 快速开始
 
 ### 安装
 
-只需一行命令，即可初始化环境：
+只需一次初始化，即可变身为“自动驾驶”模式。VibeScore 会在后台处理所有数据同步，你只需专注开发。
 
 ```bash
 npx --yes @vibescore/tracker init
 ```
 
-说明：若存在 `~/.code/config.toml`（或 `CODE_HOME`），`init` 会自动配置 Every Code 的 `notify`；缺失时不会创建该文件。
+说明：若存在 `~/.code/config.toml`（或 `CODE_HOME`），`init` 会自动配置 Every Code 的 `notify`。配置完成后，数据同步完全自动化，无需后续人工干预。
 
 ### 同步与状态查看
 
+````bash
+虽然同步是自动完成的，但你仍可以随时手动触发同步或查看状态：
+
 ```bash
-# 同步最新的本地会话数据
+# 手动同步最新的本地会话数据 (可选)
 npx --yes @vibescore/tracker sync
 
 # 查看当前连接状态
 npx --yes @vibescore/tracker status
-```
+````
 
 ### 日志来源
 
 - Codex CLI 日志：`~/.codex/sessions/**/rollout-*.jsonl`（可用 `CODEX_HOME` 覆盖）
 - Every Code 日志：`~/.code/sessions/**/rollout-*.jsonl`（可用 `CODE_HOME` 覆盖）
 
+## 🔧 环境变量
+
+- `VIBESCORE_HTTP_TIMEOUT_MS`：CLI 请求超时（毫秒，默认 `20000`，`0` 表示关闭，范围 `1000..120000`）。
+- `VITE_VIBESCORE_HTTP_TIMEOUT_MS`：Dashboard 请求超时（毫秒，默认 `15000`，`0` 表示关闭，范围 `1000..30000`）。
+
 ## 🧰 常见问题
 
 ### Streak 显示 0 天但总量正常

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibescore/tracker",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "Codex CLI token usage tracker (macOS-first, notify-driven).",
   "license": "MIT",
   "publishConfig": {

package/src/commands/init.js

@@ -1,6 +1,8 @@
 const os = require('node:os');
 const path = require('node:path');
 const fs = require('node:fs/promises');
+const fssync = require('node:fs');
+const cp = require('node:child_process');
 
 const { ensureDir, writeFileAtomic, readJson, writeJson, chmod600IfPossible } = require('../lib/fs');
 const { prompt, promptHidden } = require('../lib/prompt');
@@ -10,9 +12,9 @@ const {
   upsertEveryCodeNotify,
   loadEveryCodeNotifyOriginal
 } = require('../lib/codex-config');
+const { upsertClaudeHook, buildClaudeHookCommand } = require('../lib/claude-config');
 const { beginBrowserAuth } = require('../lib/browser-auth');
 const { issueDeviceTokenWithPassword, issueDeviceTokenWithAccessToken } = require('../lib/insforge');
-const { cmdSync } = require('./sync');
 
 async function cmdInit(argv) {
   const opts = parseArgs(argv);
@@ -113,6 +115,18 @@ async function cmdInit(argv) {
     codeChained = await loadEveryCodeNotifyOriginal(codeNotifyOriginalPath);
   }
 
+  const claudeDir = path.join(home, '.claude');
+  const claudeSettingsPath = path.join(claudeDir, 'settings.json');
+  const claudeDirExists = await isDir(claudeDir);
+  let claudeResult = null;
+  if (claudeDirExists) {
+    const claudeHookCommand = buildClaudeHookCommand(notifyPath);
+    claudeResult = await upsertClaudeHook({
+      settingsPath: claudeSettingsPath,
+      hookCommand: claudeHookCommand
+    });
+  }
+
   process.stdout.write(
     [
       'Installed:',
@@ -132,16 +146,21 @@ async function cmdInit(argv) {
           ? '- Every Code notify: chained (original preserved)'
           : '- Every Code notify: no original'
         : null,
+      claudeDirExists
+        ? claudeResult?.changed
+          ? `- Claude hooks: updated (${claudeSettingsPath})`
+          : `- Claude hooks: already set (${claudeSettingsPath})`
+        : '- Claude hooks: skipped (~/.claude not found)',
       deviceToken ? `- Device token: stored (${maskSecret(deviceToken)})` : '- Device token: not configured (set VIBESCORE_DEVICE_TOKEN and re-run init)',
       ''
     ].join('\n')
   );
 
   try {
-    await cmdSync([]);
+    spawnInitSync({ trackerBinPath, packageName: '@vibescore/tracker' });
   } catch (err) {
     const msg = err && err.message ? err.message : 'unknown error';
-    process.stderr.write(`Initial sync failed: ${msg}\n`);
+    process.stderr.write(`Initial sync spawn failed: ${msg}\n`);
   }
 }
 
@@ -241,15 +260,17 @@ try {
   }
 } catch (_) {}
 
-// Chain the original notify if present.
+// Chain the original notify if present (Codex/Every Code only).
 try {
-  const originalPath = source === 'every-code' ? codeOriginalPath : codexOriginalPath;
-  const original = JSON.parse(fs.readFileSync(originalPath, 'utf8'));
-  const cmd = Array.isArray(original?.notify) ? original.notify : null;
-  if (cmd && cmd.length > 0 && !isSelfNotify(cmd)) {
-    const args = cmd.slice(1);
-    if (payloadArgs.length > 0) args.push(...payloadArgs);
-    spawnDetached([cmd[0], ...args]);
+  const originalPath = source === 'every-code' ? codeOriginalPath : source === 'claude' ? null : codexOriginalPath;
+  if (originalPath) {
+    const original = JSON.parse(fs.readFileSync(originalPath, 'utf8'));
+    const cmd = Array.isArray(original?.notify) ? original.notify : null;
+    if (cmd && cmd.length > 0 && !isSelfNotify(cmd)) {
+      const args = cmd.slice(1);
+      if (payloadArgs.length > 0) args.push(...payloadArgs);
+      spawnDetached([cmd[0], ...args]);
+    }
   }
 } catch (_) {}
 
@@ -324,6 +345,15 @@ async function isFile(p) {
   }
 }
 
+async function isDir(p) {
+  try {
+    const st = await fs.stat(p);
+    return st.isDirectory();
+  } catch (_e) {
+    return false;
+  }
+}
+
 async function installLocalTrackerApp({ appDir }) {
   // Copy the current package's runtime (bin + src) into ~/.vibescore so notify can run sync without npx.
   const packageRoot = path.resolve(__dirname, '../..');
@@ -345,6 +375,21 @@ async function installLocalTrackerApp({ appDir }) {
   await copyRuntimeDependencies({ from: nodeModulesFrom, to: nodeModulesTo });
 }
 
+function spawnInitSync({ trackerBinPath, packageName }) {
+  const fallbackPkg = packageName || '@vibescore/tracker';
+  const argv = ['sync'];
+  const hasLocalRuntime = typeof trackerBinPath === 'string' && fssync.existsSync(trackerBinPath);
+  const cmd = hasLocalRuntime
+    ? [process.execPath, trackerBinPath, ...argv]
+    : ['npx', '--yes', fallbackPkg, ...argv];
+  const child = cp.spawn(cmd[0], cmd.slice(1), {
+    detached: true,
+    stdio: 'ignore',
+    env: process.env
+  });
+  child.unref();
+}
+
 async function copyRuntimeDependencies({ from, to }) {
   try {
     const st = await fs.stat(from);

package/src/commands/status.js

@@ -4,6 +4,7 @@ const fs = require('node:fs/promises');
 
 const { readJson } = require('../lib/fs');
 const { readCodexNotify, readEveryCodeNotify } = require('../lib/codex-config');
+const { isClaudeHookConfigured, buildClaudeHookCommand } = require('../lib/claude-config');
 const { normalizeState: normalizeUploadState } = require('../lib/upload-throttle');
 const { collectTrackerDiagnostics } = require('../lib/diagnostics');
 
@@ -29,6 +30,8 @@ async function cmdStatus(argv = []) {
   const codexConfigPath = path.join(codexHome, 'config.toml');
   const codeHome = process.env.CODE_HOME || path.join(home, '.code');
   const codeConfigPath = path.join(codeHome, 'config.toml');
+  const claudeSettingsPath = path.join(home, '.claude', 'settings.json');
+  const claudeHookCommand = buildClaudeHookCommand(path.join(home, '.vibescore', 'bin', 'notify.cjs'));
 
   const config = await readJson(configPath);
   const cursors = await readJson(cursorsPath);
@@ -46,6 +49,10 @@ async function cmdStatus(argv = []) {
   const notifyConfigured = Array.isArray(codexNotify) && codexNotify.length > 0;
   const everyCodeNotify = await readEveryCodeNotify(codeConfigPath);
   const everyCodeConfigured = Array.isArray(everyCodeNotify) && everyCodeNotify.length > 0;
+  const claudeHookConfigured = await isClaudeHookConfigured({
+    settingsPath: claudeSettingsPath,
+    hookCommand: claudeHookCommand
+  });
 
   const lastUpload = uploadThrottle.lastSuccessMs
     ? parseEpochMsToIso(uploadThrottle.lastSuccessMs)
@@ -80,6 +87,7 @@ async function cmdStatus(argv = []) {
       autoRetryLine,
       `- Codex notify: ${notifyConfigured ? JSON.stringify(codexNotify) : 'unset'}`,
       `- Every Code notify: ${everyCodeConfigured ? JSON.stringify(everyCodeNotify) : 'unset'}`,
+      `- Claude hooks: ${claudeHookConfigured ? 'set' : 'unset'}`,
       ''
     ]
       .filter(Boolean)

package/src/commands/sync.js

@@ -4,7 +4,7 @@ const fs = require('node:fs/promises');
 const cp = require('node:child_process');
 
 const { ensureDir, readJson, writeJson, openLock } = require('../lib/fs');
-const { listRolloutFiles, parseRolloutIncremental } = require('../lib/rollout');
+const { listRolloutFiles, listClaudeProjectFiles, parseRolloutIncremental, parseClaudeIncremental } = require('../lib/rollout');
 const { drainQueueToCloud } = require('../lib/uploader');
 const { createProgress, renderBar, formatNumber, formatBytes } = require('../lib/progress');
 const { syncHeartbeat } = require('../lib/vibescore-api');
@@ -44,6 +44,7 @@ async function cmdSync(argv) {
 
     const codexHome = process.env.CODEX_HOME || path.join(home, '.codex');
     const codeHome = process.env.CODE_HOME || path.join(home, '.code');
+    const claudeProjectsDir = path.join(home, '.claude', 'projects');
 
     const sources = [
       { source: 'codex', sessionsDir: path.join(codexHome, 'sessions') },
@@ -80,6 +81,29 @@ async function cmdSync(argv) {
       }
     });
 
+    const claudeFiles = await listClaudeProjectFiles(claudeProjectsDir);
+    let claudeResult = { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+    if (claudeFiles.length > 0) {
+      if (progress?.enabled) {
+        progress.start(`Parsing Claude ${renderBar(0)} 0/${formatNumber(claudeFiles.length)} files | buckets 0`);
+      }
+      claudeResult = await parseClaudeIncremental({
+        projectFiles: claudeFiles,
+        cursors,
+        queuePath,
+        onProgress: (p) => {
+          if (!progress?.enabled) return;
+          const pct = p.total > 0 ? p.index / p.total : 1;
+          progress.update(
+            `Parsing Claude ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(
+              p.bucketsQueued
+            )}`
+          );
+        },
+        source: 'claude'
+      });
+    }
+
     cursors.updatedAt = new Date().toISOString();
     await writeJson(cursorsPath, cursors);
 
@@ -205,11 +229,13 @@ async function cmdSync(argv) {
     });
 
     if (!opts.auto) {
+      const totalParsed = parseResult.filesProcessed + claudeResult.filesProcessed;
+      const totalBuckets = parseResult.bucketsQueued + claudeResult.bucketsQueued;
       process.stdout.write(
         [
           'Sync finished:',
-          `- Parsed files: ${parseResult.filesProcessed}`,
-          `- New 30-min buckets queued: ${parseResult.bucketsQueued}`,
+          `- Parsed files: ${totalParsed}`,
+          `- New 30-min buckets queued: ${totalBuckets}`,
           deviceToken
             ? `- Uploaded: ${uploadResult.inserted} inserted, ${uploadResult.skipped} skipped`
             : '- Uploaded: skipped (no device token)',

package/src/commands/uninstall.js

@@ -3,6 +3,7 @@ const path = require('node:path');
 const fs = require('node:fs/promises');
 
 const { restoreCodexNotify, restoreEveryCodeNotify } = require('../lib/codex-config');
+const { removeClaudeHook, buildClaudeHookCommand } = require('../lib/claude-config');
 
 async function cmdUninstall(argv) {
   const opts = parseArgs(argv);
@@ -12,14 +13,17 @@ async function cmdUninstall(argv) {
   const codexConfigPath = path.join(home, '.codex', 'config.toml');
   const codeHome = process.env.CODE_HOME || path.join(home, '.code');
   const codeConfigPath = path.join(codeHome, 'config.toml');
+  const claudeSettingsPath = path.join(home, '.claude', 'settings.json');
   const notifyPath = path.join(binDir, 'notify.cjs');
   const notifyOriginalPath = path.join(trackerDir, 'codex_notify_original.json');
   const codeNotifyOriginalPath = path.join(trackerDir, 'code_notify_original.json');
   const codexNotifyCmd = ['/usr/bin/env', 'node', notifyPath];
   const codeNotifyCmd = ['/usr/bin/env', 'node', notifyPath, '--source=every-code'];
+  const claudeHookCommand = buildClaudeHookCommand(notifyPath);
 
   const codexConfigExists = await isFile(codexConfigPath);
   const codeConfigExists = await isFile(codeConfigPath);
+  const claudeConfigExists = await isFile(claudeSettingsPath);
   const codexRestore = codexConfigExists
     ? await restoreCodexNotify({
         codexConfigPath,
@@ -34,6 +38,9 @@ async function cmdUninstall(argv) {
         notifyCmd: codeNotifyCmd
       })
     : { restored: false, skippedReason: 'config-missing' };
+  const claudeRemove = claudeConfigExists
+    ? await removeClaudeHook({ settingsPath: claudeSettingsPath, hookCommand: claudeHookCommand })
+    : { removed: false, skippedReason: 'config-missing' };
 
   // Remove installed notify handler.
   await fs.unlink(notifyPath).catch(() => {});
@@ -62,6 +69,13 @@ async function cmdUninstall(argv) {
             ? '- Every Code notify: skipped (no backup; not installed)'
             : '- Every Code notify: no change'
         : '- Every Code notify: skipped (config.toml not found)',
+      claudeConfigExists
+        ? claudeRemove?.removed
+          ? `- Claude hooks removed: ${claudeSettingsPath}`
+          : claudeRemove?.skippedReason === 'hook-missing'
+            ? '- Claude hooks: no change'
+            : '- Claude hooks: skipped'
+        : '- Claude hooks: skipped (settings.json not found)',
       opts.purge ? `- Purged: ${path.join(home, '.vibescore')}` : '- Purge: skipped (use --purge)',
       ''
     ].join('\n')

package/src/lib/claude-config.js

@@ -0,0 +1,190 @@
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+const { ensureDir, readJson, writeJson } = require('./fs');
+
+const DEFAULT_EVENT = 'SessionEnd';
+
+async function upsertClaudeHook({ settingsPath, hookCommand, event = DEFAULT_EVENT }) {
+  const existing = await readJson(settingsPath);
+  const settings = normalizeSettings(existing);
+  const hooks = normalizeHooks(settings.hooks);
+  const entries = normalizeEntries(hooks[event]);
+
+  const normalized = normalizeEntriesForCommand(entries, hookCommand);
+  if (normalized.changed) {
+    const nextHooks = { ...hooks, [event]: normalized.entries };
+    const nextSettings = { ...settings, hooks: nextHooks };
+    const backupPath = await writeClaudeSettings({ settingsPath, settings: nextSettings });
+    return { changed: true, backupPath };
+  }
+
+  if (hasHook(entries, hookCommand)) {
+    return { changed: false, backupPath: null };
+  }
+
+  const nextEntries = entries.concat([{ hooks: [{ type: 'command', command: hookCommand }] }]);
+  const nextHooks = { ...hooks, [event]: nextEntries };
+  const nextSettings = { ...settings, hooks: nextHooks };
+
+  const backupPath = await writeClaudeSettings({ settingsPath, settings: nextSettings });
+  return { changed: true, backupPath };
+}
+
+async function removeClaudeHook({ settingsPath, hookCommand, event = DEFAULT_EVENT }) {
+  const existing = await readJson(settingsPath);
+  if (!existing) return { removed: false, skippedReason: 'settings-missing' };
+
+  const settings = normalizeSettings(existing);
+  const hooks = normalizeHooks(settings.hooks);
+  const entries = normalizeEntries(hooks[event]);
+  if (entries.length === 0) return { removed: false, skippedReason: 'hook-missing' };
+
+  let removed = false;
+  const nextEntries = [];
+  for (const entry of entries) {
+    const res = stripHookFromEntry(entry, hookCommand);
+    if (res.removed) removed = true;
+    if (res.entry) nextEntries.push(res.entry);
+  }
+
+  if (!removed) return { removed: false, skippedReason: 'hook-missing' };
+
+  const nextHooks = { ...hooks };
+  if (nextEntries.length > 0) nextHooks[event] = nextEntries;
+  else delete nextHooks[event];
+
+  const nextSettings = { ...settings };
+  if (Object.keys(nextHooks).length > 0) nextSettings.hooks = nextHooks;
+  else delete nextSettings.hooks;
+
+  const backupPath = await writeClaudeSettings({ settingsPath, settings: nextSettings });
+  return { removed: true, skippedReason: null, backupPath };
+}
+
+async function isClaudeHookConfigured({ settingsPath, hookCommand, event = DEFAULT_EVENT }) {
+  const settings = await readJson(settingsPath);
+  if (!settings || typeof settings !== 'object') return false;
+  const hooks = settings.hooks;
+  if (!hooks || typeof hooks !== 'object') return false;
+  const entries = normalizeEntries(hooks[event]);
+  return hasHook(entries, hookCommand);
+}
+
+function buildClaudeHookCommand(notifyPath) {
+  const cmd = typeof notifyPath === 'string' ? notifyPath : '';
+  return `/usr/bin/env node ${quoteArg(cmd)} --source=claude`;
+}
+
+function normalizeSettings(raw) {
+  return raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {};
+}
+
+function normalizeHooks(raw) {
+  return raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {};
+}
+
+function normalizeEntries(raw) {
+  return Array.isArray(raw) ? raw.slice() : [];
+}
+
+function normalizeCommand(cmd) {
+  if (Array.isArray(cmd)) return cmd.map((v) => String(v)).join('\u0000');
+  if (typeof cmd === 'string') return cmd.trim();
+  return null;
+}
+
+function hasHook(entries, hookCommand) {
+  for (const entry of entries) {
+    if (!entry || typeof entry !== 'object') continue;
+    if (entry.command && commandsEqual(entry.command, hookCommand)) return true;
+    const hooks = Array.isArray(entry.hooks) ? entry.hooks : [];
+    for (const hook of hooks) {
+      if (hook && commandsEqual(hook.command, hookCommand)) return true;
+    }
+  }
+  return false;
+}
+
+function stripHookFromEntry(entry, hookCommand) {
+  if (!entry || typeof entry !== 'object') return { entry, removed: false };
+
+  if (entry.command) {
+    if (commandsEqual(entry.command, hookCommand)) return { entry: null, removed: true };
+    return { entry, removed: false };
+  }
+
+  const hooks = Array.isArray(entry.hooks) ? entry.hooks : null;
+  if (!hooks) return { entry, removed: false };
+
+  const nextHooks = hooks.filter((hook) => !commandsEqual(hook?.command, hookCommand));
+  if (nextHooks.length === hooks.length) return { entry, removed: false };
+  if (nextHooks.length === 0) return { entry: null, removed: true };
+
+  return { entry: { ...entry, hooks: nextHooks }, removed: true };
+}
+
+function normalizeEntriesForCommand(entries, hookCommand) {
+  let changed = false;
+  const nextEntries = entries.map((entry) => {
+    if (!entry || typeof entry !== 'object') return entry;
+    if (entry.command && commandsEqual(entry.command, hookCommand)) {
+      if (entry.type !== 'command') {
+        changed = true;
+        return { ...entry, type: 'command' };
+      }
+      return entry;
+    }
+    if (!Array.isArray(entry.hooks)) return entry;
+    let hooksChanged = false;
+    const nextHooks = entry.hooks.map((hook) => {
+      if (hook && commandsEqual(hook.command, hookCommand)) {
+        if (hook.type !== 'command') {
+          hooksChanged = true;
+          return { ...hook, type: 'command' };
+        }
+      }
+      return hook;
+    });
+    if (!hooksChanged) return entry;
+    changed = true;
+    return { ...entry, hooks: nextHooks };
+  });
+  return { entries: nextEntries, changed };
+}
+
+function commandsEqual(a, b) {
+  const left = normalizeCommand(a);
+  const right = normalizeCommand(b);
+  return Boolean(left && right && left === right);
+}
+
+function quoteArg(value) {
+  const v = typeof value === 'string' ? value : '';
+  if (!v) return '""';
+  if (/^[A-Za-z0-9_\-./:@]+$/.test(v)) return v;
+  return `"${v.replace(/"/g, '\\"')}"`;
+}
+
+async function writeClaudeSettings({ settingsPath, settings }) {
+  await ensureDir(path.dirname(settingsPath));
+  let backupPath = null;
+  try {
+    const st = await fs.stat(settingsPath);
+    if (st && st.isFile()) {
+      backupPath = `${settingsPath}.bak.${new Date().toISOString().replace(/[:.]/g, '-')}`;
+      await fs.copyFile(settingsPath, backupPath);
+    }
+  } catch (_e) {
+    // Ignore missing file.
+  }
+  await writeJson(settingsPath, settings);
+  return backupPath;
+}
+
+module.exports = {
+  upsertClaudeHook,
+  removeClaudeHook,
+  isClaudeHookConfigured,
+  buildClaudeHookCommand
+};

package/src/lib/diagnostics.js

@@ -4,6 +4,7 @@ const fs = require('node:fs/promises');
 
 const { readJson } = require('./fs');
 const { readCodexNotify, readEveryCodeNotify } = require('./codex-config');
+const { isClaudeHookConfigured, buildClaudeHookCommand } = require('./claude-config');
 const { normalizeState: normalizeUploadState } = require('./upload-throttle');
 
 async function collectTrackerDiagnostics({
@@ -22,6 +23,7 @@ async function collectTrackerDiagnostics({
   const autoRetryPath = path.join(trackerDir, 'auto.retry.json');
   const codexConfigPath = path.join(codexHome, 'config.toml');
   const codeConfigPath = path.join(codeHome, 'config.toml');
+  const claudeConfigPath = path.join(home, '.claude', 'settings.json');
 
   const config = await readJson(configPath);
   const cursors = await readJson(cursorsPath);
@@ -42,6 +44,11 @@ async function collectTrackerDiagnostics({
   const everyCodeNotifyRaw = await readEveryCodeNotify(codeConfigPath);
   const everyCodeConfigured = Array.isArray(everyCodeNotifyRaw) && everyCodeNotifyRaw.length > 0;
   const everyCodeNotify = everyCodeConfigured ? everyCodeNotifyRaw.map((v) => redactValue(v, home)) : null;
+  const claudeHookCommand = buildClaudeHookCommand(path.join(home, '.vibescore', 'bin', 'notify.cjs'));
+  const claudeHookConfigured = await isClaudeHookConfigured({
+    settingsPath: claudeConfigPath,
+    hookCommand: claudeHookCommand
+  });
 
   const lastSuccessAt = uploadThrottle.lastSuccessMs ? new Date(uploadThrottle.lastSuccessMs).toISOString() : null;
   const autoRetryAt = parseEpochMsToIso(autoRetry?.retryAtMs);
@@ -60,7 +67,8 @@ async function collectTrackerDiagnostics({
       codex_home: redactValue(codexHome, home),
       codex_config: redactValue(codexConfigPath, home),
       code_home: redactValue(codeHome, home),
-      code_config: redactValue(codeConfigPath, home)
+      code_config: redactValue(codeConfigPath, home),
+      claude_config: redactValue(claudeConfigPath, home)
     },
     config: {
       base_url: typeof config?.baseUrl === 'string' ? config.baseUrl : null,
@@ -84,7 +92,8 @@ async function collectTrackerDiagnostics({
       codex_notify_configured: notifyConfigured,
       codex_notify: codexNotify,
       every_code_notify_configured: everyCodeConfigured,
-      every_code_notify: everyCodeNotify
+      every_code_notify: everyCodeNotify,
+      claude_hook_configured: claudeHookConfigured
     },
     upload: {
       last_success_at: lastSuccessAt,

package/src/lib/rollout.js

@@ -6,7 +6,8 @@ const readline = require('node:readline');
 const { ensureDir } = require('./fs');
 
 const DEFAULT_SOURCE = 'codex';
-const SOURCE_SEPARATOR = '|';
+const DEFAULT_MODEL = 'unknown';
+const BUCKET_SEPARATOR = '|';
 
 async function listRolloutFiles(sessionsDir) {
   const out = [];
@@ -36,6 +37,13 @@ async function listRolloutFiles(sessionsDir) {
   return out;
 }
 
+async function listClaudeProjectFiles(projectsDir) {
+  const out = [];
+  await walkClaudeProjects(projectsDir, out);
+  out.sort((a, b) => a.localeCompare(b));
+  return out;
+}
+
 async function parseRolloutIncremental({ rolloutFiles, cursors, queuePath, onProgress, source }) {
   await ensureDir(path.dirname(queuePath));
   let filesProcessed = 0;
@@ -107,6 +115,72 @@ async function parseRolloutIncremental({ rolloutFiles, cursors, queuePath, onPro
   return { filesProcessed, eventsAggregated, bucketsQueued };
 }
 
+async function parseClaudeIncremental({ projectFiles, cursors, queuePath, onProgress, source }) {
+  await ensureDir(path.dirname(queuePath));
+  let filesProcessed = 0;
+  let eventsAggregated = 0;
+
+  const cb = typeof onProgress === 'function' ? onProgress : null;
+  const files = Array.isArray(projectFiles) ? projectFiles : [];
+  const totalFiles = files.length;
+  const hourlyState = normalizeHourlyState(cursors?.hourly);
+  const touchedBuckets = new Set();
+  const defaultSource = normalizeSourceInput(source) || 'claude';
+
+  if (!cursors.files || typeof cursors.files !== 'object') {
+    cursors.files = {};
+  }
+
+  for (let idx = 0; idx < files.length; idx++) {
+    const entry = files[idx];
+    const filePath = typeof entry === 'string' ? entry : entry?.path;
+    if (!filePath) continue;
+    const fileSource =
+      typeof entry === 'string' ? defaultSource : normalizeSourceInput(entry?.source) || defaultSource;
+    const st = await fs.stat(filePath).catch(() => null);
+    if (!st || !st.isFile()) continue;
+
+    const key = filePath;
+    const prev = cursors.files[key] || null;
+    const inode = st.ino || 0;
+    const startOffset = prev && prev.inode === inode ? prev.offset || 0 : 0;
+
+    const result = await parseClaudeFile({
+      filePath,
+      startOffset,
+      hourlyState,
+      touchedBuckets,
+      source: fileSource
+    });
+
+    cursors.files[key] = {
+      inode,
+      offset: result.endOffset,
+      updatedAt: new Date().toISOString()
+    };
+
+    filesProcessed += 1;
+    eventsAggregated += result.eventsAggregated;
+
+    if (cb) {
+      cb({
+        index: idx + 1,
+        total: totalFiles,
+        filePath,
+        filesProcessed,
+        eventsAggregated,
+        bucketsQueued: touchedBuckets.size
+      });
+    }
+  }
+
+  const bucketsQueued = await enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets });
+  hourlyState.updatedAt = new Date().toISOString();
+  cursors.hourly = hourlyState;
+
+  return { filesProcessed, eventsAggregated, bucketsQueued };
+}
+
 async function parseRolloutFile({
   filePath,
   startOffset,
@@ -169,15 +243,59 @@ async function parseRolloutFile({
     const bucketStart = toUtcHalfHourStart(tokenTimestamp);
     if (!bucketStart) continue;
 
-    const bucket = getHourlyBucket(hourlyState, source, bucketStart);
+    const bucket = getHourlyBucket(hourlyState, source, model, bucketStart);
     addTotals(bucket.totals, delta);
-    touchedBuckets.add(bucketKey(source, bucketStart));
+    touchedBuckets.add(bucketKey(source, model, bucketStart));
     eventsAggregated += 1;
   }
 
   return { endOffset, lastTotal: totals, lastModel: model, eventsAggregated };
 }
 
+async function parseClaudeFile({ filePath, startOffset, hourlyState, touchedBuckets, source }) {
+  const st = await fs.stat(filePath).catch(() => null);
+  if (!st || !st.isFile()) return { endOffset: startOffset, eventsAggregated: 0 };
+
+  const endOffset = st.size;
+  if (startOffset >= endOffset) return { endOffset, eventsAggregated: 0 };
+
+  const stream = fssync.createReadStream(filePath, { encoding: 'utf8', start: startOffset });
+  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+
+  let eventsAggregated = 0;
+  for await (const line of rl) {
+    if (!line || !line.includes('\"usage\"')) continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch (_e) {
+      continue;
+    }
+
+    const usage = obj?.message?.usage || obj?.usage;
+    if (!usage || typeof usage !== 'object') continue;
+
+    const model = normalizeModelInput(obj?.message?.model || obj?.model) || DEFAULT_MODEL;
+    const tokenTimestamp = typeof obj?.timestamp === 'string' ? obj.timestamp : null;
+    if (!tokenTimestamp) continue;
+
+    const delta = normalizeClaudeUsage(usage);
+    if (!delta || isAllZeroUsage(delta)) continue;
+
+    const bucketStart = toUtcHalfHourStart(tokenTimestamp);
+    if (!bucketStart) continue;
+
+    const bucket = getHourlyBucket(hourlyState, source, model, bucketStart);
+    addTotals(bucket.totals, delta);
+    touchedBuckets.add(bucketKey(source, model, bucketStart));
+    eventsAggregated += 1;
+  }
+
+  rl.close();
+  stream.close?.();
+  return { endOffset, eventsAggregated };
+}
+
 async function enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets }) {
   if (!touchedBuckets || touchedBuckets.size === 0) return 0;
 
@@ -185,14 +303,17 @@ async function enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets })
   for (const bucketStart of touchedBuckets) {
     const parsedKey = parseBucketKey(bucketStart);
     const source = parsedKey.source || DEFAULT_SOURCE;
+    const model = parsedKey.model || DEFAULT_MODEL;
     const hourStart = parsedKey.hourStart;
-    const bucket = hourlyState.buckets[bucketKey(source, hourStart)] || hourlyState.buckets[bucketStart];
+    const bucket =
+      hourlyState.buckets[bucketKey(source, model, hourStart)] || hourlyState.buckets[bucketStart];
     if (!bucket || !bucket.totals) continue;
     const key = totalsKey(bucket.totals);
     if (bucket.queuedKey === key) continue;
     toAppend.push(
       JSON.stringify({
         source,
+        model,
         hour_start: hourStart,
         input_tokens: bucket.totals.input_tokens,
         cached_input_tokens: bucket.totals.cached_input_tokens,
@@ -213,26 +334,35 @@ async function enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets })
 
 function normalizeHourlyState(raw) {
   const state = raw && typeof raw === 'object' ? raw : {};
+  const version = Number(state.version || 1);
+  if (!Number.isFinite(version) || version < 2) {
+    return {
+      version: 2,
+      buckets: {},
+      updatedAt: null
+    };
+  }
   const rawBuckets = state.buckets && typeof state.buckets === 'object' ? state.buckets : {};
   const buckets = {};
   for (const [key, value] of Object.entries(rawBuckets)) {
-    if (key.includes(SOURCE_SEPARATOR)) {
-      buckets[key] = value;
-      continue;
-    }
-    buckets[bucketKey(DEFAULT_SOURCE, key)] = value;
+    const parsed = parseBucketKey(key);
+    const hourStart = parsed.hourStart;
+    if (!hourStart) continue;
+    const normalizedKey = bucketKey(parsed.source, parsed.model, hourStart);
+    buckets[normalizedKey] = value;
   }
   return {
-    version: 1,
+    version: 2,
     buckets,
     updatedAt: typeof state.updatedAt === 'string' ? state.updatedAt : null
   };
 }
 
-function getHourlyBucket(state, source, hourStart) {
+function getHourlyBucket(state, source, model, hourStart) {
   const buckets = state.buckets;
   const normalizedSource = normalizeSourceInput(source) || DEFAULT_SOURCE;
-  const key = bucketKey(normalizedSource, hourStart);
+  const normalizedModel = normalizeModelInput(model) || DEFAULT_MODEL;
+  const key = bucketKey(normalizedSource, normalizedModel, hourStart);
   let bucket = buckets[key];
   if (!bucket || typeof bucket !== 'object') {
     bucket = { totals: initTotals(), queuedKey: null };
@@ -298,16 +428,25 @@ function toUtcHalfHourStart(ts) {
   return bucketStart.toISOString();
 }
 
-function bucketKey(source, hourStart) {
+function bucketKey(source, model, hourStart) {
   const safeSource = normalizeSourceInput(source) || DEFAULT_SOURCE;
-  return `${safeSource}${SOURCE_SEPARATOR}${hourStart}`;
+  const safeModel = normalizeModelInput(model) || DEFAULT_MODEL;
+  return `${safeSource}${BUCKET_SEPARATOR}${safeModel}${BUCKET_SEPARATOR}${hourStart}`;
 }
 
 function parseBucketKey(key) {
-  if (typeof key !== 'string') return { source: DEFAULT_SOURCE, hourStart: '' };
-  const idx = key.indexOf(SOURCE_SEPARATOR);
-  if (idx <= 0) return { source: DEFAULT_SOURCE, hourStart: key };
-  return { source: key.slice(0, idx), hourStart: key.slice(idx + 1) };
+  if (typeof key !== 'string') return { source: DEFAULT_SOURCE, model: DEFAULT_MODEL, hourStart: '' };
+  const first = key.indexOf(BUCKET_SEPARATOR);
+  if (first <= 0) return { source: DEFAULT_SOURCE, model: DEFAULT_MODEL, hourStart: key };
+  const second = key.indexOf(BUCKET_SEPARATOR, first + 1);
+  if (second <= 0) {
+    return { source: key.slice(0, first), model: DEFAULT_MODEL, hourStart: key.slice(first + 1) };
+  }
+  return {
+    source: key.slice(0, first),
+    model: key.slice(first + 1, second),
+    hourStart: key.slice(second + 1)
+  };
 }
 
 function normalizeSourceInput(value) {
@@ -316,6 +455,12 @@ function normalizeSourceInput(value) {
   return trimmed.length > 0 ? trimmed : null;
 }
 
+function normalizeModelInput(value) {
+  if (typeof value !== 'string') return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
 function extractTokenCount(obj) {
   const payload = obj?.payload;
   if (!payload) return null;
@@ -377,6 +522,16 @@ function normalizeUsage(u) {
   return out;
 }
 
+function normalizeClaudeUsage(u) {
+  return {
+    input_tokens: toNonNegativeInt(u?.input_tokens),
+    cached_input_tokens: toNonNegativeInt(u?.cache_read_input_tokens),
+    output_tokens: toNonNegativeInt(u?.output_tokens),
+    reasoning_output_tokens: 0,
+    total_tokens: toNonNegativeInt(u?.input_tokens) + toNonNegativeInt(u?.output_tokens)
+  };
+}
+
 function isNonEmptyObject(v) {
   return Boolean(v && typeof v === 'object' && !Array.isArray(v) && Object.keys(v).length > 0);
 }
@@ -421,7 +576,21 @@ async function safeReadDir(dir) {
   }
 }
 
+async function walkClaudeProjects(dir, out) {
+  const entries = await safeReadDir(dir);
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkClaudeProjects(fullPath, out);
+      continue;
+    }
+    if (entry.isFile() && entry.name.endsWith('.jsonl')) out.push(fullPath);
+  }
+}
+
 module.exports = {
   listRolloutFiles,
-  parseRolloutIncremental
+  listClaudeProjectFiles,
+  parseRolloutIncremental,
+  parseClaudeIncremental
 };

package/src/lib/uploader.js

@@ -6,7 +6,8 @@ const { ensureDir, readJson, writeJson } = require('./fs');
 const { ingestHourly } = require('./vibescore-api');
 
 const DEFAULT_SOURCE = 'codex';
-const SOURCE_SEPARATOR = '|';
+const DEFAULT_MODEL = 'unknown';
+const BUCKET_SEPARATOR = '|';
 
 async function drainQueueToCloud({ baseUrl, deviceToken, queuePath, queueStatePath, maxBatches, batchSize, onProgress }) {
   await ensureDir(require('node:path').dirname(queueStatePath));
@@ -74,8 +75,10 @@ async function readBatch(queuePath, startOffset, maxBuckets) {
     const hourStart = typeof bucket?.hour_start === 'string' ? bucket.hour_start : null;
     if (!hourStart) continue;
     const source = normalizeSource(bucket?.source) || DEFAULT_SOURCE;
+    const model = normalizeModel(bucket?.model) || DEFAULT_MODEL;
     bucket.source = source;
-    bucketMap.set(bucketKey(source, hourStart), bucket);
+    bucket.model = model;
+    bucketMap.set(bucketKey(source, model, hourStart), bucket);
     linesRead += 1;
     if (linesRead >= maxBuckets) break;
   }
@@ -94,8 +97,8 @@ async function safeFileSize(p) {
   }
 }
 
-function bucketKey(source, hourStart) {
-  return `${source}${SOURCE_SEPARATOR}${hourStart}`;
+function bucketKey(source, model, hourStart) {
+  return `${source}${BUCKET_SEPARATOR}${model}${BUCKET_SEPARATOR}${hourStart}`;
 }
 
 function normalizeSource(value) {
@@ -104,4 +107,10 @@ function normalizeSource(value) {
   return trimmed.length > 0 ? trimmed : null;
 }
 
+function normalizeModel(value) {
+  if (typeof value !== 'string') return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
 module.exports = { drainQueueToCloud };