@vibe-cafe/vibe-usage 0.10.12 → 0.10.14

package/README.md

@@ -53,6 +53,7 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 |------|---------------|
 | Alma | Electron app-data `alma/chat_threads.db` (macOS: `~/Library/Application Support/alma/chat_threads.db`; fixture/relocation override: `VIBE_USAGE_ALMA_DB`). Reads the `usage_records` ledger plus workspace names without selecting chat bodies, message metadata, provider credentials, or full workspace paths. Provider-prefixed model identifiers are normalized to their final model segment. Cache writes are included in input usage. The ledger contains assistant responses only, so Alma emits token buckets without session timing. |
 | Claude Code + Claude Desktop Code/Cowork | Claude Code data in `~/.claude/projects/` (tokens + sessions) and `~/.claude/transcripts/` (sessions only), plus Claude Desktop Cowork's per-session `.claude/projects/` directories. Also scans `$CLAUDE_CONFIG_DIR` and data-bearing `~/.claude-*` profiles. All variants use the existing `claude-code` source; the parser selects the most complete copy of each session so shared/copied transcripts are not counted twice. Logs are streamed and cache creation tokens are included in input usage. |
+| Cindy | Per-owner SQLite ledgers in the two regional Electron user-data roots: macOS `~/Library/Application Support/{CindyGlobal,Cindy}/cindy-*.db`, Windows `%APPDATA%\{CindyGlobal,Cindy}\cindy-*.db`, Linux `${XDG_CONFIG_HOME:-~/.config}/{CindyGlobal,Cindy}/cindy-*.db` (fixture/relocation override: `VIBE_USAGE_CINDY_DIRS`). Cindy-launched Claude Code already writes ordinary `~/.claude` transcripts, so it remains attributed to **Claude Code** and is not read again. Cindy's otherwise-private Codex and Pi daily/model ledger rows augment the existing **Codex** and **pi** sources. Currency rows are summed and cache creation joins input; chat messages, credentials, costs, and owner ids are never selected. The ledger adds token buckets only, without project or session timing. |
 | Codex CLI | `$CODEX_HOME/sessions/` and `$CODEX_HOME/archived_sessions/` (default `~/.codex`), plus an optional temporary `--extra-codex-home` or manually persisted `codexExtraHome`; a versioned local index avoids re-reading unchanged rollouts and reads only safe append tails for ordinary sessions, while fork/sub-agent replay matching, duplicate suppression, and live/archive/cross-root deduplication retain their existing semantics |
 | Grok | `$GROK_HOME/sessions/<encoded-cwd>/<session-id>/` (default `~/.grok`); token usage from `updates.jsonl` `turn_completed.usage` (per-model `modelUsage`, cache reads, reasoning); project from `summary.json` cwd; honors `GROK_HOME` |
 | GitHub Copilot CLI | `~/.copilot/session-state/*/events.jsonl` |
@@ -69,13 +70,13 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 | MiMoCode | `$MIMOCODE_HOME/data/mimocode.db`, `$XDG_DATA_HOME/mimocode/mimocode.db`, or `~/.local/share/mimocode/mimocode.db` (SQLite; exact input, output, reasoning, and cache-read tokens from assistant messages; honors `MIMOCODE_DB`; cache-write tokens are included in input usage) |
 | Amp | `~/.local/share/amp/threads/`; cache-creation tokens are included in input usage |
 | Droid | `~/.factory/sessions/` |
-| DeepSeek Harness | `$DSH_HOME/sessions/` (default `~/.dsh`, fixture/relocation override: `VIBE_USAGE_DSH_SESSIONS`). Reads multi-frame Zstandard `session.jsonl.zstd` logs (built-in `node:zlib` zstd on Node ≥ 22.15, `zstd` CLI fallback) and plain `session.jsonl` logs. Usage comes from `assistant/message`: cache writes join uncached input, cache reads remain separate, and reasoning is split out of inclusive output. Seed replay before the last `session/end-seed` marker is skipped so resumed/forked history is not double-counted. |
+| DeepSeek Harness | `$DSH_HOME/sessions/` (default `~/.dsh`, fixture/relocation override: `VIBE_USAGE_DSH_SESSIONS`). Reads multi-frame Zstandard `session.jsonl.zstd` logs (built-in `node:zlib` zstd on Node ≥ 22.15, `zstd` CLI fallback) and plain `session.jsonl` logs. Usage comes from `assistant/message`: cache writes join uncached input, cache reads remain separate, and reasoning is split out of inclusive output. Fork/subagent history is de-duplicated from the immutable header: `parentSession` identifies the source and `seedLength` gives the exact leading event boundary. Inherited messages are skipped only when matching source seqs remain in the parent file; missing parents fail open. `session/end-seed` positions are not used because resumes can append the marker after real history. |
 | Hermes | `~/.hermes/state.db` + `~/.hermes/profiles/<name>/state.db` (SQLite, multi-profile) |
 | 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 | Standalone `~/.cline/` plus `<host>/User/globalStorage/saoudrizwan.claude-dev/` across VSCode-fork hosts; migrated copies are deduplicated and empty leftover extension stores no longer count as installed |
 | Roo Code | `<host>/User/globalStorage/rooveterinaryinc.roo-cline/{tasks/_index.json,tasks/<id>/{history_item,ui_messages}.json}` (walks all VSCode-fork hosts) |
-| 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 |
+| 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). Token usage is summed per unique LLM call (`model.stream.eino`, plus `model.generate` failovers); nested duplicate spans that share a session `traceID` are not max-merged. `traces.jsonl` / `events.jsonl` are streamed line-by-line so a multi-hundred-MB events file cannot hit Node's string-length limit. |
+| Antigravity | App 2.0 `~/.gemini/antigravity/conversations/*.db` and `agy` CLI `~/.gemini/antigravity-cli/conversations/*.db` are parsed offline (tokens, real model display name when present, project, sessions). Gemini 3.7 CLI blobs omit `chatStartMetadata.createdAt` and `modelDisplayName`; usage still comes from `gen_metadata`, timestamps fall back to `steps.metadata` at the same idx, and the model name falls back to `responseModel`. Legacy App `.pb` history falls back to Connect RPC while the language server is running |
 | WorkBuddy | Current releases: `~/.workbuddy-ai/projects/**/*.jsonl`; legacy releases: `~/.workbuddy/projects/**/*.jsonl` (fixture/relocation override: `VIBE_USAGE_WORKBUDDY_DIRS`). Reads usage-bearing completed assistant and `function_call` records, using the routed model identifier exposed as `providerData.requestModelId`. Splits cache reads and reasoning from inclusive input/output totals, deduplicates copied record IDs, and extracts local session timing without uploading message content. |
 | ZCode | `~/.zcode/cli/db/db.sqlite` (SQLite; reads the `message` table for per-message tokens, model, and project `cwd`/`root`, joined to `session.directory`) |
 
@@ -83,7 +84,7 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 
 - Parses local session logs from each AI coding tool
 - Aggregates token usage into 30-minute buckets
-- Extracts session metadata where the source safely exposes user/assistant timing: active time (AI generation time, excluding queue/TTFT wait), total duration, and message counts. Alma intentionally emits buckets only because its usage ledger contains assistant responses and the parser does not read chat records.
+- Extracts session metadata where the source safely exposes user/assistant timing: active time (AI generation time, excluding queue/TTFT wait), total duration, and message counts. Alma intentionally emits buckets only; Cindy's daily-ledger augmentation adds no timing data to the native Codex/pi sessions because doing so would require reading Cindy chat records.
 - Uploads buckets + sessions to your vibecafe.ai dashboard (always gzip-compressed, ~94% smaller)
 - Incremental upload: every parser emits a complete local snapshot, then only buckets/sessions that are new or changed since the last successful upload are sent — a quiet machine uploads nothing. Upload state remains in `~/.vibe-usage/state.json`; failed or still-indexing parsers retain their prior state, while deleted local logs are pruned. Deleting the state file triggers a one-time full re-upload, and `reset` clears it automatically after deleting cloud data
 - Incremental Codex parsing: a versioned, disposable cache under `~/.vibe-usage/cache/codex/` stores per-rollout aggregate results and parser continuation state. Unchanged rollouts require no raw-log reads; an ordinary append reads only the new tail; forks, sub-agents, replacements, truncations, and failed safety checks fall back to the full correctness path. A bounded rolling audit occasionally re-reads one historical file. Very large first-time indexes checkpoint before the Mac app timeout and resume on the next sync instead of restarting

package/package.json

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

package/src/cindy-roots.js

@@ -0,0 +1,85 @@
+import { existsSync, readdirSync, realpathSync, statSync } from 'node:fs';
+import { delimiter, dirname, join, posix, resolve, win32 } from 'node:path';
+import { homedir } from 'node:os';
+
+function unique(values) {
+  return [...new Set(values)];
+}
+
+/**
+ * Cindy keeps Mainland China and Global installs in separate Electron user-data
+ * roots. Scan both because the two editions can be installed side by side.
+ */
+export function getCindyDataRoots(
+  env = process.env,
+  platform = process.platform,
+  home = homedir(),
+) {
+  const override = env.VIBE_USAGE_CINDY_DIRS?.trim();
+  if (override) {
+    return unique(
+      override
+        .split(delimiter)
+        .map((value) => value.trim())
+        .filter(Boolean)
+        .map((value) => resolve(value)),
+    );
+  }
+
+  const pathImpl = platform === 'win32' ? win32 : posix;
+  let base;
+  if (platform === 'darwin') {
+    base = pathImpl.join(home, 'Library', 'Application Support');
+  } else if (platform === 'win32') {
+    base = env.APPDATA?.trim() || pathImpl.join(home, 'AppData', 'Roaming');
+  } else {
+    base = env.XDG_CONFIG_HOME?.trim() || pathImpl.join(home, '.config');
+  }
+  return [pathImpl.join(base, 'CindyGlobal'), pathImpl.join(base, 'Cindy')];
+}
+
+function canonicalPath(value) {
+  try {
+    return realpathSync(value);
+  } catch {
+    return value;
+  }
+}
+
+/** Find every active per-owner `cindy-<owner>.db` database. */
+export function findCindyDbPaths(options = {}) {
+  const roots = getCindyDataRoots(options.env, options.platform, options.home);
+  const paths = [];
+
+  for (const root of roots) {
+    let stat;
+    try {
+      stat = statSync(root);
+    } catch {
+      continue;
+    }
+
+    if (stat.isFile()) {
+      if (root.endsWith('.db')) paths.push(canonicalPath(root));
+      continue;
+    }
+    if (!stat.isDirectory()) continue;
+
+    let entries;
+    try {
+      entries = readdirSync(root, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isFile() || !/^cindy-.+\.db$/.test(entry.name)) continue;
+      paths.push(canonicalPath(join(root, entry.name)));
+    }
+  }
+
+  return unique(paths).sort();
+}
+
+export function findCindyDataDirs(options = {}) {
+  return unique(findCindyDbPaths(options).map(dirname)).filter(existsSync);
+}

package/src/parsers/antigravity-db.js

@@ -26,6 +26,10 @@ import { queryDbJsonSnapshotOnLock, sqliteUnavailableError, isSqliteUnavailableE
  *       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)")
+ *
+ * Gemini 3.7 CLI blobs still have usage (4) and responseModel (19) but omit
+ * 9.4 and 21. Timestamps are recovered from steps.metadata field 1.1 at the
+ * same gen_metadata.idx; the model name falls back to responseModel.
  */
 
 // ── Minimal protobuf wire-format decoder (no dependency) ──────────────
@@ -146,6 +150,40 @@ export function parseGenMetadataBlob(buf) {
   };
 }
 
+/**
+ * Extract createdAt seconds from a steps.metadata blob, regardless of step
+ * source. Gemini 3.7 CLI gen_metadata blobs no longer carry chatStartMetadata
+ * (field 9.4); the step timestamp at field 1.1 is the remaining clock.
+ *
+ * @param {Buffer} buf
+ * @returns {Date|null}
+ */
+export function parseStepTimestamp(buf) {
+  const meta = decodeMessage(buf);
+  const createdAt = firstMessage(meta, 1);
+  const seconds = createdAt ? firstVarint(createdAt, 1) : undefined;
+  if (!seconds) return null;
+  const timestamp = new Date(seconds * 1000);
+  return Number.isNaN(timestamp.getTime()) ? null : timestamp;
+}
+
+/**
+ * Prefer the blob's own createdAt; if Gemini 3.7 omitted it, use the step
+ * with the same idx. idx-join is exact on current CLI stores (every
+ * gen_metadata idx exists in steps).
+ *
+ * @param {{timestamp: Date|null, idx?: number}} rec
+ * @param {Map<number, Date>} stepTimestampsByIdx
+ * @returns {Date|null}
+ */
+export function resolveUsageTimestamp(rec, stepTimestampsByIdx) {
+  if (rec?.timestamp && !Number.isNaN(rec.timestamp.getTime())) return rec.timestamp;
+  if (rec?.idx == null || !stepTimestampsByIdx) return null;
+  const stepTs = stepTimestampsByIdx.get(rec.idx);
+  if (stepTs && !Number.isNaN(stepTs.getTime())) return stepTs;
+  return null;
+}
+
 // ── SQLite store reading ──────────────────────────────────────────────
 
 function queryCascadeDb(conversationsDir, cascadeId, sql) {
@@ -182,7 +220,7 @@ export function listDbCascades(conversationsDir) {
 export function readDbUsageRecords(conversationsDir, cascadeId) {
   let rows;
   try {
-    rows = queryCascadeDb(conversationsDir, cascadeId, 'SELECT hex(data) AS h FROM gen_metadata ORDER BY idx');
+    rows = queryCascadeDb(conversationsDir, cascadeId, 'SELECT idx, hex(data) AS h FROM gen_metadata ORDER BY idx');
   } catch (err) {
     if (isSqliteUnavailableError(err)) throw err;
     return [];
@@ -196,11 +234,47 @@ export function readDbUsageRecords(conversationsDir, cascadeId) {
     } catch {
       continue; // one malformed blob must not kill the rest
     }
-    if (rec) records.push(rec);
+    if (rec) {
+      rec.idx = Number.isFinite(Number(row.idx)) ? Number(row.idx) : null;
+      records.push(rec);
+    }
   }
   return records;
 }
 
+/**
+ * Map steps.idx → createdAt for every step that has a timestamp, including
+ * system/tool steps that parseStepMetadata skips. Used to timestamp 3.7
+ * gen_metadata rows that no longer embed chatStartMetadata.
+ */
+export function readDbStepTimestamps(conversationsDir, cascadeId) {
+  let rows;
+  try {
+    rows = queryCascadeDb(
+      conversationsDir,
+      cascadeId,
+      'SELECT idx, hex(metadata) AS h FROM steps WHERE metadata IS NOT NULL ORDER BY idx',
+    );
+  } catch (err) {
+    if (isSqliteUnavailableError(err)) throw err;
+    return new Map();
+  }
+  const byIdx = new Map();
+  for (const row of rows) {
+    if (!row.h) continue;
+    let ts;
+    try {
+      ts = parseStepTimestamp(Buffer.from(row.h, 'hex'));
+    } catch {
+      continue;
+    }
+    if (!ts) continue;
+    const idx = Number(row.idx);
+    if (Number.isFinite(idx)) byIdx.set(idx, ts);
+  }
+  return byIdx;
+}
+
 /**
  * Read the workspace URI for a cascade from trajectory_metadata_blob.
  * Structure: field 1 = workspaces[0], 1.1 = workspaceFolderAbsoluteUri.

package/src/parsers/antigravity.js

@@ -3,7 +3,7 @@ import { readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { aggregateToBuckets, extractSessions } from './aggregate.js';
-import { listDbCascades, readDbUsageRecords, readDbWorkspaceUri, readDbSessionEvents } from './antigravity-db.js';
+import { listDbCascades, readDbUsageRecords, readDbWorkspaceUri, readDbSessionEvents, readDbStepTimestamps, resolveUsageTimestamp } from './antigravity-db.js';
 
 
 
@@ -327,18 +327,25 @@ export async function parse() {
     for (const cascadeId of listDbCascades(dir)) {
       const records = readDbUsageRecords(dir, cascadeId);
       const project = projectFromUri(readDbWorkspaceUri(dir, cascadeId)) || 'unknown';
+      const stepTimestampsByIdx = records.some((rec) => !rec.timestamp || isNaN(rec.timestamp.getTime()))
+        ? readDbStepTimestamps(dir, cascadeId)
+        : new Map();
 
       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;
+          // Gemini 3.7 CLI blobs dropped chatStartMetadata.createdAt (9.4.1)
+          // and modelDisplayName (21). Usage is still in field 4; clock is
+          // recovered from steps.metadata at the same idx.
+          const timestamp = resolveUsageTimestamp(rec, stepTimestampsByIdx);
+          if (!timestamp || isNaN(timestamp.getTime())) continue;
           entries.push({
             source: SOURCE,
             model: modelFromRecord(rec),
             project,
-            timestamp: rec.timestamp,
+            timestamp,
             inputTokens: toSafeNumber(rec.inputTokens),
             outputTokens: toSafeNumber(rec.outputTokens),
             cachedInputTokens: toSafeNumber(rec.cacheReadTokens),

package/src/parsers/cindy-ledger.js

@@ -0,0 +1,156 @@
+import { findCindyDbPaths } from '../cindy-roots.js';
+import { aggregateToBuckets } from './aggregate.js';
+import { toCount } from './fs-utils.js';
+import {
+  isSqliteUnavailableError,
+  queryDbJsonSnapshot,
+  sqliteUnavailableError,
+} from './sqlite.js';
+
+const CINDY_USAGE_SQL = `
+  SELECT
+    day,
+    agent_kind AS agentKind,
+    model,
+    SUM(input_tokens) AS inputTokens,
+    SUM(output_tokens) AS outputTokens,
+    SUM(cache_read_tokens) AS cacheReadTokens,
+    SUM(cache_create_tokens) AS cacheCreateTokens
+  FROM daily_model_usage
+  GROUP BY day, agent_kind, model
+  ORDER BY day, agent_kind, model
+`;
+
+/** Cindy stores its ledger day as local-time YYYY-MM-DD. */
+export function dateFromCindyDay(value) {
+  if (typeof value !== 'string') return null;
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+  if (!match) return null;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const date = new Date(year, month - 1, day);
+  if (
+    date.getFullYear() !== year
+    || date.getMonth() !== month - 1
+    || date.getDate() !== day
+  ) {
+    return null;
+  }
+  return date;
+}
+
+function skippedResult(error) {
+  const message = error?.message || String(error);
+  let reason = 'read failed';
+  if (/database is locked/i.test(message)) reason = 'database is locked';
+  else if (/no such column/i.test(message)) reason = 'incompatible database schema';
+  else if (/unable to open|SQLITE_CANTOPEN/i.test(message)) reason = 'database unavailable';
+  return {
+    buckets: [],
+    sessions: [],
+    skipped: true,
+    warnings: [`cindy: cannot read usage database (${reason})`],
+  };
+}
+
+const CINDY_HARNESS_SOURCES = {
+  codex: 'codex',
+  pi: 'pi-coding-agent',
+};
+
+/**
+ * Read Cindy's daily ledger for a harness that does not already expose the
+ * same raw logs to Vibe Usage. Cindy's Claude Code SDK writes ordinary
+ * ~/.claude transcripts, so Claude stays owned by the claude-code parser and
+ * is deliberately absent from this map.
+ */
+export function readCindyHarnessUsage(agentKind) {
+  const source = CINDY_HARNESS_SOURCES[agentKind];
+  if (!source) throw new TypeError(`Unsupported Cindy harness: ${agentKind}`);
+
+  const dbPaths = findCindyDbPaths();
+  if (dbPaths.length === 0) return { buckets: [], sessions: [] };
+
+  const rows = [];
+  for (const dbPath of dbPaths) {
+    try {
+      rows.push(...queryDbJsonSnapshot(dbPath, CINDY_USAGE_SQL, {
+        tempPrefix: 'vibe-usage-cindy-',
+      }));
+    } catch (error) {
+      if (isSqliteUnavailableError(error)) throw sqliteUnavailableError('Cindy');
+      // Cindy versions before the daily ledger was introduced have no usage
+      // rows to import. A second, current regional/account database may still
+      // be readable, so skip only this legacy database.
+      if (/no such table:\s*daily_model_usage/i.test(error?.message || '')) continue;
+      return skippedResult(error);
+    }
+  }
+
+  const entries = [];
+  for (const row of rows) {
+    if (row.agentKind !== agentKind) continue;
+    const timestamp = dateFromCindyDay(row.day);
+    if (!timestamp) continue;
+    const inputTokens = toCount(row.inputTokens) + toCount(row.cacheCreateTokens);
+    const outputTokens = toCount(row.outputTokens);
+    const cachedInputTokens = toCount(row.cacheReadTokens);
+    if (inputTokens + outputTokens + cachedInputTokens === 0) continue;
+
+    entries.push({
+      source,
+      model: typeof row.model === 'string' && row.model.trim()
+        ? row.model.trim()
+        : `${source}-unknown`,
+      project: 'unknown',
+      timestamp,
+      inputTokens,
+      outputTokens,
+      cachedInputTokens,
+      reasoningOutputTokens: 0,
+    });
+  }
+
+  return {
+    buckets: aggregateToBuckets(entries),
+    sessions: [],
+  };
+}
+
+/**
+ * Merge the optional Cindy ledger into the native harness snapshot. A failed
+ * Cindy read marks the whole source skipped so its previously uploaded rows
+ * are not pruned from incremental state.
+ */
+export function mergeCindyHarnessUsage(nativeResult, cindyResult) {
+  const warnings = [
+    ...(nativeResult.warnings || []),
+    ...(cindyResult.warnings || []),
+  ];
+  if (nativeResult.skipped || cindyResult.skipped) {
+    return {
+      ...nativeResult,
+      buckets: [],
+      sessions: [],
+      skipped: true,
+      warnings,
+    };
+  }
+
+  const entries = [];
+  for (const bucket of [...nativeResult.buckets, ...cindyResult.buckets]) {
+    const timestamp = new Date(bucket.bucketStart);
+    if (Number.isNaN(timestamp.getTime())) continue;
+    entries.push({
+      ...bucket,
+      timestamp,
+    });
+  }
+  return {
+    ...nativeResult,
+    buckets: aggregateToBuckets(entries),
+    sessions: nativeResult.sessions || [],
+    warnings,
+  };
+}

package/src/parsers/codex.js

@@ -11,6 +11,7 @@ import { join } from 'node:path';
 import { createInterface } from 'node:readline';
 import { createHash } from 'node:crypto';
 import { aggregateToBuckets } from './aggregate.js';
+import { mergeCindyHarnessUsage, readCindyHarnessUsage } from './cindy-ledger.js';
 import {
   codexSessionDirs,
   resolveCodexHomes,
@@ -796,7 +797,7 @@ function mergeFileResults(results) {
   return { buckets: aggregateToBuckets(entries), sessions };
 }
 
-export async function parse({ codexExtraHome } = {}) {
+async function parseNativeCodex({ codexExtraHome } = {}) {
   if (codexExtraHome?.trim()) {
     const validation = validateExtraCodexHome(codexExtraHome);
     if (!validation.ok) {
@@ -1019,3 +1020,8 @@ export async function parse({ codexExtraHome } = {}) {
 
   return { ...mergeFileResults(results), cache: cacheStats };
 }
+
+export async function parse(options = {}) {
+  const nativeResult = await parseNativeCodex(options);
+  return mergeCindyHarnessUsage(nativeResult, readCindyHarnessUsage('codex'));
+}

package/src/parsers/dsh.js

@@ -190,33 +190,40 @@ function isUserMessageRecord(rec) {
 }
 
 /**
- * Parse one decompressed session log into flat entries/events.
+ * Build a session model from one decompressed session log.
  *
  * Layout (DeepSeek Harness session-persistence-jsonl):
- *   line 0: {"type":"session","version":0,"id":...,"createdAt":...,"cwd":...,...}
+ *   line 0: {"type":"session","version":0,"id":...,"createdAt":...,"cwd":...,
+ *            "parentSession":...?, ...}
  *   ... possibly a resumed/forked seed replay, then ...
- *   {"type":"session/end-seed",...}          (absent in fresh sessions)
- *   {"type":"assistant/message","data":{"turn","step","message":{"source":
- *     {"kind":"model","provider","model"},...},"usage":{"inputTokens",
- *     "outputTokens","cacheReadTokens","cacheWriteTokens",
- *     "reasoningTokens"}},...}
+ *   {"type":"user/message"|"assistant/message","time":...,"data":{...}}
  *
- * When a session is resumed (or forked) the stored log begins with a replay of
- * the seed history. Everything before the LAST session/end-seed marker is a
- * replay of records that were already counted from their original file, so it
- * must be skipped or the same usage would be counted twice.
+ * DSH (developer preview) writes session/end-seed records in three situations:
+ * right after session creation (empty seed), at each resume boundary, and
+ * appended at the END of a file when that session becomes the seed for a
+ * further resume. The marker's position is therefore NOT a replay boundary —
+ * a trailing marker would make "skip everything before the last marker"
+ * discard the session's entire real history.
+ *
+ * Fork/subagent lineage is encoded separately in the immutable header.
+ * `parentSession` identifies the source and `seedLength` is the exact number
+ * of leading event seqs inherited from it. Only those seqs are skipped, and
+ * only while the parent file is also present, so a missing/corrupt source
+ * fails open instead of dropping the sole local copy of its usage.
+ *
+ * Only user/message (source.kind === 'user') and assistant/message records
+ * are kept in the model — they are the only records that produce usage
+ * entries or timing events. Their seq is retained so the header's seed
+ * boundary can be applied without inspecting or hashing message content.
  *
  * usage.outputTokens includes reasoningTokens (verified against the
  * session_projcache totals DSH itself maintains), so reasoning is split out of
  * output before aggregation, like the Pi-family parsers.
  */
-function parseSessionText(text) {
-  const entries = [];
-  const events = [];
+function buildSessionModel(text) {
   const lines = text.split('\n');
 
   let header = null;
-  let endSeedIndex = -1;
   for (let i = 0; i < lines.length; i++) {
     if (lines[i].length === 0) continue;
     let rec;
@@ -225,9 +232,8 @@ function parseSessionText(text) {
     } catch {
       continue; // torn final line: keep the complete records
     }
-    if (rec && typeof rec === 'object') {
-      if (header === null && rec.type === 'session') header = rec;
-      if (rec.type === 'session/end-seed') endSeedIndex = i;
+    if (rec && typeof rec === 'object' && header === null && rec.type === 'session') {
+      header = rec;
     }
   }
 
@@ -243,11 +249,8 @@ function parseSessionText(text) {
     throw error;
   }
 
-  const sessionId = header.id;
-  const project = projectFromCwd(header.cwd);
-
+  const messages = [];
   for (let i = 0; i < lines.length; i++) {
-    if (i <= endSeedIndex) continue;
     if (lines[i].length === 0) continue;
     let rec;
     try {
@@ -256,51 +259,142 @@ function parseSessionText(text) {
       continue;
     }
     if (!rec || typeof rec !== 'object') continue;
-    const timestamp = new Date(rec.time);
-    if (Number.isNaN(timestamp.getTime())) continue;
+    const timeMs = recordTimeMs(rec);
+    if (timeMs == null) continue;
+    const seq = Number.isSafeInteger(rec.seq) && rec.seq >= 0 ? rec.seq : null;
 
     if (isUserMessageRecord(rec)) {
-      events.push({ sessionId, source: SOURCE, project, timestamp, role: 'user' });
+      messages.push({ seq, role: 'user', timeMs, usage: null, model: null });
       continue;
     }
     if (!isUsageRecord(rec)) continue;
 
     // Every assistant/message marks the end of a billable step, even when its
-    // usage block is missing.
-    events.push({ sessionId, source: SOURCE, project, timestamp, role: 'assistant' });
-
-    const usage = rec.data.usage;
-    if (!usage || typeof usage !== 'object') continue;
-    // Harness counts are disjoint. The common bucket model has no cache-write
-    // column, so cache writes join uncached input, matching the other parsers.
-    const inputTokens = toCount(usage.inputTokens) + toCount(usage.cacheWriteTokens);
-    const cachedInputTokens = toCount(usage.cacheReadTokens);
-    const totalOutputTokens = toCount(usage.outputTokens);
-    const reasoningOutputTokens = Math.min(
-      totalOutputTokens,
-      toCount(usage.reasoningTokens),
-    );
-    const outputTokens = totalOutputTokens - reasoningOutputTokens;
-    if (inputTokens + cachedInputTokens + reasoningOutputTokens + outputTokens === 0) continue;
-
-    const model =
-      typeof rec.data.message?.source?.model === 'string' && rec.data.message.source.model
-        ? rec.data.message.source.model
-        : 'unknown';
-
-    entries.push({
-      source: SOURCE,
-      model,
-      project,
-      timestamp,
-      inputTokens,
-      outputTokens,
-      cachedInputTokens,
-      reasoningOutputTokens,
+    // usage block is missing; the model keeps it so timing survives.
+    messages.push({
+      seq,
+      role: 'assistant',
+      timeMs,
+      usage: parseUsage(rec.data.usage),
+      model:
+        typeof rec.data.message?.source?.model === 'string' && rec.data.message.source.model
+          ? rec.data.message.source.model
+          : 'unknown',
     });
   }
 
-  return { sessionId, entries, events };
+  return {
+    sessionId: header.id,
+    parentSessionId:
+      typeof header.parentSession === 'string' && header.parentSession
+        ? header.parentSession
+        : null,
+    seedLength:
+      Number.isSafeInteger(header.seedLength) && header.seedLength > 0
+        ? header.seedLength
+        : 0,
+    cwd: header.cwd,
+    messages,
+  };
+}
+
+/** Record wall-clock time in epoch ms; null when absent/invalid. */
+function recordTimeMs(rec) {
+  const t = rec.time;
+  if (typeof t === 'number' && Number.isFinite(t)) return t;
+  if (typeof t === 'string' && t.trim()) {
+    const d = new Date(t);
+    return Number.isNaN(d.getTime()) ? null : d.getTime();
+  }
+  return null;
+}
+
+/** Usage numbers from an assistant/message usage block, or null when empty. */
+function parseUsage(usage) {
+  if (!usage || typeof usage !== 'object') return null;
+  // Harness counts are disjoint. The common bucket model has no cache-write
+  // column, so cache writes join uncached input, matching the other parsers.
+  const inputTokens = toCount(usage.inputTokens) + toCount(usage.cacheWriteTokens);
+  const cachedInputTokens = toCount(usage.cacheReadTokens);
+  const totalOutputTokens = toCount(usage.outputTokens);
+  const reasoningOutputTokens = Math.min(totalOutputTokens, toCount(usage.reasoningTokens));
+  const outputTokens = totalOutputTokens - reasoningOutputTokens;
+  if (inputTokens + cachedInputTokens + reasoningOutputTokens + outputTokens === 0) return null;
+  return { inputTokens, outputTokens, cachedInputTokens, reasoningOutputTokens };
+}
+
+/** Token-accounting equality for a copied assistant record. */
+function sameUsage(left, right) {
+  if (left == null || right == null) return left === right;
+  return (
+    left.inputTokens === right.inputTokens &&
+    left.outputTokens === right.outputTokens &&
+    left.cachedInputTokens === right.cachedInputTokens &&
+    left.reasoningOutputTokens === right.reasoningOutputTokens
+  );
+}
+
+/**
+ * Number of leading child messages inherited from a parent seed.
+ *
+ * `header.seedLength` is DSH's durable fork-lineage boundary: event seqs below
+ * it came from the parent, while later seqs belong to the child. Each skipped
+ * message must still exist at the same seq in the selected parent copy.
+ * Missing, invalid, or divergent records fail open so usage is not lost.
+ */
+function replaySkipCount(child, parent) {
+  if (child.seedLength <= 0 || child.messages.length === 0) return 0;
+  let parentIndex = 0;
+  let previousSeq = -1;
+  let count = 0;
+  for (const message of child.messages) {
+    if (message.seq == null || message.seq <= previousSeq) return 0;
+    previousSeq = message.seq;
+    if (message.seq >= child.seedLength) break;
+
+    while (
+      parentIndex < parent.messages.length &&
+      parent.messages[parentIndex].seq != null &&
+      parent.messages[parentIndex].seq < message.seq
+    ) {
+      parentIndex++;
+    }
+    const source = parent.messages[parentIndex];
+    if (
+      source?.seq !== message.seq ||
+      source.role !== message.role ||
+      source.model !== message.model ||
+      !sameUsage(source.usage, message.usage)
+    ) {
+      return 0;
+    }
+    parentIndex++;
+    count++;
+  }
+  return count;
+}
+
+/** Fold a (possibly replay-trimmed) model into flat usage entries + timing events. */
+function modelToResult(model, skipCount) {
+  const sessionId = model.sessionId;
+  const project = projectFromCwd(model.cwd);
+  const entries = [];
+  const events = [];
+  for (let i = skipCount; i < model.messages.length; i++) {
+    const msg = model.messages[i];
+    const timestamp = new Date(msg.timeMs);
+    events.push({ sessionId, source: SOURCE, project, timestamp, role: msg.role });
+    if (msg.usage) {
+      entries.push({
+        source: SOURCE,
+        model: msg.model || 'unknown',
+        project,
+        timestamp,
+        ...msg.usage,
+      });
+    }
+  }
+  return { entries, events };
 }
 
 /** List session log files under a DSH sessions root (session.jsonl[.zstd]). */
@@ -355,6 +449,12 @@ function listSessionFiles(sessionsDir, onFailure) {
  * Zstandard session logs are multi-frame; node:zlib zstd (Node >= 22.15)
  * decodes one frame per call, so the buffer is walked frame-by-frame, with a
  * `zstd` CLI fallback for older Node.
+ *
+ * Replay handling: `header.parentSession` identifies a fork/subagent source,
+ * and `header.seedLength` is the exact count of leading event seqs inherited
+ * from it. Those records are skipped only when the parent file is also
+ * present. Files without either field, and children whose parent is missing,
+ * are counted in full. `session/end-seed` positions are never used.
  */
 export async function parse() {
   const sessionsDir = getDshSessionsDir();
@@ -385,7 +485,9 @@ export async function parse() {
     return result;
   }
 
-  const perSession = new Map(); // sessionId -> parsed view (largest complete log wins)
+  // sessionId -> most complete model (largest decompressed log wins, so a
+  // session copied between project dirs is counted once).
+  const perSession = new Map();
   for (const { file, compressed } of files) {
     let text;
     try {
@@ -406,9 +508,9 @@ export async function parse() {
       continue;
     }
 
-    let parsed;
+    let model;
     try {
-      parsed = parseSessionText(text);
+      model = buildSessionModel(text);
     } catch (error) {
       recordFailure(
         'dsh: skipping ' + relative(process.cwd(), file) + ' (' + error.message + ')',
@@ -417,17 +519,24 @@ export async function parse() {
     }
 
     const weight = text.length;
-    const previous = perSession.get(parsed.sessionId);
+    const previous = perSession.get(model.sessionId);
     if (!previous || weight > previous.weight) {
-      perSession.set(parsed.sessionId, { ...parsed, weight });
+      perSession.set(model.sessionId, { model, weight });
     }
   }
 
   const entries = [];
   const eventsBySession = new Map();
-  for (const parsed of perSession.values()) {
-    entries.push(...parsed.entries);
-    for (const event of parsed.events) {
+  for (const { model } of perSession.values()) {
+    // seedLength supplies the exact inherited boundary; matching source seqs
+    // prove the selected parent copy still contains what the child inherited.
+    // Missing/corrupt parents fail open so the child remains the local copy.
+    const parent =
+      model.parentSessionId == null ? null : perSession.get(model.parentSessionId);
+    const skip = parent ? replaySkipCount(model, parent.model) : 0;
+    const { entries: fileEntries, events: fileEvents } = modelToResult(model, skip);
+    entries.push(...fileEntries);
+    for (const event of fileEvents) {
       if (!eventsBySession.has(event.sessionId)) eventsBySession.set(event.sessionId, []);
       eventsBySession.get(event.sessionId).push(event);
     }

package/src/parsers/pi-coding-agent.js

@@ -1,10 +1,12 @@
 import { getPiSessionDirs } from '../pi-roots.js';
+import { mergeCindyHarnessUsage, readCindyHarnessUsage } from './cindy-ledger.js';
 import { parsePiSessionJsonl } from './pi-session-jsonl.js';
 
 /** Parse the official Pi agent's Pi-compatible JSONL sessions. */
 export async function parse() {
-  return parsePiSessionJsonl({
+  const nativeResult = await parsePiSessionJsonl({
     source: 'pi-coding-agent',
     sessionsDirs: getPiSessionDirs(),
   });
+  return mergeCindyHarnessUsage(nativeResult, readCindyHarnessUsage('pi'));
 }

package/src/parsers/sqlite.js

@@ -17,8 +17,12 @@ const require = createRequire(import.meta.url);
  * If neither is available, throws an Error whose message contains "ENOENT" so
  * callers can surface an "Install sqlite3" hint, matching the previous behavior.
  */
-export function queryDbJson(dbPath, sql, { timeout = 30000, maxBuffer = 100 * 1024 * 1024 } = {}) {
-  const db = openNodeSqlite(dbPath);
+export function queryDbJson(
+  dbPath,
+  sql,
+  { timeout = 30000, maxBuffer = 100 * 1024 * 1024, readOnly = true } = {},
+) {
+  const db = openNodeSqlite(dbPath, readOnly);
   if (db) {
     try {
       return db.prepare(sql).all();
@@ -55,12 +59,22 @@ function getNodeSqlite() {
   return nodeSqlite;
 }
 
-function openNodeSqlite(dbPath) {
+function openNodeSqlite(dbPath, readOnly = true) {
   const mod = getNodeSqlite();
   if (!mod || !mod.DatabaseSync) return null;
+  let db;
   try {
-    return new mod.DatabaseSync(dbPath, { readOnly: true });
+    db = new mod.DatabaseSync(dbPath, { readOnly });
+    // Writable access is used only for disposable snapshots whose WAL metadata
+    // may need initialization. Keep the SQL connection itself read-only.
+    if (!readOnly) db.exec('PRAGMA query_only = ON');
+    return db;
   } catch {
+    try {
+      db?.close();
+    } catch {
+      // Ignore cleanup failure while falling back to the sqlite3 CLI.
+    }
     return null;
   }
 }
@@ -94,6 +108,31 @@ export function isLockError(err) {
   return !!err && typeof err.message === 'string' && /database is locked/i.test(err.message);
 }
 
+function querySnapshot(dbPath, sql, { tempPrefix, opts } = {}) {
+  const snapshotDir = mkdtempSync(join(tmpdir(), tempPrefix || 'vibe-usage-sqlite-'));
+  const queryPath = join(snapshotDir, basename(dbPath));
+  try {
+    copyFileSync(dbPath, queryPath);
+    for (const suffix of ['-shm', '-wal']) {
+      const companion = `${dbPath}${suffix}`;
+      if (existsSync(companion)) copyFileSync(companion, `${queryPath}${suffix}`);
+    }
+    return queryDbJson(queryPath, sql, { ...opts, readOnly: false });
+  } finally {
+    rmSync(snapshotDir, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Query a disposable writable snapshot. Some WAL-mode databases cannot be
+ * opened read-only until SQLite has initialized their shared-memory metadata;
+ * doing that only in the temp copy keeps the source application database
+ * untouched and works without a sqlite3 binary on Node >= 22.5.
+ */
+export function queryDbJsonSnapshot(dbPath, sql, options = {}) {
+  return querySnapshot(dbPath, sql, options);
+}
+
 /**
  * Run a query, and if the source app holds a write lock on the database, copy
  * the DB (plus its -wal/-shm companions) to a temp dir and re-query the
@@ -104,17 +143,6 @@ export function queryDbJsonSnapshotOnLock(dbPath, sql, { tempPrefix = 'vibe-usag
     return queryDbJson(dbPath, sql, opts);
   } catch (err) {
     if (!isLockError(err)) throw err;
-    const snapshotDir = mkdtempSync(join(tmpdir(), tempPrefix));
-    const queryPath = join(snapshotDir, basename(dbPath));
-    try {
-      copyFileSync(dbPath, queryPath);
-      for (const suffix of ['-shm', '-wal']) {
-        const companion = `${dbPath}${suffix}`;
-        if (existsSync(companion)) copyFileSync(companion, `${queryPath}${suffix}`);
-      }
-      return queryDbJson(queryPath, sql, opts);
-    } finally {
-      rmSync(snapshotDir, { recursive: true, force: true });
-    }
+    return querySnapshot(dbPath, sql, { tempPrefix, opts });
   }
 }

package/src/parsers/trae-cli.js

@@ -1,22 +1,86 @@
-import { readFileSync, readdirSync } from 'node:fs';
+import { createReadStream, existsSync, readdirSync } from 'node:fs';
+import { createInterface } from 'node:readline';
 import { join } from 'node:path';
 import { findTraeCliDataDirs } from '../tools.js';
 import { aggregateToBuckets, extractSessions } from './aggregate.js';
 import { readJsonSafe, projectFromPath } from './fs-utils.js';
 
-function parseJsonlSafe(path) {
+// Trae writes each LLM call as several nested spans that share one session-level
+// traceID and copy the same usage onto every layer:
+//   model.stream.eino  (authoritative: includes reasoning tokens)
+//   model.real_call    (duplicate)
+//   model.call         (duplicate)
+// model.generate is a separate failover call (different model), not a duplicate.
+// Counting every layer would 3x; merging by traceID with max() collapses a
+// whole session of sequential calls into a single request. Keep one unique
+// layer per call, then SUM.
+const PRIMARY_LLM_CATEGORY = 'model.stream.eino';
+const FAILOVER_LLM_CATEGORY = 'model.generate';
+const FALLBACK_LLM_CATEGORIES = ['model.real_call', 'model.call'];
+
+function tagMapFrom(tags) {
+  const tagMap = {};
+  if (!Array.isArray(tags)) return tagMap;
+  for (const t of tags) {
+    if (t && typeof t === 'object' && t.key) tagMap[t.key] = t.value;
+  }
+  return tagMap;
+}
+
+function spanCategory(tagMap) {
+  return typeof tagMap['span.category'] === 'string' ? tagMap['span.category'] : '';
+}
+
+function usageFromTagMap(tagMap) {
+  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);
+  return { inputTokens, outputTokens, cacheReadTokens, reasoningTokens };
+}
+
+function hasUsage(usage) {
+  return usage.inputTokens + usage.outputTokens + usage.cacheReadTokens + usage.reasoningTokens > 0;
+}
+
+/**
+ * Pick the unique LLM-call spans from a session's traces.
+ * Prefer model.stream.eino (+ model.generate failovers). If a session has no
+ * primary layer (older traces), fall back to model.real_call, then model.call.
+ * @param {{category: string, usage: object, model: string|null, startTime: number}[]} spans
+ */
+export function selectTraeUsageSpans(spans) {
+  const withUsage = spans.filter((s) => hasUsage(s.usage));
+  const primary = withUsage.filter((s) => s.category === PRIMARY_LLM_CATEGORY);
+  const failover = withUsage.filter((s) => s.category === FAILOVER_LLM_CATEGORY);
+  if (primary.length > 0 || failover.length > 0) return primary.concat(failover);
+  for (const cat of FALLBACK_LLM_CATEGORIES) {
+    const subset = withUsage.filter((s) => s.category === cat);
+    if (subset.length > 0) return subset;
+  }
+  return withUsage;
+}
+
+/** Stream a JSONL file line by line. Skips missing files and malformed lines. */
+export async function forEachJsonl(path, onObj) {
+  if (!existsSync(path)) return;
+  const stream = createReadStream(path, { encoding: 'utf8' });
+  const lines = createInterface({ input: stream, crlfDelay: Infinity });
   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 [];
+    for await (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      let obj;
+      try {
+        obj = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      if (obj && typeof obj === 'object') onObj(obj);
+    }
+  } finally {
+    lines.close();
+    stream.destroy();
   }
 }
 
@@ -43,79 +107,41 @@ export async function parse() {
       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);
-          }
-        }
-      }
+      const spans = [];
+      await forEachJsonl(join(sessionPath, 'traces.jsonl'), (line) => {
+        const tagMap = tagMapFrom(line.tags);
+        const usage = usageFromTagMap(tagMap);
+        if (!hasUsage(usage)) return;
+        const startTime = Number(line.startTime);
+        if (!Number.isFinite(startTime) || startTime <= 0) return;
+        spans.push({
+          category: spanCategory(tagMap),
+          model: tagMap['model.name'] || tagMap['semantic.name'] || null,
+          startTime,
+          usage,
+        });
+      });
 
-      // 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);
+      for (const span of selectTraeUsageSpans(spans)) {
+        // Trae startTime is microseconds; Date expects milliseconds.
+        const timestamp = new Date(span.startTime / 1000);
+        if (Number.isNaN(timestamp.getTime())) continue;
         entries.push({
           source: 'trae-cli',
-          model: trace.model || fallbackModel,
+          model: span.model || fallbackModel,
           project,
           timestamp,
-          inputTokens: trace.inputTokens,
-          outputTokens: trace.outputTokens,
-          cachedInputTokens: trace.cacheReadTokens,
-          reasoningOutputTokens: trace.reasoningTokens,
+          inputTokens: span.usage.inputTokens,
+          outputTokens: span.usage.outputTokens,
+          cachedInputTokens: span.usage.cacheReadTokens,
+          reasoningOutputTokens: span.usage.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;
+      await forEachJsonl(join(sessionPath, 'events.jsonl'), (line) => {
+        if (!line.created_at) return;
         const timestamp = new Date(line.created_at);
-        if (Number.isNaN(timestamp.getTime())) continue;
+        if (Number.isNaN(timestamp.getTime())) return;
 
         if (line.agent_start) {
           events.push({
@@ -134,7 +160,7 @@ export async function parse() {
             role: 'assistant',
           });
         }
-      }
+      });
     }
   }
 

package/src/tools.js

@@ -2,6 +2,7 @@ import { existsSync, readdirSync, statSync } from 'node:fs';
 import { isAbsolute, join, posix, resolve, win32 } from 'node:path';
 import { homedir } from 'node:os';
 import { findClaudeCodeDataDirs } from './claude-roots.js';
+import { findCindyDataDirs, getCindyDataRoots } from './cindy-roots.js';
 import { codexSessionDirs, resolveCodexHomes } from './codex-roots.js';
 import { findClineDataDirs } from './cline-roots.js';
 import { findCraftDataDirs } from './craft-roots.js';
@@ -223,6 +224,12 @@ export const TOOLS = [
     dataDir: getAlmaDbPath(),
     detectDataDirs: () => [getAlmaDbPath()].filter(existsSync),
   },
+  {
+    name: 'Cindy',
+    id: 'cindy',
+    dataDir: getCindyDataRoots()[0],
+    detectDataDirs: findCindyDataDirs,
+  },
   {
     name: 'Claude Code',
     id: 'claude-code',