@vibe-cafe/vibe-usage 0.14.2 → 0.14.4

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`) |
@@ -144,6 +144,7 @@ To relabel old history, the maintainer needs the old bucket keys, raw per-tool t
 - 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. Multi-file sessions have a combined cache that rebuilds when any segment changes. A bounded rolling audit occasionally re-reads one historical file or continuation group. Very large first-time indexes checkpoint before the Mac app timeout and resume on the next sync instead of restarting
+- Interactive `sync` shows a live status line (`正在读取上传设置` → `正在扫描本地日志 12/35 · 已用时 2m10s`) while it reads backend settings and scans/indexes local logs. A first sync, a cold Codex index rebuild, or a slow `cursor.com` export can take minutes, so that line is what separates a slow sync from a hung one. It is printed only on a TTY — the Mac and Windows apps read the piped stdout as the result text and must keep receiving plain output. Interrupting a sync is safe: finished batches are already committed, and the Codex index checkpoints and resumes on the next run
 - The Codex parser cache contains derived aggregates and replay metadata, not raw prompt or response text. It is independent of upload state and can be deleted safely (the next sync rebuilds it). `reset` intentionally keeps it so the required full re-upload does not also require a full disk rescan. Set `VIBE_USAGE_CODEX_CACHE=0` to disable the optimization for diagnosis
 - SQLite-backed tools are read via Node's built-in `node:sqlite` on Node ≥ 22.5 — no `sqlite3` binary needed (works on Windows out of the box); on older Node the CLI falls back to the system `sqlite3` executable
 - Continuous syncing is on by default: the first run installs a background service (see [Background sync](#background-sync)); the [Vibe Usage Mac app](https://github.com/vibe-cafe/vibe-usage-app) is the menu-bar alternative

package/package.json

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

package/src/output.js

@@ -52,6 +52,65 @@ export function hint(msg) {
   console.log(dim(`提示: ${msg}`));
 }
 
+/**
+ * One redrawn status line for a phase that would otherwise leave the terminal
+ * blank for minutes: the settings round-trip (a timing-out endpoint re-trying),
+ * the local log scan, and a cold Codex index build. Without it the sync header
+ * is the last thing on screen, and "still working" is indistinguishable from
+ * "hung" — exactly how a slow first sync reads.
+ *
+ * TTY-only for the same reason as hint(): the Mac (`SyncEngine.swift`) and
+ * Windows (`sync_engine.rs`) apps run `sync` through a pipe and treat stdout as
+ * the result text, so a pipe must never receive these lines.
+ * `VIBE_USAGE_FORCE_PROGRESS=1` forces them on for tests, and
+ * `VIBE_USAGE_PROGRESS_INTERVAL_MS` overrides the redraw interval.
+ *
+ * `label` is a function so the caller owns the wording and its elapsed-time
+ * text; it is re-read on every redraw. The interval is unref'ed so a phase that
+ * never reaches `stop()` cannot hold the process open.
+ */
+export function liveStatus({ enabled = true, intervalMs } = {}) {
+  const configuredInterval = Number(process.env.VIBE_USAGE_PROGRESS_INTERVAL_MS);
+  const tickMs = intervalMs ?? (configuredInterval > 0 ? configuredInterval : 5000);
+  const active = enabled
+    && (!!process.stdout.isTTY || process.env.VIBE_USAGE_FORCE_PROGRESS === '1');
+  let label = null;
+  let timer = null;
+  let startedAt = 0;
+
+  function draw() {
+    if (label === null) return;
+    process.stdout.write(`\r${dim(`  ${label(Date.now() - startedAt)}`)}\x1b[K`);
+  }
+
+  return {
+    /** Show the line, or retarget it to the next phase. */
+    start(nextLabel) {
+      if (!active) return;
+      label = nextLabel;
+      startedAt = Date.now();
+      draw();
+      if (timer === null) {
+        timer = setInterval(draw, tickMs);
+        unrefTimer(timer);
+      }
+    },
+    /** Erase the line before regular output continues on it. */
+    stop() {
+      if (!active || label === null) return;
+      clearInterval(timer);
+      timer = null;
+      label = null;
+      process.stdout.write('\r\x1b[K');
+    },
+  };
+}
+
+/** Bun's timer objects and Node's both expose unref; tests run on either. */
+function unrefTimer(timer) {
+  if (typeof timer?.unref === 'function') timer.unref();
+}
+
 /** Print a blank line. */
 export const nl = () => console.log();
 

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/sync.js

@@ -11,7 +11,7 @@ import { aggregateToBuckets } from './parsers/aggregate.js';
 import { normalizeParserResult } from './parsers/contract.js';
 import { extraRootList } from './extra-roots.js';
 import { planKikiMigration } from './kiki-migration.js';
-import { success, failure, warn, arrow, link, dim } from './output.js';
+import { success, failure, warn, arrow, link, dim, liveStatus } from './output.js';
 
 const BATCH_SIZE = 100;
 const SESSION_BATCH_SIZE = 500;
@@ -44,6 +44,11 @@ function formatBytes(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
 }
 
+/** Elapsed-time suffix for the live status line (`formatDuration` rounds 0 to `0s`). */
+function phaseElapsed(elapsedMs) {
+  return ` · 已用时 ${formatDuration(elapsedMs / 1000)}`;
+}
+
 export function resolveUploadProjectSetting(settings) {
   if (typeof settings?.uploadProject !== 'boolean') {
     const error = new Error('SETTINGS_UNAVAILABLE');
@@ -127,6 +132,13 @@ export async function runSync({
   // Built from the same `apiUrl` the ingest calls below use, so the recorded
   // target and the actual target can never drift apart.
   const identity = stateIdentity({ apiUrl, apiKey: config.apiKey });
+  // Both the settings round-trip and the log scan below can run for minutes on
+  // a cold or proxied machine (a timing-out endpoint retrying, a cold Codex
+  // index, a 120s Cursor export). A live status line keeps that work
+  // distinguishable from a hang; it never reaches a pipe, so the desktop apps
+  // keep parsing bare result text from stdout.
+  const status = liveStatus({ enabled: !quiet });
+  status.start(elapsedMs => `正在读取上传设置${phaseElapsed(elapsedMs)}`);
   let uploadProject;
   try {
     const settings = await fetchSettings(apiUrl, config.apiKey);
@@ -143,6 +155,7 @@ export async function runSync({
       saveConfig(config);
     }
   } catch (err) {
+    status.stop();
     if (err.message === 'UNAUTHORIZED') {
       console.error(failure('API Key 无效，请运行 `npx @vibe-cafe/vibe-usage init` 重新配置。'));
       if (throws) throw err;
@@ -173,8 +186,11 @@ export async function runSync({
   // Run parsers concurrently (bounded) so one slow parser (Cursor's network
   // fetch, a cold Codex index) can't stall the rest. Results are collected in
   // registry order so output and merged arrays stay deterministic.
+  const parserRegistry = Object.entries(parsers);
+  let parsedSources = 0;
+  status.start(elapsedMs => `正在扫描本地日志 ${parsedSources}/${parserRegistry.length}${phaseElapsed(elapsedMs)}`);
   const parserOutcomes = await mapWithConcurrency(
-    Object.entries(parsers),
+    parserRegistry,
     PARSER_CONCURRENCY,
     async ([source, parse]) => {
       try {
@@ -187,9 +203,12 @@ export async function runSync({
         return { source, result };
       } catch (err) {
         return { source, error: err };
+      } finally {
+        parsedSources++;
       }
     },
   );
+  status.stop();
 
   for (const { source, result, error } of parserOutcomes) {
     if (error) {