@vibe-cafe/vibe-usage 0.14.1 → 0.14.3

package/README.md

@@ -104,7 +104,7 @@ Quota results are never uploaded or added to incremental sync state. Credential-
 | Cline (CLI / SDK / Desktop app) | All variants write the same `~/.cline/data/sessions/*/*.messages.json` per-call metrics (the desktop app's manifest says `source: "desktop"`; its Electron userData holds only WebView caches), plus legacy `~/.cline/{,data/}state/taskHistory.json` and editor extension stores. Honors `CLINE_DIR`, `CLINE_DATA_DIR`, and `CLINE_SESSION_DATA_DIR`; copied history is deduplicated |
 | 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). 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 | Scans App 2.0 `~/.gemini/antigravity/conversations/`, `agy` CLI `~/.gemini/antigravity-cli/conversations/`, and standalone IDE `~/.gemini/antigravity-ide/conversations/`. `.db` stores, including the same paths below explicitly added alternate Homes, are parsed offline (tokens, model, project, sessions). When Gemini blobs omit `chatStartMetadata.createdAt` or `modelDisplayName`, timestamps fall back to `steps.metadata` and model names to `responseModel`. `.pb` history in the default stores requires the corresponding App/IDE language server to be running; when several servers are open, the parser tries the others for unreadable conversations. Unavailable legacy history produces a warning and preserves prior sync state. |
+| Antigravity | Scans App 2.0 `~/.gemini/antigravity/conversations/`, `agy` CLI `~/.gemini/antigravity-cli/conversations/`, and standalone IDE `~/.gemini/antigravity-ide/conversations/`. `.db` stores, including the same paths below explicitly added alternate Homes, are parsed offline (tokens, model, project, sessions). Usage is read from `gen_metadata` and from `steps.metadata` (newer builds keep the live usage on the step instead); the two are merged by response/message identity, keeping the richest payload so a call both tables saw is counted once. Output is the store's total (thinking is billed once as reasoning, not twice), and cache writes land in the 5m column. When Gemini blobs omit `chatStartMetadata.createdAt` or `modelDisplayName`, timestamps fall back to the step's own clock or the `steps.idx` join and model names to `responseModel`/step model info. `.pb` history in the default stores requires the corresponding App/IDE language server to be running; when several servers are open, the parser tries the others for unreadable conversations. Unavailable legacy history produces a warning and preserves prior sync state. |
 | 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. |
 | CodeBuddy | Tencent's CodeBuddy Code CLI (`@tencent-ai/codebuddy-code`). Home is `$CODEBUDDY_CONFIG_DIR` or `~/.codebuddy` (fixture/relocation override: `VIBE_USAGE_CODEBUDDY_DIRS`); transcripts at `projects/<compressed-cwd>/<sessionId>.jsonl`, including nested subagent directories. Only the API-message records' `message.usage` is read: `input_tokens` + `cache_creation_input_tokens` fold into input (the store writes no per-TTL breakdown), `cache_read_input_tokens` stays separate, `output_tokens` is the full completion. Retries and copies dedupe onto one logical call using `message.id`, `providerData.messageId`, or the record id (the CLI leaves `message.id` empty on some builds; `conversationRequestId` is a turn id, never a dedup key). The model comes from `message.model` and falls back to `providerData.requestModelId`/`model`, because successful calls can write `message.model: null`; routing-tier labels are namespaced (`codebuddy-auto`) so they can never match another vendor's price. Prompt text, thinking signatures, and tool payloads are never read. |
 | ZCode | `~/.zcode/cli/db/db.sqlite` (SQLite; reads the `message` table for per-message tokens, model, and project `cwd`/`root`, joined to `session.directory`; fixture/relocation override: `VIBE_USAGE_ZCODE_DB`) |

package/package.json

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

package/src/parsers/antigravity-db.js

@@ -105,7 +105,73 @@ function firstMessage(fields, num) {
   return b ? decodeMessage(b) : undefined;
 }
 
-// ── GeneratorMetadata parsing ─────────────────────────────────────────
+// ── Usage message decoding ────────────────────────────────────────────
+
+/**
+ * Decode one ModelUsage message. The identical wire shape appears in three
+ * carriers — `gen_metadata` chatModel.usage (1.4), that message's per-attempt
+ * retry entries (1.17.2), and `steps.metadata` usage (9) with its retries
+ * (28.2) — so every carrier shares this decoder:
+ *
+ *   modelId           = 1
+ *   inputTokens       = 2
+ *   totalOutputTokens = 3   (visible + thinking)
+ *   cacheCreation     = 4
+ *   cacheReadTokens   = 5
+ *   provider          = 6
+ *   messageId         = 7
+ *   thinkingOutput    = 9
+ *   visibleOutput     = 10
+ *   responseId        = 11
+ *   providerMessageId = 12
+ *
+ * Field 3 is the *total* output: verified on a live store where 3 = 9 + 10 on
+ * every usage row. The bucket schema bills output + reasoning at the output
+ * rate, so thinking must leave `outputTokens` here — leaving it inside counts
+ * every thinking token a second time in 总 Token and once more in cost.
+ */
+function parseUsageMessage(usage) {
+  const inputTokens = firstVarint(usage, 2) || 0;
+  const totalOutputTokens = firstVarint(usage, 3) || 0;
+  const cacheCreationTokens = firstVarint(usage, 4) || 0;
+  const cacheReadTokens = firstVarint(usage, 5) || 0;
+  const thinkingOutputTokens = firstVarint(usage, 9) || 0;
+  const visibleOutputTokens = firstVarint(usage, 10);
+  const outputTokens = visibleOutputTokens === undefined
+    ? Math.max(0, totalOutputTokens - thinkingOutputTokens)
+    : Math.min(visibleOutputTokens, totalOutputTokens);
+  return {
+    modelId: firstVarint(usage, 1) || 0,
+    inputTokens,
+    outputTokens,
+    cacheCreationTokens,
+    cacheReadTokens,
+    // Older blobs omit the visible/reasoning split; the remainder after the
+    // visible part is thinking, and vice versa, so the two always sum to 3.
+    thinkingOutputTokens: Math.max(thinkingOutputTokens, totalOutputTokens - outputTokens),
+    messageId: firstString(usage, 7) || '',
+    responseId: firstString(usage, 11) || '',
+    providerMessageId: firstString(usage, 12) || '',
+    totalOutputTokens,
+  };
+}
+
+/** True when a decoded usage message carries any real token count. */
+export function hasTokenUsage(usage) {
+  return Boolean(usage && (usage.inputTokens || usage.totalOutputTokens ||
+    usage.cacheCreationTokens || usage.cacheReadTokens || usage.thinkingOutputTokens));
+}
+
+/** Decode the usage of every retry entry carried at `fieldNumber` (2 = usage). */
+function parseRetryUsages(fields, fieldNumber) {
+  const out = [];
+  for (const entry of fields.get(fieldNumber) || []) {
+    if (entry.wireType !== 2) continue;
+    const usage = firstMessage(decodeMessage(entry.value), 2);
+    if (usage) out.push(parseUsageMessage(usage));
+  }
+  return out;
+}
 
 /**
  * Parse one gen_metadata blob into a normalized usage record, or null if it
@@ -113,7 +179,8 @@ function firstMessage(fields, num) {
  *
  * @param {Buffer} buf raw protobuf bytes of a GeneratorMetadata row
  * @returns {{inputTokens, outputTokens, cacheReadTokens, thinkingOutputTokens,
- *            responseId, timestamp: Date|null, displayName, responseModel}|null}
+ *            responseId, timestamp: Date|null, displayName, responseModel,
+ *            retryUsages}|null}
  */
 export function parseGenMetadataBlob(buf) {
   const chatModel = firstMessage(decodeMessage(buf), 1);
@@ -122,51 +189,75 @@ export function parseGenMetadataBlob(buf) {
   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 parsed = parseUsageMessage(usage);
+  if (!hasTokenUsage(parsed)) 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,
+    ...parsed,
+    timestamp: seconds ? new Date(seconds * 1000) : null,
     displayName: firstString(chatModel, 21) || '',
     responseModel: firstString(chatModel, 19) || '',
+    retryUsages: parseRetryUsages(chatModel, 17),
   };
 }
 
 /**
- * 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.
+ * Decode the usage a `steps.metadata` blob carries itself. Newer Antigravity
+ * builds stop writing usage into `gen_metadata` while the step keeps it (field
+ * 9), so a store can have a live step stream with no generator usage at all —
+ * the exact shape where the parser used to go silently empty.
  *
- * @param {Buffer} buf
- * @returns {Date|null}
+ * @returns {{usage, retryUsages, modelName, modelId}} usage/entries may be null
  */
-export function parseStepTimestamp(buf) {
-  const meta = decodeMessage(buf);
-  const createdAt = firstMessage(meta, 1);
-  const seconds = createdAt ? firstVarint(createdAt, 1) : undefined;
+function decodeStepUsage(meta) {
+  const usage = firstMessage(meta, 9);
+  const modelInfo = firstMessage(meta, 24);
+  return {
+    usage: usage ? parseUsageMessage(usage) : null,
+    retryUsages: parseRetryUsages(meta, 28),
+    modelName: modelInfo ? (firstString(modelInfo, 12) || firstString(modelInfo, 8) || '') : '',
+    modelId: modelInfo ? (firstVarint(modelInfo, 1) || 0) : 0,
+  };
+}
+
+/** Parse one steps.metadata blob's own usage record (field 9 + retries). */
+export function parseStepUsageBlob(buf) {
+  return decodeStepUsage(decodeMessage(buf));
+}
+
+/**
+ * Extract a step's own clock, regardless of step source. Field 1.1 is the
+ * createdAt this parser has always used (Gemini 3.7 CLI gen_metadata blobs no
+ * longer carry chatStartMetadata, so the step is the remaining clock); field 8
+ * carries a completion timestamp on some builds and only fills in when 1.1 is
+ * absent, so every timestamp that resolved before keeps its exact second.
+ */
+function stepTimestamp(meta) {
+  let seconds;
+  for (const fieldNumber of [1, 8]) {
+    const message = firstMessage(meta, fieldNumber);
+    seconds = message ? firstVarint(message, 1) : undefined;
+    if (seconds) break;
+  }
   if (!seconds) return null;
   const timestamp = new Date(seconds * 1000);
   return Number.isNaN(timestamp.getTime()) ? null : timestamp;
 }
 
+/**
+ * Extract a steps.metadata blob's own timestamp (see {@link stepTimestamp}).
+ *
+ * @param {Buffer} buf
+ * @returns {Date|null}
+ */
+export function parseStepTimestamp(buf) {
+  return stepTimestamp(decodeMessage(buf));
+}
+
 /**
  * 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
@@ -244,11 +335,24 @@ export function readDbUsageRecords(conversationsDir, cascadeId, { strict = false
 }
 
 /**
- * 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.
+ * Read every `steps` row in one pass and derive everything the parser needs
+ * from that same scan:
+ *
+ *  - `usages` — the usage each step carries itself (field 9, plus the field 28
+ *    retry entries). Newer Antigravity builds keep the live usage here instead
+ *    of `gen_metadata`, so a store whose generator rows carry no usage still
+ *    has its tokens on the step.
+ *  - `timestamps` — idx → clock for every step that has one, including the
+ *    system/tool steps that produce no event. Used to timestamp gen_metadata
+ *    rows that no longer embed chatStartMetadata.
+ *  - `events` — user/assistant turns, chronological by idx, for session timing.
+ *
+ * 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) contributes a
+ * timestamp and nothing else.
  */
-export function readDbStepTimestamps(conversationsDir, cascadeId, { strict = false } = {}) {
+export function readDbStepRows(conversationsDir, cascadeId, { strict = false } = {}) {
   let rows;
   try {
     rows = queryCascadeDb(
@@ -258,22 +362,41 @@ export function readDbStepTimestamps(conversationsDir, cascadeId, { strict = fal
     );
   } catch (err) {
     if (isSqliteUnavailableError(err) || strict) throw err;
-    return new Map();
+    return { usages: [], timestamps: new Map(), events: [] };
   }
-  const byIdx = new Map();
+  const usages = [];
+  const timestamps = new Map();
+  const events = [];
   for (const row of rows) {
     if (!row.h) continue;
-    let ts;
+    let meta;
     try {
-      ts = parseStepTimestamp(Buffer.from(row.h, 'hex'));
+      meta = decodeMessage(Buffer.from(row.h, 'hex'));
     } catch {
-      continue;
+      continue; // one malformed blob must not kill the rest
     }
-    if (!ts) continue;
     const idx = Number(row.idx);
-    if (Number.isFinite(idx)) byIdx.set(idx, ts);
+    const timestamp = stepTimestamp(meta);
+    if (timestamp && Number.isFinite(idx)) timestamps.set(idx, timestamp);
+
+    const source = firstVarint(meta, 3);
+    const role = source === STEP_SOURCE_USER
+      ? 'user'
+      : source === STEP_SOURCE_MODEL ? 'assistant' : null;
+    if (role && timestamp) events.push({ role, timestamp });
+
+    const stepUsage = decodeStepUsage(meta);
+    if (!stepUsage.usage && stepUsage.retryUsages.length === 0) continue;
+    usages.push({
+      idx: Number.isFinite(idx) ? idx : null,
+      timestamp,
+      modelName: stepUsage.modelName,
+      modelId: stepUsage.modelId,
+      usage: stepUsage.usage,
+      retryUsages: stepUsage.retryUsages,
+    });
   }
-  return byIdx;
+  return { usages, timestamps, events };
 }
 
 /**
@@ -304,56 +427,3 @@ export function readDbWorkspaceUri(conversationsDir, cascadeId) {
 // 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, { strict = false } = {}) {
-  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) || strict) 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

@@ -4,7 +4,7 @@ import { delimiter, join } from 'node:path';
 import { homedir } from 'node:os';
 import { antigravityConversationDirs, normalizeExtraRoot } from '../extra-roots.js';
 import { aggregateToBuckets, extractSessions } from './aggregate.js';
-import { listDbCascades, readDbUsageRecords, readDbWorkspaceUri, readDbSessionEvents, readDbStepTimestamps, resolveUsageTimestamp } from './antigravity-db.js';
+import { hasTokenUsage, listDbCascades, readDbUsageRecords, readDbWorkspaceUri, readDbStepRows, resolveUsageTimestamp } from './antigravity-db.js';
 
 
 
@@ -310,13 +310,152 @@ function listPbCascades(conversationsDir) {
 
 // ── Main parse ───────────────────────────────────────────────────────
 
-/** Model name for an offline .db record: real display name → slug → unknown. */
+// Model ids (`GeneratorMetadata` chatModel field 3 / `ModelUsage` field 1) for
+// the models current builds serve. Cross-verified against the ccusage
+// Antigravity adapter's id table, which decodes the same wire format; an id
+// outside this table falls through to the cascade's last named model rather
+// than inventing a placeholder nobody can price.
+const MODEL_ID_NAMES = {
+  246: 'gemini-2.5-pro',
+  312: 'gemini-2.5-flash',
+  313: 'gemini-2.5-flash-thinking',
+  329: 'gemini-2.5-flash-thinking',
+  330: 'gemini-2.5-flash-lite',
+  281: 'claude-4-sonnet',
+  282: 'claude-4-sonnet',
+  290: 'claude-4-opus',
+  291: 'claude-4-opus',
+  333: 'claude-4.5-sonnet',
+  334: 'claude-4.5-sonnet',
+  340: 'claude-4.5-haiku',
+  341: 'claude-4.5-haiku',
+  342: 'gpt-oss-120b-medium',
+  1071: 'gemini-3.6-flash-high',
+  1072: 'gemini-3.6-flash-medium',
+  1073: 'gemini-3.6-flash-low',
+  1298: 'gemini-3.7-flash-high',
+  1299: 'gemini-3.7-flash-medium',
+  1300: 'gemini-3.7-flash-low',
+  1318: 'gemini-3.8-flash-high',
+  1319: 'gemini-3.8-flash-medium',
+  1320: 'gemini-3.8-flash-low',
+};
+
+/** Model name for a .db usage record: display name → slug → step model → id. */
 function modelFromRecord(rec) {
   if (rec.displayName) return rec.displayName;
   if (rec.responseModel) return normalizeModel(rec.responseModel);
+  if (rec.modelName) return normalizeModel(rec.modelName);
+  if (rec.modelId && MODEL_ID_NAMES[rec.modelId]) return MODEL_ID_NAMES[rec.modelId];
   return 'unknown';
 }
 
+/** Identity keys naming one provider call; any shared key links two records. */
+function usageIdentityKeys(rec) {
+  const keys = [];
+  if (rec.responseId) keys.push(`response:${rec.responseId}`);
+  if (rec.providerMessageId) keys.push(`provider:${rec.providerMessageId}`);
+  if (rec.messageId) keys.push(`message:${rec.messageId}`);
+  return keys;
+}
+
+/** Ranking used to keep the richest copy of one call. */
+function usageScore(rec) {
+  return (rec.inputTokens || 0) + (rec.totalOutputTokens || 0) +
+    (rec.cacheReadTokens || 0) + (rec.cacheCreationTokens || 0);
+}
+
+/** Keep the richest payload, borrowing the loser's clock and model name. */
+function richerUsageRecord(a, b) {
+  const [rich, poor] = usageScore(b) > usageScore(a) ? [b, a] : [a, b];
+  return {
+    ...rich,
+    timestamp: rich.timestamp ?? poor.timestamp ?? null,
+    displayName: rich.displayName || poor.displayName || '',
+    responseModel: rich.responseModel || poor.responseModel || '',
+  };
+}
+
+/**
+ * Merge one cascade's usage records from the two tables that can carry them.
+ *
+ * Older stores write every call into `gen_metadata`; newer builds keep the live
+ * usage on the *step* instead, so a cascade can have a moving step stream and no
+ * generator usage at all — the shape where this parser used to go silently
+ * empty while its session timing kept advancing. Both carriers name a call by
+ * the provider's response id and, on some builds, by message ids only, so two
+ * records are linked by *any* shared identity and the richest payload wins;
+ * counting both would double-bill every turn that both tables saw.
+ *
+ * A step record with no identity at all can only be proven new when the cascade
+ * has no generator usage for it to duplicate; next to generator usage it is
+ * dropped rather than risk the same turn twice.
+ */
+function mergeCascadeUsage(genRecords, stepRows) {
+  const groups = new Set();
+  const byIdentity = new Map();
+
+  const merge = (record) => {
+    const keys = usageIdentityKeys(record);
+    const hits = new Set();
+    for (const key of keys) {
+      const group = byIdentity.get(key);
+      if (group) hits.add(group);
+    }
+    let target;
+    if (hits.size === 0) {
+      target = { rec: record, keys: new Set() };
+      groups.add(target);
+    } else {
+      target = hits.values().next().value;
+      for (const other of hits) {
+        if (other === target) continue;
+        target.rec = richerUsageRecord(target.rec, other.rec);
+        for (const key of other.keys) {
+          byIdentity.set(key, target);
+          target.keys.add(key);
+        }
+        groups.delete(other);
+      }
+      target.rec = richerUsageRecord(target.rec, record);
+    }
+    for (const key of keys) {
+      byIdentity.set(key, target);
+      target.keys.add(key);
+    }
+  };
+
+  for (const rec of genRecords) {
+    merge(rec);
+    // Retry entries repeat the call they belong to (same response id), so they
+    // collapse into it; a genuine extra attempt keeps its own id and counts.
+    for (const retry of rec.retryUsages || []) merge({ ...retry, timestamp: rec.timestamp });
+  }
+  const stepUsageStandsAlone = genRecords.length === 0;
+  for (const row of stepRows.usages) {
+    for (const usage of [row.usage, ...row.retryUsages]) {
+      if (!hasTokenUsage(usage)) continue;
+      if (!stepUsageStandsAlone && usageIdentityKeys(usage).length === 0) continue;
+      merge({
+        ...usage,
+        timestamp: row.timestamp,
+        displayName: '',
+        responseModel: '',
+        modelName: row.modelName,
+      });
+    }
+  }
+
+  // Records merged in first-seen order; resolve each model, carrying the
+  // cascade's last named model onto records that only carry an id.
+  let carriedModel = '';
+  return [...groups].map((group) => {
+    const model = modelFromRecord(group.rec);
+    if (model !== 'unknown') carriedModel = model;
+    return { ...group.rec, model: model === 'unknown' ? carriedModel || 'unknown' : model };
+  });
+}
+
 export async function parse({ extraRoots = [] } = {}) {
   const entries = [];
   const sessionEvents = [];
@@ -396,11 +535,13 @@ export async function parse({ extraRoots = [] } = {}) {
     if (selected && selected.dir !== dir) continue;
     try {
       const options = { strict };
-      const records = readDbUsageRecords(dir, cascadeId, options);
+      // One steps scan feeds all of it: the usage newer builds keep on the step
+      // (which `gen_metadata` no longer carries), the idx → clock fallback for
+      // generator rows that lost their own timestamp, and session events.
+      const stepRows = readDbStepRows(dir, cascadeId, options);
+      const genRecords = readDbUsageRecords(dir, cascadeId, options);
       const project = projectFromUri(readDbWorkspaceUri(dir, cascadeId)) || 'unknown';
-      const stepTimestampsByIdx = records.some((rec) => !rec.timestamp || isNaN(rec.timestamp.getTime()))
-        ? readDbStepTimestamps(dir, cascadeId, options)
-        : new Map();
+      const records = mergeCascadeUsage(genRecords, stepRows);
 
       if (records.length > 0) {
         dbHandled.add(cascadeId);
@@ -408,25 +549,30 @@ export async function parse({ extraRoots = [] } = {}) {
           if (rec.responseId && seenResponseIds.has(rec.responseId)) continue;
           if (rec.responseId) seenResponseIds.add(rec.responseId);
           // 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);
+          // and modelDisplayName (21); newer stores drop generator usage
+          // altogether and keep it on the step. Either way the clock comes from
+          // the record itself or from steps.metadata at the same idx.
+          const timestamp = resolveUsageTimestamp(rec, stepRows.timestamps);
           if (!timestamp || isNaN(timestamp.getTime())) continue;
           entries.push({
             source: SOURCE,
-            model: modelFromRecord(rec),
+            model: rec.model,
             project,
             timestamp,
             inputTokens: toSafeNumber(rec.inputTokens),
             outputTokens: toSafeNumber(rec.outputTokens),
             cachedInputTokens: toSafeNumber(rec.cacheReadTokens),
+            // The store carries one untyped cache-write count; an unexplained
+            // total belongs in the cheaper 5m tier (see the cache-write rule in
+            // AGENTS.md).
+            cacheCreation5mTokens: toSafeNumber(rec.cacheCreationTokens),
             reasoningOutputTokens: toSafeNumber(rec.thinkingOutputTokens),
           });
         }
       }
 
-      // Session timing from steps (independent of token usage presence).
-      for (const ev of readDbSessionEvents(dir, cascadeId, options)) {
+      // Session timing from the same steps scan (independent of token usage).
+      for (const ev of stepRows.events) {
         sessionEvents.push({
           sessionId: cascadeId,
           source: SOURCE,
@@ -497,15 +643,22 @@ export async function parse({ extraRoots = [] } = {}) {
             const responseId = usage.responseId || '';
             if (responseId && seenResponseIds.has(responseId)) continue;
             if (responseId) seenResponseIds.add(responseId);
+            // The language server serializes the same GeneratorMetadata
+            // protobuf the .db rows carry, where `outputTokens` (field 3) is
+            // the total and thinking is one part of it — billed at the same
+            // output rate, but only once.
+            const totalOutputTokens = toSafeNumber(usage.outputTokens);
+            const thinkingOutputTokens = toSafeNumber(usage.thinkingOutputTokens);
+            const outputTokens = Math.max(0, totalOutputTokens - thinkingOutputTokens);
             entries.push({
               source: SOURCE,
               model,
               project,
               timestamp: ts,
               inputTokens: toSafeNumber(usage.inputTokens),
-              outputTokens: toSafeNumber(usage.outputTokens),
+              outputTokens,
               cachedInputTokens: toSafeNumber(usage.cacheReadTokens),
-              reasoningOutputTokens: toSafeNumber(usage.thinkingOutputTokens),
+              reasoningOutputTokens: Math.max(thinkingOutputTokens, totalOutputTokens - outputTokens),
             });
           }
         }

package/src/parsers/codex-cache.js

@@ -14,7 +14,7 @@ import { join } from 'node:path';
 // separate from ~/.vibe-usage/state.json, whose hashes are the authoritative
 // record of successful uploads and must remain backward-compatible.
 export const CODEX_CACHE_SCHEMA_VERSION = 1;
-export const CODEX_PARSER_ALGORITHM_VERSION = 4;
+export const CODEX_PARSER_ALGORITHM_VERSION = 5;
 
 function hash(value, length = 24) {
   return createHash('sha256').update(value).digest('hex').slice(0, length);

package/src/parsers/codex-segments.js

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { normalizeUsageRecord } from './codex-usage-record.js';
 
 const hash = value => createHash('sha256').update(JSON.stringify(value)).digest('base64url');
 function pick(value, keys) {
@@ -10,6 +11,7 @@ const usageKeys = ['input_tokens', 'output_tokens', 'cached_input_tokens', 'cach
 // Retain only fields consumed by the existing token/timing parser. Full JSON is
 // hashed transiently to identify exact copies; chat/tool text is never retained.
 function accountingRecord(obj, context) {
+  obj = normalizeUsageRecord(obj);
   const next = { type: obj.type, timestamp: obj.timestamp };
   const p = obj.payload;
   if (obj.type === 'session_meta' && p) {
@@ -22,7 +24,7 @@ function accountingRecord(obj, context) {
   } else if (obj.type === 'turn_context') {
     next.payload = pick(p, ['model', 'service_tier']);
   } else if (obj.type === 'event_msg' && p) {
-    next.payload = pick(p, ['type', 'started_at', 'model']);
+    next.payload = pick(p, ['type', 'started_at', 'model', 'usage_record']);
     if (p.type === 'token_count') {
       next._tokenFingerprint = hash(p).slice(0, 16);
       next._segmentContext = { ...context };

package/src/parsers/codex-usage-record.js

@@ -0,0 +1,29 @@
+// Codex writes usage twice for the same request: once as the UI-facing
+// `event_msg` / `token_count`, and once as a durable `token_usage_record`.
+// The UI event can be missing entirely — an interrupted or crashed call never
+// reaches the point where it is emitted — while the durable record still lands,
+// so counting only the UI form under-reports real usage.
+//
+// Rewrite the durable form into the shape the parser already understands, and
+// keep a `usage_record` marker so the UI event that mirrors the same request is
+// not counted a second time when its cumulative total lags.
+export function normalizeUsageRecord(obj) {
+  if (obj?.type !== 'token_usage_record') return obj;
+  const p = obj.payload;
+  const usage = p?.usage;
+  const total = p?.thread_token_usage;
+  if (!usage || !total || !Number.isFinite(total.total_tokens) || total.total_tokens <= 0) return obj;
+  for (const value of [usage.input_tokens, usage.output_tokens, usage.cached_input_tokens ?? 0, usage.reasoning_output_tokens ?? 0]) {
+    if (!Number.isFinite(value) || value < 0) return obj;
+  }
+  return { ...obj, type: 'event_msg', payload: {
+    type: 'token_count', usage_record: true,
+    info: { last_token_usage: pickUsage(usage), total_token_usage: pickUsage(total) },
+  }};
+}
+
+function pickUsage(value) {
+  const keys = ['input_tokens', 'output_tokens', 'cached_input_tokens', 'cache_read_input_tokens',
+    'cache_write_input_tokens', 'reasoning_output_tokens', 'total_tokens'];
+  return Object.fromEntries(keys.filter(key => Number.isFinite(value[key])).map(key => [key, value[key]]));
+}

package/src/parsers/codex.js

@@ -1,3 +1,4 @@
+import { normalizeUsageRecord } from './codex-usage-record.js';
 import {
   closeSync,
   createReadStream,
@@ -139,7 +140,7 @@ async function readSessionHeader(filePath, snapshotSize) {
   for await (const line of readLines(filePath, snapshotSize)) {
     if (!line.trim()) continue;
     try {
-      const obj = JSON.parse(line);
+      const obj = normalizeUsageRecord(JSON.parse(line));
       if (obj.type !== 'session_meta' || !obj.payload) continue;
       const meta = obj.payload;
       return {
@@ -338,7 +339,7 @@ async function indexSessionFile(filePath, snapshotSize, lines = null) {
   for await (const line of (lines ?? readLines(filePath, snapshotSize))) {
     if (!line.trim()) continue;
     try {
-      const obj = JSON.parse(line);
+      const obj = normalizeUsageRecord(JSON.parse(line));
       parsedRecordCount++;
 
       const recordTimestamp = timestampMs(obj.timestamp);
@@ -635,12 +636,20 @@ async function parseSessionFile(filePath, snapshotSize, fm, boundary, {
   let serviceTier = previousTail?.serviceTier || null;
   let prevTotal = previousTail?.prevTotal || null;
   let prevCumulativeTotal = previousTail?.prevCumulativeTotal ?? null;
+  // Durable records and UI counters are separate series whose cumulative totals
+  // can diverge after an interrupted call, so each keeps its own baseline.
+  let prevRecordTotal = previousTail?.prevRecordTotal ?? null;
+  let pendingUsageMirror = previousTail?.pendingUsageMirror ?? null;
   const start = previousTail?.parsedBytes || 0;
   for await (const line of (lines ?? readLines(filePath, snapshotSize, start))) {
     if (!line.trim()) continue;
     try {
-      const obj = JSON.parse(line);
+      const obj = normalizeUsageRecord(JSON.parse(line));
       parsedRecordIndex++;
+      // A resumed or new turn cannot be the delayed mirror of the preceding
+      // request, so the marker must not survive a turn boundary.
+      if (obj.type === 'session_meta' || obj.type === 'turn_context' || obj.type === 'token_usage_record'
+          || (obj.type === 'event_msg' && isTaskStarted(obj.payload))) pendingUsageMirror = null;
 
         // A direct child task boundary covers every copied record, including
         // timing/meta events. The raw-token ordinal covers full-history and
@@ -717,11 +726,21 @@ async function parseSessionFile(filePath, snapshotSize, fm, boundary, {
         // 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 isUsageRecord = payload.usage_record === true;
+      // The durable record and the UI event describe the same request, but their
+      // cumulative counters can diverge after an interrupted call, so the match
+      // is on per-request usage. The marker survives appends because the mirror
+      // can arrive in a later read.
+      const isMirror = !isUsageRecord && pendingUsageMirror && sameRequestUsage(pendingUsageMirror, info.last_token_usage);
+      pendingUsageMirror = isUsageRecord ? info.last_token_usage : null;
       const cumulativeTotal = info.total_token_usage?.total_tokens;
       const isDuplicateEmission = typeof cumulativeTotal === 'number'
         && cumulativeTotal > 0
-        && cumulativeTotal === prevCumulativeTotal;
-      if (typeof cumulativeTotal === 'number') prevCumulativeTotal = cumulativeTotal;
+        && cumulativeTotal === (isUsageRecord ? prevRecordTotal : prevCumulativeTotal);
+      if (typeof cumulativeTotal === 'number') {
+        if (isUsageRecord) prevRecordTotal = cumulativeTotal;
+        else prevCumulativeTotal = cumulativeTotal;
+      }
 
         // Prefer incremental per-request usage; compute delta from cumulative
         // totals as fallback. Always advance the cumulative baseline, even
@@ -749,7 +768,7 @@ async function parseSessionFile(filePath, snapshotSize, fm, boundary, {
         // avoids counting the full cumulative total again after a model switch.
       if (curr) prevTotal = { ...curr };
       if (!usage) continue;
-      if (isReplayedHistory || isDuplicateEmission) continue;
+      if (isReplayedHistory || isDuplicateEmission || isMirror) continue;
 
       const timestamp = obj.timestamp ? new Date(obj.timestamp) : null;
       if (!timestamp || isNaN(timestamp.getTime())) continue;
@@ -816,6 +835,8 @@ async function parseSessionFile(filePath, snapshotSize, fm, boundary, {
       serviceTier,
       prevTotal,
       prevCumulativeTotal,
+      prevRecordTotal,
+      pendingUsageMirror,
       buckets,
       sessionAccumulator,
       guardHash: guard.hash,
@@ -1171,6 +1192,12 @@ async function parseNativeCodex({ codexExtraHome, extraRoots = [] } = {}) {
   return { ...mergeFileResults(results), cache: cacheStats };
 }
 
+function sameRequestUsage(left, right) {
+  if (!left || !right) return false;
+  return ['input_tokens', 'cached_input_tokens', 'output_tokens', 'reasoning_output_tokens']
+    .every(key => (left[key] || 0) === (right[key] || 0));
+}
+
 export async function parse(options = {}) {
   const nativeResult = await parseNativeCodex(options);
   return mergeCindyHarnessUsage(nativeResult, readCindyHarnessUsage('codex'));