@vibe-cafe/vibe-usage 0.9.10 → 0.9.12

package/README.md

@@ -51,7 +51,7 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 | Tool | Data Location |
 |------|---------------|
 | Claude Code | `~/.claude/projects/` (tokens + sessions), `~/.claude/transcripts/` (sessions only); also scans `$CLAUDE_CONFIG_DIR` when set (deduped), so relocated configs and GUI/CLI env mismatches are both covered |
-| Codex CLI | `~/.codex/sessions/` and `~/.codex/archived_sessions/` |
+| Codex CLI | `$CODEX_HOME/sessions/` and `$CODEX_HOME/archived_sessions/` (default `~/.codex`); forked and sub-agent rollouts replay the parent conversation's `token_count` records at spawn time — those are skipped (fork: by source session's record count; sub-agent: everything before its own first `task_started`), and duplicate `token_count` emissions with an unchanged cumulative total count once |
 | GitHub Copilot CLI | `~/.copilot/session-state/*/events.jsonl` |
 | Cursor | `state.vscdb` (SQLite, reads `cursorAuth/accessToken`, fetches CSV from `cursor.com`); cloud data is stamped with a fixed `cursor-cloud` hostname so multi-machine setups don't double-count |
 | Gemini CLI | `~/.gemini/tmp/<project_hash>/chats/session-*.jsonl` (current line-delimited format) and legacy `session-*.json`; recurses into nested subagent sessions |
@@ -66,7 +66,8 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 | Kiro | Kiro CLI native event streams `~/.kiro/sessions/cli/*.jsonl` (estimated tokens from message text: input = prompt + tool results, output = reply + tool calls, reasoning = thinking, cacheRead = re-sent context; thinking-block signatures excluded). Falls back to `~/Library/Application Support/kiro-cli/data.sqlite3` / `~/.local/share/kiro-cli/data.sqlite3` + optional `~/.kiro_sessions/*.json` archives, then IDE `q-client.log` whole-credit deltas as `kiro-credits` (floored cumulative diff — the server stores token counts as bigint); legacy IDE `dev_data/devdata.sqlite` token telemetry is opt-in with `VIBE_USAGE_KIRO_LEGACY_TOKENS=1` |
 | Cline | `<host>/User/globalStorage/saoudrizwan.claude-dev/{state/taskHistory.json,tasks/<id>/ui_messages.json}` (walks all VSCode-fork hosts: Code, Cursor, Windsurf, VSCodium, Trae, ...) |
 | Roo Code | `<host>/User/globalStorage/rooveterinaryinc.roo-cline/{tasks/_index.json,tasks/<id>/{history_item,ui_messages}.json}` (walks all VSCode-fork hosts) |
-| Antigravity | `~/.gemini/antigravity/conversations/*.pb` / `*.db` to discover cascades, then reads token usage + sessions from the running language server via Connect RPC (process discovered with `ps`/`lsof` on macOS/Linux, PowerShell CIM with a `wmic` fallback on Windows) |
+| Trae CLI | macOS: `~/Library/Caches/trae-cli/sessions/`; Windows: `%LOCALAPPDATA%/trae-cli/cache/sessions/`; Linux: `~/.cache/trae-cli/sessions/` (CLI telemetry only; Trae IDE/Trae Work chats are not supported) |
+| Antigravity | App 2.0 `~/.gemini/antigravity/conversations/*.db` and `agy` CLI `~/.gemini/antigravity-cli/conversations/*.db` are parsed offline (tokens, real model display name, project, sessions); legacy App `.pb` history falls back to Connect RPC while the language server is running |
 | ZCode | `~/.zcode/cli/db/db.sqlite` (SQLite; reads the `message` table for per-message tokens, model, and project `cwd`/`root`, joined to `session.directory`) |
 
 ## How It Works

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-cafe/vibe-usage",
-  "version": "0.9.10",
+  "version": "0.9.12",
   "description": "Track your AI coding tool token usage and sync to vibecafe.ai",
   "type": "module",
   "scripts": {

package/src/parsers/antigravity-db.js

@@ -0,0 +1,307 @@
+import { copyFileSync, existsSync, mkdtempSync, readdirSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { queryDbJson } from './sqlite.js';
+
+/**
+ * Offline reader for Antigravity SQLite conversation stores.
+ *
+ * Antigravity 2.0 (standalone app) and the `agy` CLI both persist each cascade
+ * as a per-conversation SQLite `.db` file whose `gen_metadata` table holds one
+ * protobuf-encoded GeneratorMetadata per row. Unlike the legacy `.pb` files
+ * (which are encrypted/opaque and only decodable by a running language server),
+ * these blobs are plain protobuf, so we can extract token usage directly from
+ * disk — no running process, no RPC.
+ *
+ * The wire-format tag numbers below were cross-verified against the language
+ * server's GetCascadeTrajectory JSON for the same responseId:
+ *
+ *   chatModel = field 1
+ *     usage = field 4
+ *       inputTokens          = 4.2
+ *       outputTokens         = 4.3
+ *       cacheReadTokens      = 4.5
+ *       thinkingOutputTokens = 4.9
+ *       responseId           = 4.11
+ *     chatStartMetadata = field 9
+ *       createdAt (Timestamp) = 9.4  → seconds = 9.4.1
+ *     responseModel      = field 19  ("gemini-3-flash-a" / "gemini-default")
+ *     modelDisplayName   = field 21  ("Gemini 3.5 Flash (High/Medium/Low)")
+ */
+
+// ── Minimal protobuf wire-format decoder (no dependency) ──────────────
+
+/** Read a base-128 varint. Returns [value: number, newPos]. */
+function readVarint(buf, pos) {
+  let result = 0n;
+  let shift = 0n;
+  while (pos < buf.length) {
+    const byte = buf[pos++];
+    result |= BigInt(byte & 0x7f) << shift;
+    if ((byte & 0x80) === 0) break;
+    shift += 7n;
+  }
+  return [Number(result), pos];
+}
+
+/**
+ * Decode one protobuf message into Map<fieldNumber, Array<{wireType, value}>>.
+ * Length-delimited values are kept as raw Buffers (caller decides string vs
+ * sub-message). Unknown wire types abort parsing of the rest of the message.
+ */
+function decodeMessage(buf) {
+  const fields = new Map();
+  let pos = 0;
+  while (pos < buf.length) {
+    let tag;
+    [tag, pos] = readVarint(buf, pos);
+    const fieldNum = tag >> 3;
+    const wireType = tag & 0x7;
+    let value;
+    if (wireType === 0) {
+      [value, pos] = readVarint(buf, pos);
+    } else if (wireType === 2) {
+      let len;
+      [len, pos] = readVarint(buf, pos);
+      value = buf.subarray(pos, pos + len);
+      pos += len;
+    } else if (wireType === 5) {
+      value = buf.subarray(pos, pos + 4);
+      pos += 4;
+    } else if (wireType === 1) {
+      value = buf.subarray(pos, pos + 8);
+      pos += 8;
+    } else {
+      break; // group/unknown — stop
+    }
+    if (!fields.has(fieldNum)) fields.set(fieldNum, []);
+    fields.get(fieldNum).push({ wireType, value });
+  }
+  return fields;
+}
+
+function firstVarint(fields, num) {
+  const arr = fields.get(num);
+  const e = arr && arr.find((x) => x.wireType === 0);
+  return e ? e.value : undefined;
+}
+
+function firstBytes(fields, num) {
+  const arr = fields.get(num);
+  const e = arr && arr.find((x) => x.wireType === 2);
+  return e ? e.value : undefined;
+}
+
+function firstString(fields, num) {
+  const b = firstBytes(fields, num);
+  return b ? Buffer.from(b).toString('utf-8') : undefined;
+}
+
+function firstMessage(fields, num) {
+  const b = firstBytes(fields, num);
+  return b ? decodeMessage(b) : undefined;
+}
+
+// ── GeneratorMetadata parsing ─────────────────────────────────────────
+
+/**
+ * Parse one gen_metadata blob into a normalized usage record, or null if it
+ * carries no token usage (error/planning placeholders have none).
+ *
+ * @param {Buffer} buf raw protobuf bytes of a GeneratorMetadata row
+ * @returns {{inputTokens, outputTokens, cacheReadTokens, thinkingOutputTokens,
+ *            responseId, timestamp: Date|null, displayName, responseModel}|null}
+ */
+export function parseGenMetadataBlob(buf) {
+  const chatModel = firstMessage(decodeMessage(buf), 1);
+  if (!chatModel) return null;
+
+  const usage = firstMessage(chatModel, 4);
+  if (!usage) return null;
+
+  const inputTokens = firstVarint(usage, 2) || 0;
+  const outputTokens = firstVarint(usage, 3) || 0;
+  const cacheReadTokens = firstVarint(usage, 5) || 0;
+  const thinkingOutputTokens = firstVarint(usage, 9) || 0;
+  const responseId = firstString(usage, 11) || '';
+
+  // Skip rows with no real usage (errors, planning-only steps).
+  if (!inputTokens && !outputTokens && !cacheReadTokens && !thinkingOutputTokens) {
+    return null;
+  }
+
+  const chatStartMetadata = firstMessage(chatModel, 9);
+  const createdAt = chatStartMetadata ? firstMessage(chatStartMetadata, 4) : undefined;
+  const seconds = createdAt ? firstVarint(createdAt, 1) : undefined;
+  const timestamp = seconds ? new Date(seconds * 1000) : null;
+
+  return {
+    inputTokens,
+    outputTokens,
+    cacheReadTokens,
+    thinkingOutputTokens,
+    responseId,
+    timestamp,
+    displayName: firstString(chatModel, 21) || '',
+    responseModel: firstString(chatModel, 19) || '',
+  };
+}
+
+// ── SQLite store reading ──────────────────────────────────────────────
+
+function isLockError(err) {
+  return err && typeof err.message === 'string' && /database is locked/i.test(err.message);
+}
+
+function isSqliteUnavailableError(err) {
+  return err && typeof err.message === 'string' && /ENOENT|sqlite3.*not found/i.test(err.message);
+}
+
+function queryCascadeDb(conversationsDir, cascadeId, sql) {
+  const dbPath = join(conversationsDir, `${cascadeId}.db`);
+  try {
+    return queryDbJson(dbPath, sql);
+  } catch (err) {
+    if (isSqliteUnavailableError(err)) {
+      throw new Error('sqlite3 CLI not found. Install sqlite3 (or use Node >= 22.5) to sync Antigravity data.');
+    }
+    if (!isLockError(err)) throw err;
+
+    // The App can hold the live DB open. Query a WAL-consistent snapshot so
+    // one active cascade does not make the whole Antigravity parser go empty.
+    const snapshotDir = mkdtempSync(join(tmpdir(), 'vibe-usage-antigravity-'));
+    const snapshotPath = join(snapshotDir, `${cascadeId}.db`);
+    try {
+      copyFileSync(dbPath, snapshotPath);
+      for (const suffix of ['-shm', '-wal']) {
+        const companion = `${dbPath}${suffix}`;
+        if (existsSync(companion)) copyFileSync(companion, `${snapshotPath}${suffix}`);
+      }
+      return queryDbJson(snapshotPath, sql);
+    } finally {
+      rmSync(snapshotDir, { recursive: true, force: true });
+    }
+  }
+}
+
+/** List cascade IDs backed by a `.db` file in a conversations directory. */
+export function listDbCascades(conversationsDir) {
+  try {
+    const out = [];
+    for (const f of readdirSync(conversationsDir)) {
+      if (f.endsWith('.db') && f !== 'db.sqlite') out.push(f.slice(0, -3));
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Read all gen_metadata blobs from one cascade `.db` and return parsed usage
+ * records. blob is fetched as hex text so it round-trips through both the
+ * node:sqlite and sqlite3-CLI backends uniformly.
+ */
+export function readDbUsageRecords(conversationsDir, cascadeId) {
+  let rows;
+  try {
+    rows = queryCascadeDb(conversationsDir, cascadeId, 'SELECT hex(data) AS h FROM gen_metadata ORDER BY idx');
+  } catch (err) {
+    if (isSqliteUnavailableError(err)) throw err;
+    return [];
+  }
+  const records = [];
+  for (const row of rows) {
+    if (!row.h) continue;
+    let rec;
+    try {
+      rec = parseGenMetadataBlob(Buffer.from(row.h, 'hex'));
+    } catch {
+      continue; // one malformed blob must not kill the rest
+    }
+    if (rec) records.push(rec);
+  }
+  return records;
+}
+
+/**
+ * Read the workspace URI for a cascade from trajectory_metadata_blob.
+ * Structure: field 1 = workspaces[0], 1.1 = workspaceFolderAbsoluteUri.
+ * Returns the raw file:// URI, or null.
+ */
+export function readDbWorkspaceUri(conversationsDir, cascadeId) {
+  let rows;
+  try {
+    rows = queryCascadeDb(conversationsDir, cascadeId, 'SELECT hex(data) AS h FROM trajectory_metadata_blob LIMIT 1');
+  } catch (err) {
+    if (isSqliteUnavailableError(err)) throw err;
+    return null;
+  }
+  if (!rows.length || !rows[0].h) return null;
+  try {
+    const meta = decodeMessage(Buffer.from(rows[0].h, 'hex'));
+    const ws0 = firstMessage(meta, 1);
+    return (ws0 && firstString(ws0, 1)) || null;
+  } catch {
+    return null;
+  }
+}
+
+// Step source enum in steps.metadata field 3 (behavior-verified against payload
+// contents, since it mirrors the RPC's CORTEX_STEP_SOURCE_*): 4 = user turn,
+// 2 = model turn. Everything else (system, tool, unspecified) is skipped.
+const STEP_SOURCE_USER = 4;
+const STEP_SOURCE_MODEL = 2;
+
+/**
+ * Parse one steps.metadata blob into a session-timing event, or null if the
+ * step is neither a user nor a model turn (system/tool/unspecified). createdAt
+ * is a Timestamp at field 1 (seconds at 1.1); source enum is field 3.
+ *
+ * @param {Buffer} buf
+ * @returns {{role:'user'|'assistant', timestamp: Date}|null}
+ */
+export function parseStepMetadata(buf) {
+  const meta = decodeMessage(buf);
+  const source = firstVarint(meta, 3);
+  let role;
+  if (source === STEP_SOURCE_USER) role = 'user';
+  else if (source === STEP_SOURCE_MODEL) role = 'assistant';
+  else return null;
+
+  const createdAt = firstMessage(meta, 1);
+  const seconds = createdAt ? firstVarint(createdAt, 1) : undefined;
+  if (!seconds) return null;
+
+  return { role, timestamp: new Date(seconds * 1000) };
+}
+
+/**
+ * Read session timing events (user/assistant turns) for a cascade from the
+ * steps table, chronological by idx.
+ */
+export function readDbSessionEvents(conversationsDir, cascadeId) {
+  let rows;
+  try {
+    rows = queryCascadeDb(
+      conversationsDir,
+      cascadeId,
+      'SELECT hex(metadata) AS h FROM steps WHERE metadata IS NOT NULL ORDER BY idx',
+    );
+  } catch (err) {
+    if (isSqliteUnavailableError(err)) throw err;
+    return [];
+  }
+  const events = [];
+  for (const row of rows) {
+    if (!row.h) continue;
+    let ev;
+    try {
+      ev = parseStepMetadata(Buffer.from(row.h, 'hex'));
+    } catch {
+      continue;
+    }
+    if (ev) events.push(ev);
+  }
+  return events;
+}

package/src/parsers/antigravity.js

@@ -3,18 +3,25 @@ import { readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { aggregateToBuckets, extractSessions } from './index.js';
+import { listDbCascades, readDbUsageRecords, readDbWorkspaceUri, readDbSessionEvents } from './antigravity-db.js';
 
 
 
 /**
- * Antigravity parser (file-based).
- * Scans .pb/.db files in ~/.gemini/antigravity/conversations/ to discover cascade IDs.
- * Calls GetCascadeTrajectory via a running language server to extract token usage
- * (from generatorMetadata) and session events (from trajectory steps).
+ * Antigravity parser.
+ *
+ * Two conversation stores, two read paths:
+ *  - `.db` cascades (App 2.0 + `agy` CLI): plain-protobuf SQLite, parsed offline
+ *    from disk — no running process required (see antigravity-db.js).
+ *  - `.pb` cascades (legacy App history): encrypted/opaque, only decodable via a
+ *    running language server's GetCascadeTrajectory RPC (fallback below).
+ * A cascade backed by a `.db` never uses RPC, so the two paths never double-count.
  */
 
 const SOURCE = 'antigravity';
 const CONVERSATIONS_DIR = join(homedir(), '.gemini', 'antigravity', 'conversations');
+// `agy` CLI stores conversations in a separate, App-independent directory.
+const CLI_CONVERSATIONS_DIR = join(homedir(), '.gemini', 'antigravity-cli', 'conversations');
 
 // User sources → role 'user'; Model source → role 'assistant'; System sources → skip
 const USER_SOURCES = new Set([
@@ -221,12 +228,14 @@ async function probeHttpPort(ports, csrfToken) {
 /**
  * Normalize model names to canonical forms.
  */
+// Normalize model names to canonical forms. NOTE: only legacy .pb data (which
+// exposes bare slugs via responseModel) reaches this; .db data uses the
+// human-readable modelDisplayName verbatim (e.g. "Gemini 3.5 Flash (High)"),
+// which is never normalized. Flash reasoning tiers (-a/-b/-c) are intentionally
+// NOT merged: each tier is a distinct choice and left as-is ("as it is").
 const MODEL_NORMALIZE_MAP = {
   'claude-opus-4-6-thinking': 'claude-opus-4-6',
   'claude-sonnet-4-6-thinking': 'claude-sonnet-4-6',
-  'gemini-3-flash-a': 'gemini-3-flash',
-  'gemini-3-flash-b': 'gemini-3-flash',
-  'gemini-3-flash-c': 'gemini-3-flash',
   "gemini-3.1-pro-high": "gemini-3.1-pro",
   "gemini-3.1-pro-low": "gemini-3.1-pro",
   "gemini-3-pro-high": "gemini-3-pro",
@@ -244,10 +253,6 @@ const PLACEHOLDER_MODEL_MAP = {
   'MODEL_PLACEHOLDER_M35': 'claude-sonnet-4-6',
   'MODEL_PLACEHOLDER_M26': 'claude-opus-4-6',
   'MODEL_OPENAI_GPT_OSS_120B_MEDIUM': 'gpt-oss-120b',
-  // Antigravity 2.0+ standalone app placeholders (verified via responseModel)
-  'MODEL_PLACEHOLDER_M132': 'gemini-3-flash',
-  'MODEL_PLACEHOLDER_M133': 'gemini-3-flash',
-  'MODEL_PLACEHOLDER_M20': 'gemini-3-flash',
 };
 
 function normalizeModel(raw) {
@@ -255,9 +260,16 @@ function normalizeModel(raw) {
 }
 
 /**
- * Resolve model name: prefer responseModel, fall back to placeholder map.
+ * Resolve a display model name from a chatModel-like object.
+ * Priority: modelDisplayName (real name, e.g. "Gemini 3.5 Flash (High)") →
+ * responseModel slug (normalized) → placeholder map → "unknown".
+ *
+ * modelDisplayName is present on .db data (App 2.0 + CLI) and is authoritative;
+ * it is used verbatim (carries the reasoning tier). Legacy .pb data has no
+ * display name, so it falls back to the responseModel slug.
  */
 function resolveModel(chatModel) {
+  if (chatModel.modelDisplayName) return chatModel.modelDisplayName;
   if (chatModel.responseModel) return normalizeModel(chatModel.responseModel);
   const placeholder = chatModel.model || '';
   if (PLACEHOLDER_MODEL_MAP[placeholder]) return PLACEHOLDER_MODEL_MAP[placeholder];
@@ -280,21 +292,16 @@ function projectFromUri(uri) {
 }
 
 /**
- * List cascade IDs from .pb and .db files in the conversations directory.
- * Antigravity 2.0+ stores new conversations as SQLite .db files instead of .pb.
+ * List cascade IDs backed by a legacy `.pb` file (App history). `.db` cascades
+ * are handled separately via offline parsing.
  */
-function listCascades() {
+function listPbCascades() {
   try {
-    const files = readdirSync(CONVERSATIONS_DIR);
-    const seen = new Set();
-    for (const f of files) {
-      // SQLite auxiliaries (foo.db-wal / foo.db-shm) don't end with .db, so no
-      // extra filtering is needed here.
-      if (f.endsWith('.pb') || f.endsWith('.db')) {
-        seen.add(f.slice(0, -3));
-      }
+    const out = [];
+    for (const f of readdirSync(CONVERSATIONS_DIR)) {
+      if (f.endsWith('.pb')) out.push(f.slice(0, -3));
     }
-    return [...seen];
+    return out;
   } catch {
     return [];
   }
@@ -302,113 +309,133 @@ function listCascades() {
 
 // ── Main parse ───────────────────────────────────────────────────────
 
-export async function parse() {
-  // Step 1: List cascade conversation files (.pb / .db)
-  const cascadeIds = listCascades();
-  if (cascadeIds.length === 0) return { buckets: [], sessions: [] };
-
-  // Step 2: Find a running language server to make RPC calls
-  const server = findLanguageServer();
-  if (!server) return { buckets: [], sessions: [] };
-
-  const ports = findListeningPorts(server.pid);
-  if (ports.length === 0) return { buckets: [], sessions: [] };
-
-  const baseUrl = await probeHttpPort(ports, server.csrfToken);
-  if (!baseUrl) return { buckets: [], sessions: [] };
-
-  const rpc = (method, body) =>
-    rpcPost(
-      baseUrl,
-      `/exa.language_server_pb.LanguageServerService/${method}`,
-      body,
-      server.csrfToken,
-    );
+/** Model name for an offline .db record: real display name → slug → unknown. */
+function modelFromRecord(rec) {
+  if (rec.displayName) return rec.displayName;
+  if (rec.responseModel) return normalizeModel(rec.responseModel);
+  return 'unknown';
+}
 
-  // Step 3: Fetch trajectory for each changed cascade
+export async function parse() {
   const entries = [];
   const sessionEvents = [];
   const seenResponseIds = new Set();
 
-  for (const cascadeId of cascadeIds) {
-    let resp;
-    try {
-      resp = await rpc('GetCascadeTrajectory', { cascadeId });
-    } catch {
-      continue; // skip this cascade if RPC fails
-    }
-
-    const trajectory = resp?.trajectory;
-    if (!trajectory) continue;
-
-    const steps = trajectory.steps || [];
-    const metadataList = trajectory.generatorMetadata || [];
-
-
-    // Extract project from trajectory metadata workspaces
-    let project = 'unknown';
-    const workspaces = trajectory.metadata?.workspaces || [];
-    if (workspaces.length > 0) {
-      project = workspaces[0].repository?.computedName || projectFromUri(workspaces[0].workspaceFolderAbsoluteUri) || 'unknown';
-    }
-
-    // ── Token entries from generatorMetadata ──
-    for (const meta of metadataList) {
-      const chatModel = meta?.chatModel;
-      if (!chatModel) continue;
-
-      const responseModel = resolveModel(chatModel);
-      const createdAt = chatModel?.chatStartMetadata?.createdAt;
-      const ts = createdAt ? new Date(createdAt) : null;
-      if (!ts || isNaN(ts.getTime())) continue;
-
-      const retryInfos = chatModel.retryInfos || [];
-      for (const retry of retryInfos) {
-        const usage = retry.usage;
-        if (!usage) continue;
-
-        const responseId = usage.responseId || '';
-        if (responseId && seenResponseIds.has(responseId)) continue;
-        if (responseId) seenResponseIds.add(responseId);
+  // ── Path 1: offline .db parsing (App 2.0 + agy CLI, no process needed) ──
+  const dbHandled = new Set();
+  for (const dir of [CONVERSATIONS_DIR, CLI_CONVERSATIONS_DIR]) {
+    for (const cascadeId of listDbCascades(dir)) {
+      const records = readDbUsageRecords(dir, cascadeId);
+      const project = projectFromUri(readDbWorkspaceUri(dir, cascadeId)) || 'unknown';
+
+      if (records.length > 0) {
+        dbHandled.add(cascadeId);
+        for (const rec of records) {
+          if (rec.responseId && seenResponseIds.has(rec.responseId)) continue;
+          if (rec.responseId) seenResponseIds.add(rec.responseId);
+          if (!rec.timestamp || isNaN(rec.timestamp.getTime())) continue;
+          entries.push({
+            source: SOURCE,
+            model: modelFromRecord(rec),
+            project,
+            timestamp: rec.timestamp,
+            inputTokens: toSafeNumber(rec.inputTokens),
+            outputTokens: toSafeNumber(rec.outputTokens),
+            cachedInputTokens: toSafeNumber(rec.cacheReadTokens),
+            reasoningOutputTokens: toSafeNumber(rec.thinkingOutputTokens),
+          });
+        }
+      }
 
-        entries.push({
+      // Session timing from steps (independent of token usage presence).
+      for (const ev of readDbSessionEvents(dir, cascadeId)) {
+        sessionEvents.push({
+          sessionId: cascadeId,
           source: SOURCE,
-          model: responseModel,
           project,
-          timestamp: ts,
-          inputTokens: toSafeNumber(usage.inputTokens),
-          outputTokens: toSafeNumber(usage.outputTokens),
-          cachedInputTokens: toSafeNumber(usage.cacheReadTokens),
-          reasoningOutputTokens: toSafeNumber(usage.thinkingOutputTokens),
+          timestamp: ev.timestamp,
+          role: ev.role,
         });
       }
     }
+  }
 
-    // ── Session events from trajectory steps ──
-    for (const step of steps) {
-      const stepSource = step?.metadata?.source || '';
-      let role;
-      if (USER_SOURCES.has(stepSource)) {
-        role = 'user';
-      } else if (ASSISTANT_SOURCES.has(stepSource)) {
-        role = 'assistant';
-      } else {
-        continue; // skip SYSTEM / SYSTEM_SDK / UNSPECIFIED
+  // ── Path 2: RPC fallback, only for legacy .pb cascades not already parsed ──
+  const pbCascades = listPbCascades().filter((id) => !dbHandled.has(id));
+  if (pbCascades.length > 0) {
+    const server = findLanguageServer();
+    const ports = server ? findListeningPorts(server.pid) : [];
+    const baseUrl = ports.length > 0 ? await probeHttpPort(ports, server.csrfToken) : null;
+    if (baseUrl) {
+      const rpc = (method, body) =>
+        rpcPost(
+          baseUrl,
+          `/exa.language_server_pb.LanguageServerService/${method}`,
+          body,
+          server.csrfToken,
+        );
+
+      for (const cascadeId of pbCascades) {
+        let resp;
+        try {
+          resp = await rpc('GetCascadeTrajectory', { cascadeId });
+        } catch {
+          continue;
+        }
+        const trajectory = resp?.trajectory;
+        if (!trajectory) continue;
+
+        const steps = trajectory.steps || [];
+        const metadataList = trajectory.generatorMetadata || [];
+
+        let project = 'unknown';
+        const workspaces = trajectory.metadata?.workspaces || [];
+        if (workspaces.length > 0) {
+          project = workspaces[0].repository?.computedName
+            || projectFromUri(workspaces[0].workspaceFolderAbsoluteUri)
+            || 'unknown';
+        }
+
+        for (const meta of metadataList) {
+          const chatModel = meta?.chatModel;
+          if (!chatModel) continue;
+          const model = resolveModel(chatModel);
+          const createdAt = chatModel?.chatStartMetadata?.createdAt;
+          const ts = createdAt ? new Date(createdAt) : null;
+          if (!ts || isNaN(ts.getTime())) continue;
+
+          for (const retry of (chatModel.retryInfos || [])) {
+            const usage = retry.usage;
+            if (!usage) continue;
+            const responseId = usage.responseId || '';
+            if (responseId && seenResponseIds.has(responseId)) continue;
+            if (responseId) seenResponseIds.add(responseId);
+            entries.push({
+              source: SOURCE,
+              model,
+              project,
+              timestamp: ts,
+              inputTokens: toSafeNumber(usage.inputTokens),
+              outputTokens: toSafeNumber(usage.outputTokens),
+              cachedInputTokens: toSafeNumber(usage.cacheReadTokens),
+              reasoningOutputTokens: toSafeNumber(usage.thinkingOutputTokens),
+            });
+          }
+        }
+
+        for (const step of steps) {
+          const stepSource = step?.metadata?.source || '';
+          let role;
+          if (USER_SOURCES.has(stepSource)) role = 'user';
+          else if (ASSISTANT_SOURCES.has(stepSource)) role = 'assistant';
+          else continue;
+          const createdAt = step?.metadata?.createdAt;
+          const ts = createdAt ? new Date(createdAt) : null;
+          if (!ts || isNaN(ts.getTime())) continue;
+          sessionEvents.push({ sessionId: cascadeId, source: SOURCE, project, timestamp: ts, role });
+        }
       }
-
-      const createdAt = step?.metadata?.createdAt;
-      const ts = createdAt ? new Date(createdAt) : null;
-      if (!ts || isNaN(ts.getTime())) continue;
-
-      sessionEvents.push({
-        sessionId: cascadeId,
-        source: SOURCE,
-        project,
-        timestamp: ts,
-        role,
-      });
     }
-
   }
 
   return {

package/src/parsers/codex.js

@@ -4,18 +4,22 @@ import { homedir } from 'node:os';
 import { createInterface } from 'node:readline';
 import { aggregateToBuckets, extractSessions } from './index.js';
 
-// Codex stores live sessions in ~/.codex/sessions and, once a session is
-// "completed", moves its rollout file verbatim into ~/.codex/archived_sessions.
-// A session can be archived between two syncs, so scanning only the live dir
-// loses that session's usage forever. We scan both: the parser is stateless
-// and the server dedups on (source, sessionHash/bucket), so re-reading an
-// archived file that was already synced from sessions/ is idempotent. Indexing
-// both together also keeps fork replay-skip correct when a fork and its parent
-// end up split across the two directories.
-const SESSIONS_DIRS = [
-  join(homedir(), '.codex', 'sessions'),
-  join(homedir(), '.codex', 'archived_sessions'),
-];
+// Codex stores live sessions in $CODEX_HOME/sessions (default ~/.codex) and,
+// once a session is "completed", moves its rollout file verbatim into
+// $CODEX_HOME/archived_sessions. A session can be archived between two syncs,
+// so scanning only the live dir loses that session's usage forever. We scan
+// both: the parser is stateless and the server dedups on
+// (source, sessionHash/bucket), so re-reading an archived file that was
+// already synced from sessions/ is idempotent. Indexing both together also
+// keeps fork replay-skip correct when a fork and its parent end up split
+// across the two directories.
+function sessionsDirs() {
+  const codexHome = process.env.CODEX_HOME?.trim() || join(homedir(), '.codex');
+  return [
+    join(codexHome, 'sessions'),
+    join(codexHome, 'archived_sessions'),
+  ];
+}
 
 /**
  * Recursively find all .jsonl files under a directory.
@@ -56,9 +60,24 @@ function extractProject(meta) {
   return 'unknown';
 }
 
+/**
+ * A sub-agent rollout (spawned thread / guardian / collab agent). Depending
+ * on the Codex version the marker is `thread_source: "subagent"`, a
+ * `source: { subagent: {...} }` object, or just a `parent_thread_id` — check
+ * all three so no version's sub-agents slip through as normal sessions.
+ */
+function isSubagentMeta(meta) {
+  if (meta.thread_source === 'subagent') return true;
+  const src = meta.source;
+  if (src === 'subagent') return true;
+  if (src && typeof src === 'object' && 'subagent' in src) return true;
+  return meta.parent_thread_id != null;
+}
+
 /**
  * Stream a session file once and extract its index metadata: the session
- * id, the forked-from id, the project name, and the total count of
+ * id, the forked-from id, the project name, whether it is a sub-agent
+ * rollout (and contains a task_started boundary), and the total count of
  * `event_msg/token_count` records. The token_count total is used to size
  * the replayed-history block of a forked session — a fork copies the
  * original conversation verbatim, so it begins with exactly as many
@@ -69,6 +88,8 @@ async function indexSessionFile(filePath) {
   let forkedFromId = null;
   let sessionProject = 'unknown';
   let tokenCountRecords = 0;
+  let isSubagent = false;
+  let hasTaskStarted = false;
 
   for await (const line of readLines(filePath)) {
     if (!line.trim()) continue;
@@ -78,24 +99,28 @@ async function indexSessionFile(filePath) {
         const meta = obj.payload;
         sessionId = meta.id || sessionId;
         forkedFromId = meta.forked_from_id || null;
+        isSubagent = isSubagentMeta(meta);
         sessionProject = extractProject(meta);
       } else if (obj.type === 'event_msg' && obj.payload?.type === 'token_count') {
         tokenCountRecords++;
+      } else if (obj.type === 'event_msg' && obj.payload?.type === 'task_started') {
+        hasTaskStarted = true;
       }
     } catch {
       continue;
     }
   }
 
-  return { sessionId, forkedFromId, sessionProject, tokenCountRecords };
+  return { sessionId, forkedFromId, sessionProject, tokenCountRecords, isSubagent, hasTaskStarted };
 }
 
 export async function parse() {
-  if (!SESSIONS_DIRS.some(existsSync)) return { buckets: [], sessions: [] };
+  const dirs = sessionsDirs();
+  if (!dirs.some(existsSync)) return { buckets: [], sessions: [] };
 
   const entries = [];
   const sessionEvents = [];
-  const files = SESSIONS_DIRS.flatMap(findJsonlFiles);
+  const files = dirs.flatMap(findJsonlFiles);
   if (files.length === 0) return { buckets: [], sessions: [] };
 
   // Pass 1: index every session by its UUID and count its token_count
@@ -144,6 +169,19 @@ export async function parse() {
     }
     let tokenCountSeen = 0;
 
+    // Sub-agent rollouts can begin with the parent session's history copied
+    // in — including its token_count records — all re-stamped at the spawn
+    // instant. Those tokens are already counted from the parent's own file,
+    // so re-counting them here double-counts usage and produces a huge
+    // spurious spike at spawn time (observed 20×+). Unlike forks there is no
+    // forked_from_id/count to size the block by, but the copied history ends
+    // at the sub-agent's own first task_started event, so skip everything
+    // before it. If the file has no task_started at all (unknown/legacy
+    // format) we can't locate the boundary; skip nothing so incomplete data
+    // over-counts rather than silently dropping real usage.
+    const skipUntilTaskStarted = fm.isSubagent && fm.hasTaskStarted;
+    let taskStartedSeen = false;
+
     const sessionProject = fm.sessionProject;
     // Group timing events by the real Codex session id, not the file path: the
     // same session can briefly exist in both sessions/ and archived_sessions/
@@ -154,6 +192,7 @@ export async function parse() {
 
     let turnContextModel = 'unknown';
     const prevTotal = new Map();
+    let prevCumulativeTotal = null;
     for await (const line of readLines(filePath)) {
       if (!line.trim()) continue;
       try {
@@ -167,14 +206,23 @@ export async function parse() {
         // edge — the new conversation's events come strictly after it.)
         const inReplayBlock = tokenCountSeen < replayTokenCountToSkip;
 
+        // The task_started event itself belongs to the sub-agent — it marks
+        // the start of its own first turn — so flip the flag before deciding
+        // whether this record is inherited.
+        if (skipUntilTaskStarted && !taskStartedSeen
+            && obj.type === 'event_msg' && obj.payload?.type === 'task_started') {
+          taskStartedSeen = true;
+        }
+        const inInheritedBlock = skipUntilTaskStarted && !taskStartedSeen;
+
         if (obj.timestamp) {
           const evTs = new Date(obj.timestamp);
           if (!isNaN(evTs.getTime())) {
-            // Skip replayed history events so a forked session's
-            // duration/active-time/message counts reflect only the new
-            // conversation, not the copied original. session_meta itself is
-            // kept: it marks when the fork actually started.
-            const isReplay = inReplayBlock && obj.type !== 'session_meta';
+            // Skip replayed/inherited history events so a forked or sub-agent
+            // session's duration/active-time/message counts reflect only the
+            // new conversation, not the copied original. session_meta itself
+            // is kept: it marks when the fork/sub-agent actually started.
+            const isReplay = (inReplayBlock || inInheritedBlock) && obj.type !== 'session_meta';
             if (!isReplay) {
               const isUserTurn = obj.type === 'turn_context' || obj.type === 'session_meta';
               sessionEvents.push({
@@ -207,13 +255,27 @@ export async function parse() {
         if (!timestamp || isNaN(timestamp.getTime())) continue;
 
         // This is the (tokenCountSeen+1)-th token_count in the file. If it
-        // falls inside the fork's replay block it's an exact copy of a record
-        // already counted from the source session's own file — skip it (but
-        // still advance the cumulative-total baseline below so the first real
-        // post-fork delta is measured correctly).
-        const isReplayedHistory = tokenCountSeen < replayTokenCountToSkip;
+        // falls inside the fork's replay block or a sub-agent's inherited
+        // block it's an exact copy of a record already counted from the
+        // source session's own file — skip it (but still advance the
+        // cumulative-total baselines below so the first real delta after the
+        // copied history is measured correctly).
+        const isReplayedHistory = tokenCountSeen < replayTokenCountToSkip || inInheritedBlock;
         tokenCountSeen++;
 
+        // Codex sometimes writes the same token_count twice back-to-back:
+        // identical last_token_usage with an unchanged cumulative total. A
+        // real API call always advances the cumulative counter (its input
+        // tokens alone are non-zero), so an unchanged positive total marks a
+        // duplicate emission — or a zero-usage bookkeeping event such as
+        // compaction — and must count as zero, not a second copy of
+        // last_token_usage. Guarded to positive totals so builds that leave
+        // total_token_usage all-zero can't suppress real usage.
+        const cumulativeTotal = info.total_token_usage?.total_tokens;
+        const isDuplicateEmission = typeof cumulativeTotal === 'number'
+          && cumulativeTotal > 0 && cumulativeTotal === prevCumulativeTotal;
+        if (typeof cumulativeTotal === 'number') prevCumulativeTotal = cumulativeTotal;
+
         // Prefer incremental per-request usage; compute delta from cumulative total as fallback
         let usage = info.last_token_usage;
         if (!usage && info.total_token_usage) {
@@ -237,7 +299,7 @@ export async function parse() {
           prevTotal.set(totalKey, { ...curr });
         }
         if (!usage) continue;
-        if (isReplayedHistory) continue;
+        if (isReplayedHistory || isDuplicateEmission) continue;
 
         const model = info.model || payload.model || turnContextModel || 'unknown';
 

package/src/parsers/index.js

@@ -17,6 +17,7 @@ import { parse as parseHermes } from './hermes.js';
 import { parse as parseKiro } from './kiro.js';
 import { parse as parsePiCodingAgent } from './pi-coding-agent.js';
 import { parse as parseZcode } from './zcode.js';
+import { parse as parseTraeCli } from './trae-cli.js';
 
 export const parsers = {
   'claude-code': parseClaudeCode,
@@ -37,6 +38,7 @@ export const parsers = {
   'kiro': parseKiro,
   'pi-coding-agent': parsePiCodingAgent,
   'zcode': parseZcode,
+  'trae-cli': parseTraeCli,
 };
 
 

package/src/parsers/trae-cli.js

@@ -0,0 +1,155 @@
+import { readFileSync, readdirSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { findTraeCliDataDirs } from '../tools.js';
+import { aggregateToBuckets, extractSessions } from './index.js';
+
+function readJsonSafe(path) {
+  try { return JSON.parse(readFileSync(path, 'utf-8')); } catch { return null; }
+}
+
+function projectFromPath(absPath) {
+  if (!absPath || typeof absPath !== 'string') return 'unknown';
+  const trimmed = absPath.replace(/[\\/]+$/, '');
+  const name = basename(trimmed);
+  return name || 'unknown';
+}
+
+function parseJsonlSafe(path) {
+  try {
+    const content = readFileSync(path, 'utf-8');
+    return content
+      .split('\n')
+      .map(line => line.trim())
+      .filter(line => line.length > 0)
+      .map(line => {
+        try { return JSON.parse(line); } catch { return null; }
+      })
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+export async function parse() {
+  const cacheDirs = findTraeCliDataDirs();
+  if (cacheDirs.length === 0) return { buckets: [], sessions: [] };
+
+  const entries = [];
+  const events = [];
+
+  for (const cacheDir of cacheDirs) {
+    let sessionDirs = [];
+    try {
+      sessionDirs = readdirSync(cacheDir, { withFileTypes: true })
+        .filter(entry => entry.isDirectory())
+        .map(entry => entry.name);
+    } catch {
+      continue;
+    }
+
+    for (const sessionId of sessionDirs) {
+      const sessionPath = join(cacheDir, sessionId);
+      const sessionJson = readJsonSafe(join(sessionPath, 'session.json')) || {};
+      const project = projectFromPath(sessionJson.metadata?.cwd);
+      const fallbackModel = sessionJson.metadata?.model_name || 'trae-unknown';
+
+      // 1. Parse traces.jsonl for token usage
+      const traceLines = parseJsonlSafe(join(sessionPath, 'traces.jsonl'));
+      const tracesMap = new Map();
+
+      for (const line of traceLines) {
+        if (!line.traceID) continue;
+        const tags = Array.isArray(line.tags) ? line.tags : [];
+        const tagMap = {};
+        for (const t of tags) {
+          if (t && typeof t === 'object' && t.key) {
+            tagMap[t.key] = t.value;
+          }
+        }
+
+        const model = tagMap['model.name'] || tagMap['semantic.name'] || null;
+        const inputTokens = Math.max(0, Number(tagMap['usage.input_tokens']) || 0);
+        const outputTokens = Math.max(0, Number(tagMap['usage.output_tokens']) || 0);
+        const cacheReadTokens = Math.max(0, Number(tagMap['usage.cache_read_tokens']) || 0);
+        const reasoningTokens = Math.max(0, Number(tagMap['usage.reasoning_tokens']) || 0);
+
+        if (inputTokens + outputTokens + cacheReadTokens + reasoningTokens === 0) {
+          continue;
+        }
+
+        if (!tracesMap.has(line.traceID)) {
+          tracesMap.set(line.traceID, {
+            model,
+            inputTokens,
+            outputTokens,
+            cacheReadTokens,
+            reasoningTokens,
+            startTime: Number(line.startTime) || 0,
+          });
+        } else {
+          // Merge spans under the same traceID by selecting the max values
+          const existing = tracesMap.get(line.traceID);
+          if (model) {
+            existing.model = model;
+          }
+          existing.inputTokens = Math.max(existing.inputTokens, inputTokens);
+          existing.outputTokens = Math.max(existing.outputTokens, outputTokens);
+          existing.cacheReadTokens = Math.max(existing.cacheReadTokens, cacheReadTokens);
+          existing.reasoningTokens = Math.max(existing.reasoningTokens, reasoningTokens);
+          if (line.startTime) {
+            existing.startTime = existing.startTime ? Math.min(existing.startTime, Number(line.startTime)) : Number(line.startTime);
+          }
+        }
+      }
+
+      // Convert trace map to vibe-usage entries
+      for (const trace of tracesMap.values()) {
+        // Convert microsecond startTime to milliseconds for Date constructor
+        const startTime = Number(trace.startTime);
+        if (!Number.isFinite(startTime) || startTime <= 0) continue;
+        const timestamp = new Date(startTime / 1000);
+        entries.push({
+          source: 'trae-cli',
+          model: trace.model || fallbackModel,
+          project,
+          timestamp,
+          inputTokens: trace.inputTokens,
+          outputTokens: trace.outputTokens,
+          cachedInputTokens: trace.cacheReadTokens,
+          reasoningOutputTokens: trace.reasoningTokens,
+        });
+      }
+
+      // 2. Parse events.jsonl for user and assistant timings
+      const eventLines = parseJsonlSafe(join(sessionPath, 'events.jsonl'));
+      for (const line of eventLines) {
+        if (!line.created_at) continue;
+        const timestamp = new Date(line.created_at);
+        if (Number.isNaN(timestamp.getTime())) continue;
+
+        if (line.agent_start) {
+          events.push({
+            sessionId,
+            source: 'trae-cli',
+            project,
+            timestamp,
+            role: 'user',
+          });
+        } else if (line.agent_end || line.tool_call || (line.message && line.message.message?.role === 'assistant')) {
+          events.push({
+            sessionId,
+            source: 'trae-cli',
+            project,
+            timestamp,
+            role: 'assistant',
+          });
+        }
+      }
+    }
+  }
+
+  return {
+    buckets: aggregateToBuckets(entries),
+    sessions: extractSessions(events),
+  };
+}

package/src/tools.js

@@ -113,11 +113,41 @@ function findKimiCodeDataDirs() {
   ].filter(existsSync);
 }
 
+function findAntigravityDataDirs() {
+  return [
+    join(homedir(), '.gemini', 'antigravity'),
+    join(homedir(), '.gemini', 'antigravity-cli'),
+  ].filter(existsSync);
+}
+
+export function findTraeCliDataDirs() {
+  const envDir = process.env.VIBE_USAGE_TRAE_CLI_SESSIONS?.trim();
+  if (envDir) {
+    return [envDir].filter(existsSync);
+  }
+  if (process.platform === 'darwin') {
+    return [join(homedir(), 'Library', 'Caches', 'trae-cli', 'sessions')].filter(existsSync);
+  }
+  if (process.platform === 'win32') {
+    const localAppData = process.env.LOCALAPPDATA?.trim() || join(homedir(), 'AppData', 'Local');
+    return [join(localAppData, 'trae-cli', 'cache', 'sessions')].filter(existsSync);
+  }
+  const xdgCacheHome = process.env.XDG_CACHE_HOME?.trim() || join(homedir(), '.cache');
+  return [join(xdgCacheHome, 'trae-cli', 'sessions')].filter(existsSync);
+}
+
 export const TOOLS = [
+  {
+    name: 'Trae CLI',
+    id: 'trae-cli',
+    dataDir: join(homedir(), 'Library', 'Caches', 'trae-cli', 'sessions'),
+    detectDataDirs: findTraeCliDataDirs,
+  },
   {
     name: 'Antigravity',
     id: 'antigravity',
     dataDir: join(homedir(), '.gemini', 'antigravity'),
+    detectDataDirs: findAntigravityDataDirs,
   },
   {
     name: 'Claude Code',