@vibescore/tracker 0.0.8 → 0.1.0

package/README.md

@@ -13,7 +13,7 @@ _Real-time AI Analytics for Codex CLI_
 
 [**English**](README.md) • [**中文说明**](README.zh-CN.md)
 
-[**Documentation**](docs/) • [**Dashboard**](dashboard/) • [**Backend API**](BACKEND_API.md) • [**Dashboard API**](docs/dashboard/api.md)
+[**Documentation**](docs/) • [**Dashboard**](dashboard/) • [**Backend API**](BACKEND_API.md)
 
 <br/>
 
@@ -25,7 +25,7 @@ _Real-time AI Analytics for Codex CLI_
 
 ## 🌌 Overview
 
-**VibeScore** is an intelligent token usage tracking system designed specifically for macOS developers. It monitors Codex CLI output in real-time, transforming your **AI Output** into quantifiable metrics via a high-fidelity, **Matrix-themed** dashboard.
+**VibeScore** is an intelligent token usage tracking system designed specifically for macOS developers. Through the all-new **Matrix-A Design System**, it provides a high-fidelity cyberpunk-style dashboard that transforms your **AI Output** into quantifiable metrics, supported by the **Neural Divergence Map** for real-time monitoring of multi-model compute distribution.
 
 > [!TIP] > **Core Index**: Our signature metric that reflects your flow state by analyzing token consumption rates and patterns.
 
@@ -40,9 +40,12 @@ We believe your code and thoughts are your own. VibeScore is built with strict p
 
 ## 🚀 Key Features
 
-- 📡 **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.
+- 📡 **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.
+- 🧭 **Universal-Sync**: Native support for **Codex CLI**, **Every Code**, and the latest **Claude Code**. Whether it's GPT-4, Claude 3.5 Sonnet, or o1/Gemini, token consumption from all models is unified and counted.
+- 📊 **Matrix Dashboard**: High-performance dashboard built with React + Vite, featuring the new **Matrix-A** design language.
+  - **Neural Divergence Map**: Visualize multi-engine load balancing and compute distribution.
+  - **Cost Intelligence**: Real-time, multi-dimensional cost breakdown and forecasting.
+  - **Smart Notifications**: Non-intrusive system-level alerts using a Golden (Gold/Amber) visual style for high-value information.
 - ⚡ **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.
 
@@ -79,11 +82,13 @@ npx --yes @vibescore/tracker status
 
 - Codex CLI logs: `~/.codex/sessions/**/rollout-*.jsonl` (override with `CODEX_HOME`)
 - Every Code logs: `~/.code/sessions/**/rollout-*.jsonl` (override with `CODE_HOME`)
+- Gemini CLI logs: `~/.gemini/tmp/**/chats/session-*.json` (override with `GEMINI_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`).
+- `GEMINI_HOME`: Override Gemini CLI home (defaults to `~/.gemini`).
 
 ## 🧰 Troubleshooting
 

package/README.zh-CN.md

@@ -13,7 +13,7 @@ _Codex CLI 实时 AI 分析工具_
 
 [**English**](README.md) • [**中文说明**](README.zh-CN.md)
 
-[**文档**](docs/) • [**控制台**](dashboard/) • [**后端接口**](BACKEND_API.md) • [**Dashboard API**](docs/dashboard/api.md)
+[**文档**](docs/) • [**控制台**](dashboard/) • [**后端接口**](BACKEND_API.md)
 
 <br/>
 
@@ -25,7 +25,7 @@ _Codex CLI 实时 AI 分析工具_
 
 ## 🌌 项目概述
 
-**VibeScore** 是一个专为 macOS 开发者设计的智能令牌（Token）使用追踪系统。它能够实时监控 Codex CLI 的输出，通过高度可视化的 **Matrix** 风格仪表盘，将你的 **AI 产出 (AI Output)** 转化为可量化的指标。
+**VibeScore** 是一个专为 macOS 开发者设计的智能令牌（Token）使用追踪系统。它通过全新的 **Matrix-A Design System**，提供高度可视化的赛博朋克风格仪表盘，将你的 **AI 产出 (AI Output)** 转化为可量化的指标，并支持通过 **Neural Divergence Map** 实时监控多模型的算力分布。
 
 > [!TIP] > **Core Index (核心指数)**: 我们的标志性指标，通过分析 Token 消耗速率与模式，反映你的开发心流状态。
 
@@ -41,8 +41,11 @@ _Codex CLI 实时 AI 分析工具_
 ## 🚀 核心功能
 
 - 📡 **自动嗅探与同步 (Auto-Sync)**: 实时监听 Codex CLI 管道并具备**全自动后台同步**功能。初始化后，你的 Token 产出将自动追踪并同步，无需手动执行脚本。
-- 🧭 **多来源采集**：支持 Codex CLI 与 Every Code（标记为 `source=every-code`），无需修改 Every Code 客户端。
-- 📊 **Matrix Dashboard (矩阵控制台)**: 基于 React + Vite 的高性能仪表盘，具备热力图、趋势图与实时日志。
+- 🧭 **全能采集 (Universal-Sync)**: 原生支持 **Codex CLI**, **Every Code** 以及最新的 **Claude Code**。无论是 GPT-4, Claude 3.5 Sonnet 还是 o1/Gemini，所有模型的 Token 消耗均可被统一捕获与统计。
+- 📊 **Matrix Dashboard (矩阵控制台)**: 基于 React + Vite 的高性能仪表盘，采用全新的 **Matrix-A** 设计语言。
+  - **Neural Divergence Map (神经发散图谱)**: 可视化多引擎负载均衡状态，直观展示算力分布。
+  - **Cost Intelligence (成本智能)**: 实时、多维度的成本分解与预测。
+  - **Smart Notifications (智能通知)**: 非侵入式的系统级通知，采用金色 (Gold/Amber) 视觉传达高价值信息。
 - ⚡ **AI Analytics (AI 分析)**: 深度分析 Input/Output Token，支持缓存 (Cached) 与推理 (Reasoning) 部分的分离监控。
 - 🔒 **Identity Core (身份核心)**: 完备的身份验证与权限管理，保护你的开发数据资产。
 
@@ -79,11 +82,13 @@ npx --yes @vibescore/tracker status
 
 - Codex CLI 日志：`~/.codex/sessions/**/rollout-*.jsonl`（可用 `CODEX_HOME` 覆盖）
 - Every Code 日志：`~/.code/sessions/**/rollout-*.jsonl`（可用 `CODE_HOME` 覆盖）
+- Gemini CLI 日志：`~/.gemini/tmp/**/chats/session-*.json`（可用 `GEMINI_HOME` 覆盖）
 
 ## 🔧 环境变量
 
 - `VIBESCORE_HTTP_TIMEOUT_MS`：CLI 请求超时（毫秒，默认 `20000`，`0` 表示关闭，范围 `1000..120000`）。
 - `VITE_VIBESCORE_HTTP_TIMEOUT_MS`：Dashboard 请求超时（毫秒，默认 `15000`，`0` 表示关闭，范围 `1000..30000`）。
+- `GEMINI_HOME`：覆盖 Gemini CLI 的 home（默认 `~/.gemini`）。
 
 ## 🧰 常见问题
 

package/package.json

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

package/src/commands/init.js

@@ -387,6 +387,10 @@ function spawnInitSync({ trackerBinPath, packageName }) {
     stdio: 'ignore',
     env: process.env
   });
+  child.on('error', (err) => {
+    const msg = err && err.message ? err.message : 'unknown error';
+    process.stderr.write(`Initial sync spawn failed: ${msg}\n`);
+  });
   child.unref();
 }
 

package/src/commands/sync.js

@@ -4,7 +4,14 @@ const fs = require('node:fs/promises');
 const cp = require('node:child_process');
 
 const { ensureDir, readJson, writeJson, openLock } = require('../lib/fs');
-const { listRolloutFiles, listClaudeProjectFiles, parseRolloutIncremental, parseClaudeIncremental } = require('../lib/rollout');
+const {
+  listRolloutFiles,
+  listClaudeProjectFiles,
+  listGeminiSessionFiles,
+  parseRolloutIncremental,
+  parseClaudeIncremental,
+  parseGeminiIncremental
+} = require('../lib/rollout');
 const { drainQueueToCloud } = require('../lib/uploader');
 const { createProgress, renderBar, formatNumber, formatBytes } = require('../lib/progress');
 const { syncHeartbeat } = require('../lib/vibescore-api');
@@ -45,6 +52,8 @@ 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 geminiHome = process.env.GEMINI_HOME || path.join(home, '.gemini');
+    const geminiTmpDir = path.join(geminiHome, 'tmp');
 
     const sources = [
       { source: 'codex', sessionsDir: path.join(codexHome, 'sessions') },
@@ -104,6 +113,29 @@ async function cmdSync(argv) {
       });
     }
 
+    const geminiFiles = await listGeminiSessionFiles(geminiTmpDir);
+    let geminiResult = { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+    if (geminiFiles.length > 0) {
+      if (progress?.enabled) {
+        progress.start(`Parsing Gemini ${renderBar(0)} 0/${formatNumber(geminiFiles.length)} files | buckets 0`);
+      }
+      geminiResult = await parseGeminiIncremental({
+        sessionFiles: geminiFiles,
+        cursors,
+        queuePath,
+        onProgress: (p) => {
+          if (!progress?.enabled) return;
+          const pct = p.total > 0 ? p.index / p.total : 1;
+          progress.update(
+            `Parsing Gemini ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(
+              p.bucketsQueued
+            )}`
+          );
+        },
+        source: 'gemini'
+      });
+    }
+
     cursors.updatedAt = new Date().toISOString();
     await writeJson(cursorsPath, cursors);
 
@@ -229,8 +261,8 @@ async function cmdSync(argv) {
     });
 
     if (!opts.auto) {
-      const totalParsed = parseResult.filesProcessed + claudeResult.filesProcessed;
-      const totalBuckets = parseResult.bucketsQueued + claudeResult.bucketsQueued;
+      const totalParsed = parseResult.filesProcessed + claudeResult.filesProcessed + geminiResult.filesProcessed;
+      const totalBuckets = parseResult.bucketsQueued + claudeResult.bucketsQueued + geminiResult.bucketsQueued;
       process.stdout.write(
         [
           'Sync finished:',

package/src/lib/rollout.js

@@ -44,6 +44,23 @@ async function listClaudeProjectFiles(projectsDir) {
   return out;
 }
 
+async function listGeminiSessionFiles(tmpDir) {
+  const out = [];
+  const roots = await safeReadDir(tmpDir);
+  for (const root of roots) {
+    if (!root.isDirectory()) continue;
+    const chatsDir = path.join(tmpDir, root.name, 'chats');
+    const chats = await safeReadDir(chatsDir);
+    for (const entry of chats) {
+      if (!entry.isFile()) continue;
+      if (!entry.name.startsWith('session-') || !entry.name.endsWith('.json')) continue;
+      out.push(path.join(chatsDir, entry.name));
+    }
+  }
+  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;
@@ -181,6 +198,78 @@ async function parseClaudeIncremental({ projectFiles, cursors, queuePath, onProg
   return { filesProcessed, eventsAggregated, bucketsQueued };
 }
 
+async function parseGeminiIncremental({ sessionFiles, 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(sessionFiles) ? sessionFiles : [];
+  const totalFiles = files.length;
+  const hourlyState = normalizeHourlyState(cursors?.hourly);
+  const touchedBuckets = new Set();
+  const defaultSource = normalizeSourceInput(source) || 'gemini';
+
+  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;
+    let startIndex = prev && prev.inode === inode ? Number(prev.lastIndex || -1) : -1;
+    let lastTotals = prev && prev.inode === inode ? prev.lastTotals || null : null;
+    let lastModel = prev && prev.inode === inode ? prev.lastModel || null : null;
+
+    const result = await parseGeminiFile({
+      filePath,
+      startIndex,
+      lastTotals,
+      lastModel,
+      hourlyState,
+      touchedBuckets,
+      source: fileSource
+    });
+
+    cursors.files[key] = {
+      inode,
+      lastIndex: result.lastIndex,
+      lastTotals: result.lastTotals,
+      lastModel: result.lastModel,
+      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,
@@ -296,35 +385,137 @@ async function parseClaudeFile({ filePath, startOffset, hourlyState, touchedBuck
   return { endOffset, eventsAggregated };
 }
 
+async function parseGeminiFile({
+  filePath,
+  startIndex,
+  lastTotals,
+  lastModel,
+  hourlyState,
+  touchedBuckets,
+  source
+}) {
+  const raw = await fs.readFile(filePath, 'utf8').catch(() => '');
+  if (!raw.trim()) return { lastIndex: startIndex, lastTotals, lastModel, eventsAggregated: 0 };
+
+  let session;
+  try {
+    session = JSON.parse(raw);
+  } catch (_e) {
+    return { lastIndex: startIndex, lastTotals, lastModel, eventsAggregated: 0 };
+  }
+
+  const messages = Array.isArray(session?.messages) ? session.messages : [];
+  if (startIndex >= messages.length) {
+    startIndex = -1;
+    lastTotals = null;
+    lastModel = null;
+  }
+
+  let eventsAggregated = 0;
+  let model = typeof lastModel === 'string' ? lastModel : null;
+  let totals = lastTotals && typeof lastTotals === 'object' ? lastTotals : null;
+  const begin = Number.isFinite(startIndex) ? startIndex + 1 : 0;
+
+  for (let idx = begin; idx < messages.length; idx++) {
+    const msg = messages[idx];
+    if (!msg || typeof msg !== 'object') continue;
+
+    const normalizedModel = normalizeModelInput(msg.model);
+    if (normalizedModel) model = normalizedModel;
+
+    const timestamp = typeof msg.timestamp === 'string' ? msg.timestamp : null;
+    const currentTotals = normalizeGeminiTokens(msg.tokens);
+    if (!timestamp || !currentTotals) {
+      totals = currentTotals || totals;
+      continue;
+    }
+
+    const delta = diffGeminiTotals(currentTotals, totals);
+    if (!delta || isAllZeroUsage(delta)) {
+      totals = currentTotals;
+      continue;
+    }
+
+    const bucketStart = toUtcHalfHourStart(timestamp);
+    if (!bucketStart) {
+      totals = currentTotals;
+      continue;
+    }
+
+    const bucket = getHourlyBucket(hourlyState, source, model, bucketStart);
+    addTotals(bucket.totals, delta);
+    touchedBuckets.add(bucketKey(source, model, bucketStart));
+    eventsAggregated += 1;
+    totals = currentTotals;
+  }
+
+  return {
+    lastIndex: messages.length - 1,
+    lastTotals: totals,
+    lastModel: model,
+    eventsAggregated
+  };
+}
+
 async function enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets }) {
   if (!touchedBuckets || touchedBuckets.size === 0) return 0;
 
-  const toAppend = [];
+  const touchedGroups = new Set();
   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, model, hourStart)] || hourlyState.buckets[bucketStart];
+    const parsed = parseBucketKey(bucketStart);
+    const hourStart = parsed.hourStart;
+    if (!hourStart) continue;
+    touchedGroups.add(groupBucketKey(parsed.source, hourStart));
+  }
+  if (touchedGroups.size === 0) return 0;
+
+  const grouped = new Map();
+  for (const [key, bucket] of Object.entries(hourlyState.buckets || {})) {
     if (!bucket || !bucket.totals) continue;
-    const key = totalsKey(bucket.totals);
-    if (bucket.queuedKey === key) continue;
+    const parsed = parseBucketKey(key);
+    const hourStart = parsed.hourStart;
+    if (!hourStart) continue;
+    const groupKey = groupBucketKey(parsed.source, hourStart);
+    if (!touchedGroups.has(groupKey)) continue;
+
+    let group = grouped.get(groupKey);
+    if (!group) {
+      group = {
+        source: normalizeSourceInput(parsed.source) || DEFAULT_SOURCE,
+        hourStart,
+        models: new Set(),
+        totals: initTotals()
+      };
+      grouped.set(groupKey, group);
+    }
+    group.models.add(parsed.model || DEFAULT_MODEL);
+    addTotals(group.totals, bucket.totals);
+  }
+
+  const toAppend = [];
+  const groupQueued = hourlyState.groupQueued && typeof hourlyState.groupQueued === 'object' ? hourlyState.groupQueued : {};
+  for (const group of grouped.values()) {
+    const model = group.models.size === 1 ? [...group.models][0] : DEFAULT_MODEL;
+    const key = totalsKey(group.totals);
+    const groupKey = groupBucketKey(group.source, group.hourStart);
+    if (groupQueued[groupKey] === key) continue;
     toAppend.push(
       JSON.stringify({
-        source,
+        source: group.source,
         model,
-        hour_start: hourStart,
-        input_tokens: bucket.totals.input_tokens,
-        cached_input_tokens: bucket.totals.cached_input_tokens,
-        output_tokens: bucket.totals.output_tokens,
-        reasoning_output_tokens: bucket.totals.reasoning_output_tokens,
-        total_tokens: bucket.totals.total_tokens
+        hour_start: group.hourStart,
+        input_tokens: group.totals.input_tokens,
+        cached_input_tokens: group.totals.cached_input_tokens,
+        output_tokens: group.totals.output_tokens,
+        reasoning_output_tokens: group.totals.reasoning_output_tokens,
+        total_tokens: group.totals.total_tokens
       })
     );
-    bucket.queuedKey = key;
+    groupQueued[groupKey] = key;
   }
 
+  hourlyState.groupQueued = groupQueued;
+
   if (toAppend.length > 0) {
     await fs.appendFile(queuePath, toAppend.join('\n') + '\n', 'utf8');
   }
@@ -335,15 +526,30 @@ async function enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets })
 function normalizeHourlyState(raw) {
   const state = raw && typeof raw === 'object' ? raw : {};
   const version = Number(state.version || 1);
+  const rawBuckets = state.buckets && typeof state.buckets === 'object' ? state.buckets : {};
+  const buckets = {};
+  const groupQueued = {};
+
   if (!Number.isFinite(version) || version < 2) {
+    for (const [key, value] of Object.entries(rawBuckets)) {
+      const parsed = parseBucketKey(key);
+      const hourStart = parsed.hourStart;
+      if (!hourStart) continue;
+      const source = normalizeSourceInput(parsed.source) || DEFAULT_SOURCE;
+      const normalizedKey = bucketKey(source, DEFAULT_MODEL, hourStart);
+      buckets[normalizedKey] = value;
+      if (value?.queuedKey) {
+        groupQueued[groupBucketKey(source, hourStart)] = value.queuedKey;
+      }
+    }
     return {
-      version: 2,
-      buckets: {},
-      updatedAt: null
+      version: 3,
+      buckets,
+      groupQueued,
+      updatedAt: typeof state.updatedAt === 'string' ? state.updatedAt : null
     };
   }
-  const rawBuckets = state.buckets && typeof state.buckets === 'object' ? state.buckets : {};
-  const buckets = {};
+
   for (const [key, value] of Object.entries(rawBuckets)) {
     const parsed = parseBucketKey(key);
     const hourStart = parsed.hourStart;
@@ -351,9 +557,14 @@ function normalizeHourlyState(raw) {
     const normalizedKey = bucketKey(parsed.source, parsed.model, hourStart);
     buckets[normalizedKey] = value;
   }
+
+  const existingGroupQueued =
+    state.groupQueued && typeof state.groupQueued === 'object' ? state.groupQueued : {};
+
   return {
-    version: 2,
+    version: 3,
     buckets,
+    groupQueued: version >= 3 ? existingGroupQueued : {},
     updatedAt: typeof state.updatedAt === 'string' ? state.updatedAt : null
   };
 }
@@ -434,6 +645,11 @@ function bucketKey(source, model, hourStart) {
   return `${safeSource}${BUCKET_SEPARATOR}${safeModel}${BUCKET_SEPARATOR}${hourStart}`;
 }
 
+function groupBucketKey(source, hourStart) {
+  const safeSource = normalizeSourceInput(source) || DEFAULT_SOURCE;
+  return `${safeSource}${BUCKET_SEPARATOR}${hourStart}`;
+}
+
 function parseBucketKey(key) {
   if (typeof key !== 'string') return { source: DEFAULT_SOURCE, model: DEFAULT_MODEL, hourStart: '' };
   const first = key.indexOf(BUCKET_SEPARATOR);
@@ -461,6 +677,54 @@ function normalizeModelInput(value) {
   return trimmed.length > 0 ? trimmed : null;
 }
 
+function normalizeGeminiTokens(tokens) {
+  if (!tokens || typeof tokens !== 'object') return null;
+  const input = toNonNegativeInt(tokens.input);
+  const cached = toNonNegativeInt(tokens.cached);
+  const output = toNonNegativeInt(tokens.output);
+  const tool = toNonNegativeInt(tokens.tool);
+  const thoughts = toNonNegativeInt(tokens.thoughts);
+  const total = toNonNegativeInt(tokens.total);
+
+  return {
+    input_tokens: input,
+    cached_input_tokens: cached,
+    output_tokens: output + tool,
+    reasoning_output_tokens: thoughts,
+    total_tokens: total
+  };
+}
+
+function sameGeminiTotals(a, b) {
+  if (!a || !b) return false;
+  return (
+    a.input_tokens === b.input_tokens &&
+    a.cached_input_tokens === b.cached_input_tokens &&
+    a.output_tokens === b.output_tokens &&
+    a.reasoning_output_tokens === b.reasoning_output_tokens &&
+    a.total_tokens === b.total_tokens
+  );
+}
+
+function diffGeminiTotals(current, previous) {
+  if (!current || typeof current !== 'object') return null;
+  if (!previous || typeof previous !== 'object') return current;
+  if (sameGeminiTotals(current, previous)) return null;
+
+  const totalReset = (current.total_tokens || 0) < (previous.total_tokens || 0);
+  if (totalReset) return current;
+
+  const delta = {
+    input_tokens: Math.max(0, (current.input_tokens || 0) - (previous.input_tokens || 0)),
+    cached_input_tokens: Math.max(0, (current.cached_input_tokens || 0) - (previous.cached_input_tokens || 0)),
+    output_tokens: Math.max(0, (current.output_tokens || 0) - (previous.output_tokens || 0)),
+    reasoning_output_tokens: Math.max(0, (current.reasoning_output_tokens || 0) - (previous.reasoning_output_tokens || 0)),
+    total_tokens: Math.max(0, (current.total_tokens || 0) - (previous.total_tokens || 0))
+  };
+
+  return isAllZeroUsage(delta) ? null : delta;
+}
+
 function extractTokenCount(obj) {
   const payload = obj?.payload;
   if (!payload) return null;
@@ -523,12 +787,16 @@ function normalizeUsage(u) {
 }
 
 function normalizeClaudeUsage(u) {
+  const inputTokens = toNonNegativeInt(u?.input_tokens);
+  const outputTokens = toNonNegativeInt(u?.output_tokens);
+  const hasTotal = u && Object.prototype.hasOwnProperty.call(u, 'total_tokens');
+  const totalTokens = hasTotal ? toNonNegativeInt(u?.total_tokens) : inputTokens + outputTokens;
   return {
-    input_tokens: toNonNegativeInt(u?.input_tokens),
+    input_tokens: inputTokens,
     cached_input_tokens: toNonNegativeInt(u?.cache_read_input_tokens),
-    output_tokens: toNonNegativeInt(u?.output_tokens),
+    output_tokens: outputTokens,
     reasoning_output_tokens: 0,
-    total_tokens: toNonNegativeInt(u?.input_tokens) + toNonNegativeInt(u?.output_tokens)
+    total_tokens: totalTokens
   };
 }
 
@@ -591,6 +859,8 @@ async function walkClaudeProjects(dir, out) {
 module.exports = {
   listRolloutFiles,
   listClaudeProjectFiles,
+  listGeminiSessionFiles,
   parseRolloutIncremental,
-  parseClaudeIncremental
+  parseClaudeIncremental,
+  parseGeminiIncremental
 };

package/src/lib/uploader.js

@@ -78,7 +78,7 @@ async function readBatch(queuePath, startOffset, maxBuckets) {
     const model = normalizeModel(bucket?.model) || DEFAULT_MODEL;
     bucket.source = source;
     bucket.model = model;
-    bucketMap.set(bucketKey(source, model, hourStart), bucket);
+    bucketMap.set(bucketKey(source, hourStart), bucket);
     linesRead += 1;
     if (linesRead >= maxBuckets) break;
   }
@@ -97,8 +97,8 @@ async function safeFileSize(p) {
   }
 }
 
-function bucketKey(source, model, hourStart) {
-  return `${source}${BUCKET_SEPARATOR}${model}${BUCKET_SEPARATOR}${hourStart}`;
+function bucketKey(source, hourStart) {
+  return `${source}${BUCKET_SEPARATOR}${hourStart}`;
 }
 
 function normalizeSource(value) {