@vibe-cafe/vibe-usage 0.14.1 → 0.14.2

package/package.json

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

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'));