@vibe-cafe/vibe-usage 0.10.32 → 0.10.33

package/README.md

@@ -92,6 +92,7 @@ npx @vibe-cafe/vibe-usage help --all   # Full help (plain `help` shows the short
 | 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`) |
 | Qoder | International edition (qoder.com). IDE store `~/Library/Application Support/Qoder/SharedClientCache/cache/db/local.db` (Windows `%APPDATA%\Qoder`, Linux `~/.config/Qoder`; honors `QODER_HOME`, fixture override `VIBE_USAGE_QODER_DB`) gives real tokens from `chat_message.token_info` (prompt includes cached; split out) with `model_key` usually a routing tier, reported as `qoder-auto` / `qoder-ultimate` / … so it never collides with a priced model id; message content is never selected, and lock/schema failures fall back to a snapshot or `skipped`. CLI + desktop app transcripts `~/.qoder/projects/**/*.jsonl` (honors `QODER_CONFIG_DIR`, fixture override `VIBE_USAGE_QODER_PROJECTS`; sub-agents under `<session>/subagents/`) are credit-billed with every token field at 0, so they contribute sessions only — credits are account funding and are not collected |
 | Qoder CN | China edition (qoder.com.cn, separate account). Same two shapes under `~/Library/Application Support/QoderCN/SharedClientCache/cache/db/local.db` (`QODER_CN_HOME` / `VIBE_USAGE_QODER_CN_DB`) and `~/.qoder-cn/projects/` (`QODERCN_CONFIG_DIR` / `VIBE_USAGE_QODER_CN_PROJECTS`); reported as source `qoder-cn` |
+| Devin | `$XDG_DATA_HOME/devin/cli/sessions.db` (default `~/.local/share/devin/cli/sessions.db`; fixture override `VIBE_USAGE_DEVIN_DB`). Devin CLI and Devin Desktop share this one WAL store. Reads only allow-listed fields from `message_nodes.chat_message` via `json_extract` — per-request `metadata.metrics` token counters on assistant messages, `generation_model`, `is_user_input`, timestamps — joined to `sessions.working_directory`/`model`; message content and the session credit/ACU billing fields are never selected. Cache writes fold into input, cache reads stay separate. The node forest stores some logical messages at several nodes, so rows are deduplicated by session + message id. Synthetic user records (cache keepalives) are not counted as human prompts |
 
 ## How It Works
 

package/package.json

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

package/src/parsers/aggregate.js

@@ -52,6 +52,12 @@ export function aggregateToBuckets(entries) {
         outputTokens: 0,
         cachedInputTokens: 0,
         reasoningOutputTokens: 0,
+        // Prompt-cache *writes*, split by TTL. Anthropic prices them at 1.25x
+        // (5m) and 2x (1h) the base input rate, so they cannot be folded into
+        // inputTokens without under-billing. Parsers that cannot tell the two
+        // TTLs apart leave these at 0 and keep their existing behaviour.
+        cacheCreation5mTokens: 0,
+        cacheCreation1hTokens: 0,
       });
     }
 
@@ -60,6 +66,8 @@ export function aggregateToBuckets(entries) {
     b.outputTokens += e.outputTokens || 0;
     b.cachedInputTokens += e.cachedInputTokens || 0;
     b.reasoningOutputTokens += e.reasoningOutputTokens || 0;
+    b.cacheCreation5mTokens += e.cacheCreation5mTokens || 0;
+    b.cacheCreation1hTokens += e.cacheCreation1hTokens || 0;
   }
 
   // Clamp after summation, not per entry — rounding each entry first would
@@ -69,13 +77,22 @@ export function aggregateToBuckets(entries) {
     const outputTokens = toTokenCount(b.outputTokens);
     const cachedInputTokens = toTokenCount(b.cachedInputTokens);
     const reasoningOutputTokens = toTokenCount(b.reasoningOutputTokens);
+    const cacheCreation5mTokens = toTokenCount(b.cacheCreation5mTokens);
+    const cacheCreation1hTokens = toTokenCount(b.cacheCreation1hTokens);
     return {
       ...b,
       inputTokens,
       outputTokens,
       cachedInputTokens,
       reasoningOutputTokens,
-      totalTokens: inputTokens + outputTokens + reasoningOutputTokens,
+      cacheCreation5mTokens,
+      cacheCreation1hTokens,
+      // Cache writes stay inside totalTokens: they used to arrive folded into
+      // inputTokens, and the server uses this field only as a `> 0` liveness
+      // filter. Keeping them in makes the number bit-identical to what the same
+      // logs produced before the split, so no bucket drops out of any view.
+      totalTokens: inputTokens + outputTokens + reasoningOutputTokens +
+        cacheCreation5mTokens + cacheCreation1hTokens,
     };
   });
 }

package/src/parsers/claude-code.js

@@ -57,15 +57,48 @@ function projectFromRelative(relative) {
   return parts.at(-1) || 'unknown';
 }
 
-function cacheCreationTokens(usage) {
+/**
+ * Cache-creation (prompt-cache write) tokens, split by TTL.
+ *
+ * Anthropic bills the two TTLs at different multiples of the base input rate
+ * (5-minute writes 1.25x, 1-hour writes 2x — platform.claude.com/docs/en/
+ * about-claude/pricing), so the split is a price-changing dimension and has to
+ * survive to the server. Folding both into `input_tokens` (what this parser did
+ * before 2026-09-16) under-billed every Claude bucket by 13-33%.
+ *
+ * Current Claude logs carry both the `cache_creation_input_tokens` total and its
+ * `cache_creation` TTL breakdown. When the breakdown is missing, or adds up to
+ * less than the total, the unexplained remainder is booked to the **5m** bucket:
+ * that is the cheaper of the two multipliers, so a partially populated log can
+ * only ever under-state cost, never over-state it. This preserves the old
+ * max(direct, split) total exactly — only its attribution is new.
+ */
+function cacheCreationSplit(usage) {
   const direct = toCount(usage.cache_creation_input_tokens);
   const breakdown = usage.cache_creation || {};
-  const split =
-    toCount(breakdown.ephemeral_5m_input_tokens) +
-    toCount(breakdown.ephemeral_1h_input_tokens);
-  // Current Claude logs carry both the total and its TTL breakdown. max()
-  // avoids double-counting while remaining tolerant of partially populated logs.
-  return Math.max(direct, split);
+  const fiveMinute = toCount(breakdown.ephemeral_5m_input_tokens);
+  const oneHour = toCount(breakdown.ephemeral_1h_input_tokens);
+  const split = fiveMinute + oneHour;
+  if (split >= direct) return { fiveMinute, oneHour };
+  return { fiveMinute: fiveMinute + (direct - split), oneHour };
+}
+
+// Fast mode (research preview, Claude Opus 5 / Opus 4.8) is billed at 2x the
+// standard input and output rate, with the cache multipliers stacking on top.
+// Claude Code records it as `message.usage.speed` ('standard' | 'fast'); accept
+// `message.speed` too so a build that moves the field keeps working. The server
+// pricing map keys the premium rate off a trailing `-fast` marker
+// (TIER_MARKER_SUFFIX -> tiers.priority), so tag the model here. A model with no
+// published priority tier falls back to its base rate server-side, which makes
+// the marker safe to append unconditionally.
+function isFastMode(usage, message) {
+  const speed = usage?.speed ?? message?.speed;
+  return typeof speed === 'string' && speed.trim().toLowerCase() === 'fast';
+}
+
+function applySpeedMarker(model, fast) {
+  if (!fast || !model) return model;
+  return model.endsWith('-fast') ? model : `${model}-fast`;
 }
 
 function candidateIsBetter(next, current) {
@@ -225,13 +258,20 @@ async function scanProjectCandidate(candidate) {
       ? obj.message.model.trim()
       : '';
     if (rawModel && rawModel !== '<synthetic>') lastModel = rawModel;
-    const model = rawModel && rawModel !== '<synthetic>'
+    const baseModel = rawModel && rawModel !== '<synthetic>'
       ? rawModel
       : lastModel || 'claude-unknown';
-    const inputTokens = toCount(usage.input_tokens) + cacheCreationTokens(usage);
+    const model = applySpeedMarker(baseModel, isFastMode(usage, obj.message));
+    const cacheCreation = cacheCreationSplit(usage);
+    const inputTokens = toCount(usage.input_tokens);
     const outputTokens = toCount(usage.output_tokens);
     const cachedInputTokens = toCount(usage.cache_read_input_tokens);
-    const usageScore = inputTokens + outputTokens + cachedInputTokens;
+    const cacheCreation5mTokens = cacheCreation.fiveMinute;
+    const cacheCreation1hTokens = cacheCreation.oneHour;
+    // Unchanged from when cache writes lived inside inputTokens, so the
+    // "keep the most complete duplicate" ranking keeps its old ordering.
+    const usageScore = inputTokens + outputTokens + cachedInputTokens +
+      cacheCreation5mTokens + cacheCreation1hTokens;
 
     // Synthetic bookkeeping messages are common and carry zero usage. Do not
     // inflate the CLI's bucket count with rows the server will discard anyway.
@@ -248,6 +288,8 @@ async function scanProjectCandidate(candidate) {
       outputTokens,
       cachedInputTokens,
       reasoningOutputTokens: 0,
+      cacheCreation5mTokens,
+      cacheCreation1hTokens,
     });
   });
 

package/src/parsers/devin.js

@@ -0,0 +1,184 @@
+import { existsSync } from 'node:fs';
+import { projectFromPath, toCount } from './fs-utils.js';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import {
+  queryDbJsonSnapshotOnLock,
+  isSqliteUnavailableError,
+  sqliteUnavailableError,
+} from './sqlite.js';
+import { getDevinDbPath } from '../tools.js';
+
+const SOURCE = 'devin';
+
+// Devin (the CLI and the Desktop app's embedded agent share one backend) keeps
+// every session in a single WAL SQLite database,
+// $XDG_DATA_HOME/devin/cli/sessions.db (default ~/.local/share/devin/cli/
+// sessions.db). Per-request token usage lives inside
+// message_nodes.chat_message → metadata.metrics on assistant rows:
+// input_tokens is the uncached prompt portion, cache_creation_tokens and
+// cache_read_tokens are separate counters, and output_tokens is the full
+// completion (there is no separate reasoning field).
+//
+// message_nodes is a forest: the same logical message can be stored at several
+// adjacent nodes (verified on a live DB — duplicated rows carry byte-identical
+// metrics), so rows are deduplicated by (session_id, message_id). Only
+// allow-listed identity/accounting fields are extracted via json_extract;
+// message content, cogs_json, and sessions.metadata (which carries
+// credit/ACU billing totals — account funding, never collected) are never
+// selected.
+const NODE_COLUMNS = ['session_id', 'node_id', 'chat_message', 'created_at'];
+const SESSION_COLUMNS = ['id', 'working_directory', 'model'];
+
+const USAGE_SQL = `
+  SELECT
+    m.session_id AS sessionId,
+    m.row_id AS rowId,
+    m.created_at AS nodeCreated,
+    json_extract(m.chat_message, '$.message_id') AS messageId,
+    json_extract(m.chat_message, '$.role') AS role,
+    json_extract(m.chat_message, '$.metadata.is_user_input') AS isUserInput,
+    json_extract(m.chat_message, '$.metadata.created_at') AS msgCreatedAt,
+    json_extract(m.chat_message, '$.metadata.generation_model') AS generationModel,
+    json_extract(m.chat_message, '$.metadata.metrics.input_tokens') AS inputTokens,
+    json_extract(m.chat_message, '$.metadata.metrics.output_tokens') AS outputTokens,
+    json_extract(m.chat_message, '$.metadata.metrics.cache_read_tokens') AS cacheReadTokens,
+    json_extract(m.chat_message, '$.metadata.metrics.cache_creation_tokens') AS cacheCreationTokens,
+    s.working_directory AS workingDir,
+    s.model AS sessionModel
+  FROM message_nodes AS m
+  LEFT JOIN sessions AS s ON s.id = m.session_id
+`;
+
+export function resolveDevinDbPath(env = process.env, home) {
+  return getDevinDbPath(env, home);
+}
+
+/**
+ * Per-message instant: metadata.created_at is an ISO-8601 string with
+ * millisecond precision; the node column is integer unix seconds (defensive
+ * ms/seconds sniffing matches the sibling parsers).
+ */
+function resolveTimestamp(row) {
+  if (typeof row.msgCreatedAt === 'string') {
+    const d = new Date(row.msgCreatedAt);
+    if (!Number.isNaN(d.getTime())) return d;
+  }
+  const n = Number(row.nodeCreated);
+  if (!Number.isFinite(n) || n <= 0) return null;
+  const d = new Date(n < 1e12 ? n * 1000 : n);
+  return Number.isNaN(d.getTime()) ? null : d;
+}
+
+/**
+ * Timing-event role. Only `is_user_input` user rows are human prompts —
+ * Devin writes synthetic user records (e.g. `cache_keepalive` "continue"
+ * prompts) that must not inflate the user-prompt count; they and tool results
+ * still mark agent activity, so they join the assistant side. `system` rows
+ * are prompt-assembly artifacts re-written on resume and are skipped.
+ */
+function eventRole(row) {
+  if (row.role === 'system') return null;
+  if (row.role === 'user' && (row.isUserInput === 1 || row.isUserInput === true)) {
+    return 'user';
+  }
+  return 'assistant';
+}
+
+function dbHasColumns(dbPath, table, columns) {
+  const info = queryDbJsonSnapshotOnLock(
+    dbPath,
+    `PRAGMA table_info(${table})`,
+    { tempPrefix: 'vibe-usage-devin' },
+  );
+  const present = new Set(info.map(row => String(row.name)));
+  return columns.every(col => present.has(col));
+}
+
+export async function parse() {
+  const dbPath = resolveDevinDbPath();
+  if (!existsSync(dbPath)) return { buckets: [], sessions: [] };
+
+  // Schema guard: if a future Devin build renames or drops a relied-upon
+  // column, fail soft (skipped) so incremental sync keeps this source's last
+  // good upload state.
+  let schemaOk;
+  try {
+    schemaOk =
+      dbHasColumns(dbPath, 'message_nodes', NODE_COLUMNS) &&
+      dbHasColumns(dbPath, 'sessions', SESSION_COLUMNS);
+  } catch (err) {
+    if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('Devin');
+    return { buckets: [], sessions: [], skipped: true };
+  }
+  if (!schemaOk) {
+    return { buckets: [], sessions: [], skipped: true };
+  }
+
+  let rows;
+  try {
+    rows = queryDbJsonSnapshotOnLock(dbPath, USAGE_SQL, {
+      tempPrefix: 'vibe-usage-devin',
+    });
+  } catch (err) {
+    if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('Devin');
+    return { buckets: [], sessions: [], skipped: true };
+  }
+
+  const entries = [];
+  const events = [];
+  const sessionsWithUserPrompt = new Set();
+  const seen = new Set();
+
+  for (const row of rows) {
+    const sessionId = row.sessionId != null ? String(row.sessionId) : '';
+    if (!sessionId) continue;
+
+    // The node forest stores the same logical message at several adjacent
+    // nodes; dedupe on the stable message id (row id as fallback when absent).
+    const messageId = row.messageId != null ? String(row.messageId) : `row:${row.rowId}`;
+    const dedupKey = `${sessionId}|${messageId}`;
+    if (seen.has(dedupKey)) continue;
+    seen.add(dedupKey);
+
+    const timestamp = resolveTimestamp(row);
+    if (!timestamp) continue;
+
+    const project = row.workingDir ? projectFromPath(String(row.workingDir)) : 'unknown';
+    const role = eventRole(row);
+    if (role) {
+      events.push({ sessionId, source: SOURCE, project, timestamp, role });
+      if (role === 'user') sessionsWithUserPrompt.add(sessionId);
+    }
+
+    if (row.role !== 'assistant') continue;
+
+    // Cache creation folds into input (the shared bucket schema has no
+    // cache-write column); cache reads stay separate. Devin reports no
+    // reasoning split, so output is taken as-is.
+    const inputTokens = toCount(row.inputTokens) + toCount(row.cacheCreationTokens);
+    const outputTokens = toCount(row.outputTokens);
+    const cachedInputTokens = toCount(row.cacheReadTokens);
+    if (inputTokens + outputTokens + cachedInputTokens === 0) continue;
+
+    entries.push({
+      source: SOURCE,
+      model: row.generationModel || row.sessionModel || 'unknown',
+      project,
+      timestamp,
+      inputTokens,
+      outputTokens,
+      cachedInputTokens,
+      reasoningOutputTokens: 0,
+    });
+  }
+
+  // Only sessions containing a real human prompt reach extractSessions() —
+  // keepalive-only or otherwise automated sessions still contribute their
+  // token usage to buckets above.
+  const sessionEvents = events.filter(e => sessionsWithUserPrompt.has(e.sessionId));
+
+  return {
+    buckets: aggregateToBuckets(entries),
+    sessions: extractSessions(sessionEvents),
+  };
+}

package/src/parsers/index.js

@@ -28,6 +28,7 @@ import { parse as parseZcode } from './zcode.js';
 import { parse as parseTraeCli } from './trae-cli.js';
 import { parse as parseWorkbuddy } from './workbuddy.js';
 import { parseQoder, parseQoderCn } from './qoder.js';
+import { parse as parseDevin } from './devin.js';
 
 export const parsers = {
   'claude-code': parseClaudeCode,
@@ -61,6 +62,7 @@ export const parsers = {
   'roo-code': parseRooCode,
   'workbuddy': parseWorkbuddy,
   'zcode': parseZcode,
+  'devin': parseDevin,
 };
 
 export { roundToHalfHour, aggregateToBuckets, extractSessions } from './aggregate.js';

package/src/state.js

@@ -75,6 +75,11 @@ export function bucketHash(b) {
     b.cachedInputTokens || 0,
     b.reasoningOutputTokens || 0,
     b.totalTokens || 0,
+    // Cache writes carry a different unit price per TTL, so a bucket whose only
+    // change is a 5m<->1h reclassification must still re-upload — totalTokens
+    // alone cannot see that move.
+    b.cacheCreation5mTokens || 0,
+    b.cacheCreation1hTokens || 0,
   ]);
 }
 

package/src/sync.js

@@ -411,6 +411,10 @@ export async function runSync({
         }
       }
       for (const s of batchSessions) {
+        // Same uncommitted-on-drop rule as buckets: a session the backend
+        // rejected for an unknown source must be retried on the next sync
+        // rather than permanently lost.
+        if (batchUnknownSources.has(s.source)) continue;
         const key = sessionKey(s);
         const entry = pendingSessionState.get(key);
         if (entry) {

package/src/tools.js

@@ -161,6 +161,16 @@ export function getMcodeDbPath(env = process.env, home = homedir()) {
   return join(root, 'v2', 'sqlite', 'runtime-state.sqlite');
 }
 
+// Devin (CLI and Desktop share one agent backend) keeps all sessions in a
+// single WAL database: $XDG_DATA_HOME/devin/cli/sessions.db, defaulting to
+// ~/.local/share/devin/cli/sessions.db. Fixture override: VIBE_USAGE_DEVIN_DB.
+export function getDevinDbPath(env = process.env, home = homedir()) {
+  const override = env.VIBE_USAGE_DEVIN_DB?.trim();
+  if (override) return isAbsolute(override) ? override : resolve(override);
+  const dataHome = env.XDG_DATA_HOME?.trim() || join(home, '.local', 'share');
+  return join(dataHome, 'devin', 'cli', 'sessions.db');
+}
+
 export function getMimocodeDbPath(env = process.env) {
   if (env.MIMOCODE_HOME && !isAbsolute(env.MIMOCODE_HOME)) {
     throw new Error(`MIMOCODE_HOME must be an absolute path, got: ${JSON.stringify(env.MIMOCODE_HOME)}`);
@@ -441,6 +451,12 @@ export const TOOLS = [
     id: 'zcode',
     dataDir: getZcodeDbPath(),
   },
+  {
+    name: 'Devin',
+    id: 'devin',
+    dataDir: getDevinDbPath(),
+    detectDataDirs: () => [getDevinDbPath()].filter(existsSync),
+  },
 ];
 
 export function detectInstalledTools(options = {}) {