@vibe-cafe/vibe-usage 0.10.32 → 0.10.34

package/README.md

@@ -89,9 +89,11 @@ npx @vibe-cafe/vibe-usage help --all   # Full help (plain `help` shows the short
 | 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. |
 | 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`) |
 | 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.34",
   "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/codebuddy.js

@@ -0,0 +1,202 @@
+import { existsSync, readdirSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { createReadStream } from 'node:fs';
+import { basename, join, sep } from 'node:path';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import { projectFromCwd, toCount } from './fs-utils.js';
+import { getCodebuddyRoots } from '../tools.js';
+
+// CodeBuddy Code (Tencent's terminal agent, `@tencent-ai/codebuddy-code`). The
+// store follows Claude Code's layout:
+//   <home>/projects/<compressed-cwd>/<sessionId>.jsonl   (+ nested subagent dirs)
+// where <home> is `$CODEBUDDY_CONFIG_DIR` or ~/.codebuddy.
+//
+// Two record shapes live in those transcripts (verified against 2.151.0's own
+// writer and a real store): local turns are `{type:"message", role:"user"|…,
+// content, sessionId, cwd}`, while every successful model call is the API
+// message shape — `{message:{id, model, role:"assistant",
+// usage:{input_tokens, output_tokens, cache_read_input_tokens,
+// cache_creation_input_tokens}}}` — so token accounting reads `message.usage`
+// only. `usage.cache_creation` (the per-TTL breakdown) is written as `null`, so
+// cache writes fold into input and cannot be priced per TTL, matching every
+// parser that has no split.
+const SOURCE = 'codebuddy';
+const PROJECTS = 'projects';
+
+export function resolveCodebuddyRoots(env = process.env, home) {
+  return getCodebuddyRoots(env, home);
+}
+
+/** Session id of a transcript file, and the project fallback from its folder. */
+function fileIdentity(filePath, projectsDir) {
+  const sessionId = basename(filePath, '.jsonl');
+  const relative = filePath.startsWith(projectsDir + sep) ? filePath.slice(projectsDir.length + 1) : '';
+  const folder = relative.split(sep)[0] || '';
+  // Compressed cwd folders look like `private-tmp-my-project`; the last segment
+  // is the best guess when a record carries no cwd.
+  const fallback = folder.split('-').filter(Boolean).at(-1) || 'unknown';
+  return { sessionId, fallback };
+}
+
+function findTranscripts(root, onWarning) {
+  const projectsDir = join(root, PROJECTS);
+  if (!existsSync(projectsDir)) return { projectsDir, files: [] };
+  const files = [];
+  const walk = dir => {
+    let entries;
+    try { entries = readdirSync(dir, { withFileTypes: true }); }
+    catch (err) { onWarning(`codebuddy: 无法读取目录 ${dir}: ${err.message}`); return; }
+    for (const entry of entries) {
+      const path = join(dir, entry.name);
+      if (entry.isDirectory()) walk(path);
+      else if (entry.isFile() && entry.name.endsWith('.jsonl')) files.push(path);
+    }
+  };
+  walk(projectsDir);
+  return { projectsDir, files };
+}
+
+/**
+ * Provider routing/tier labels ('auto', 'default', …) are not model ids, and
+ * server-side pricing matches the model string alone: a bare `auto` would be
+ * billed at Cursor's `auto` rate — the collision PR #83 fixed for Qoder by
+ * renaming it `qoder-auto`. Namespace the tier labels with the tool prefix;
+ * concrete ids (`claude-sonnet-4-6`, …) pass through untouched.
+ */
+const ROUTING_TIER_IDS = new Set([
+  'auto', 'default', 'default-model', 'fast', 'turbo', 'lite', 'ultimate', 'performance', 'efficient',
+]);
+
+function normalizeModel(model) {
+  const lower = model.toLowerCase();
+  return ROUTING_TIER_IDS.has(lower) ? `${SOURCE}-${lower}` : model;
+}
+
+/** One usage-bearing assistant message, keyed so retries/copies collapse. */
+function usageEntry(obj, projectFallback, sessionId) {
+  const usage = obj.message?.usage;
+  if (!usage) return null;
+  const timestampMs = Number(obj.timestamp) || Date.parse(obj.message?.timestamp) || null;
+  const timestamp = Number.isFinite(timestampMs) ? new Date(timestampMs) : null;
+  if (!timestamp || isNaN(timestamp.getTime())) return null;
+
+  const cacheWrite = toCount(usage.cache_creation_input_tokens);
+  const inputTokens = toCount(usage.input_tokens) + cacheWrite;
+  const outputTokens = toCount(usage.output_tokens);
+  const cachedInputTokens = toCount(usage.cache_read_input_tokens);
+  if (!inputTokens && !outputTokens && !cachedInputTokens) return null;
+
+  const messageId = typeof obj.message?.id === 'string' ? obj.message.id.trim() : '';
+  const providerMessageId = typeof obj.providerData?.messageId === 'string' ? obj.providerData.messageId.trim() : '';
+  const ownId = typeof obj.id === 'string' ? obj.id.trim() : '';
+  // The CLI leaves `message.id` empty on some builds and keeps the per-message id
+  // in providerData; `conversationRequestId` is a *turn* id (one turn can hold
+  // several billable calls), so it is explicitly not a dedup key. Without this
+  // chain every call collapses onto one empty key and the session under-counts.
+  const identity = messageId || providerMessageId || ownId;
+  const dedupeKey = identity ? `call:${identity}` : null;
+
+  const model = normalizeModel([
+    obj.message?.model,
+    obj.providerData?.requestModelId,
+    obj.providerData?.model,
+  ].find(value => typeof value === 'string' && value.trim()) || 'unknown');
+
+  return {
+    dedupeKey,
+    usageScore: inputTokens + outputTokens + cachedInputTokens,
+    entry: {
+      source: SOURCE,
+      model,
+      project: projectFromCwd(obj.cwd, projectFallback),
+      timestamp,
+      inputTokens,
+      outputTokens,
+      cachedInputTokens,
+      reasoningOutputTokens: 0,
+    },
+    sessionId: typeof obj.sessionId === 'string' && obj.sessionId ? obj.sessionId : sessionId,
+  };
+}
+
+/** Human prompt? Local user turns only — the CLI marks injected/system text. */
+function isHumanPrompt(obj) {
+  if (obj?.role !== 'user' && obj?.message?.role !== 'user') return false;
+  if (obj.providerData?.isMeta || obj.providerData?.skipRun) return false;
+  if (obj.providerData?.isSessionSeparator || obj.providerData?.isCompactSummary) return false;
+  return true;
+}
+
+function readTimestamp(obj) {
+  const ms = Number(obj?.timestamp);
+  return Number.isFinite(ms) ? new Date(ms) : null;
+}
+
+export async function parse() {
+  const warnings = [];
+  const onWarning = message => warnings.push(message);
+  const entries = [];
+  const events = [];
+  const byKey = new Map();
+  const anonymous = [];
+  let skipped = false;
+
+  for (const root of resolveCodebuddyRoots()) {
+    const { projectsDir, files } = findTranscripts(root, onWarning);
+    for (const file of files) {
+      const { sessionId, fallback } = fileIdentity(file, projectsDir);
+      let stream;
+      try {
+        stream = createReadStream(file);
+        const lines = createInterface({ input: stream, crlfDelay: Infinity });
+        for await (const line of lines) {
+          if (!line.trim()) continue;
+          let obj;
+          try { obj = JSON.parse(line); } catch { continue; }
+          if (!obj || typeof obj !== 'object') continue;
+
+          const entry = usageEntry(obj, fallback, sessionId);
+          if (entry) {
+            if (!entry.dedupeKey) anonymous.push(entry);
+            else {
+              const current = byKey.get(entry.dedupeKey);
+              if (!current || entry.usageScore > current.usageScore) byKey.set(entry.dedupeKey, entry);
+            }
+            const timestamp = readTimestamp(obj);
+            if (timestamp) events.push({ sessionId: entry.sessionId, source: SOURCE, project: entry.entry.project, timestamp, role: 'assistant' });
+            continue;
+          }
+
+          if (isHumanPrompt(obj)) {
+            const timestamp = readTimestamp(obj);
+            if (timestamp) {
+              events.push({
+                sessionId: typeof obj.sessionId === 'string' && obj.sessionId ? obj.sessionId : sessionId,
+                source: SOURCE,
+                project: projectFromCwd(obj.cwd) || fallback,
+                timestamp,
+                role: 'user',
+              });
+            }
+          }
+        }
+      } catch (err) {
+        // A transcript that cannot be read means this source's snapshot is
+        // incomplete: skip the source so its previous upload state survives.
+        skipped = true;
+        onWarning(`codebuddy: 无法读取会话 ${file}: ${err.message}`);
+      } finally {
+        stream?.close();
+      }
+    }
+  }
+
+  for (const entry of anonymous) entries.push(entry.entry);
+  for (const entry of byKey.values()) entries.push(entry.entry);
+
+  const buckets = aggregateToBuckets(entries);
+  const sessions = extractSessions(events);
+  return skipped
+    ? { buckets: [], sessions: [], skipped: true, warnings }
+    : { buckets, sessions, warnings };
+}

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,8 @@ 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';
+import { parse as parseCodebuddy } from './codebuddy.js';
 
 export const parsers = {
   'claude-code': parseClaudeCode,
@@ -61,6 +63,8 @@ export const parsers = {
   'roo-code': parseRooCode,
   'workbuddy': parseWorkbuddy,
   'zcode': parseZcode,
+  'devin': parseDevin,
+  'codebuddy': parseCodebuddy,
 };
 
 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

@@ -1,5 +1,5 @@
 import { existsSync, readdirSync, statSync } from 'node:fs';
-import { dirname, isAbsolute, join, posix, resolve, win32 } from 'node:path';
+import { delimiter, dirname, isAbsolute, join, posix, resolve, win32 } from 'node:path';
 import { homedir } from 'node:os';
 import { getOpenCodeStores } from './opencode-roots.js';
 import { findClaudeCodeDataDirs } from './claude-roots.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)}`);
@@ -172,6 +182,12 @@ export function getMimocodeDbPath(env = process.env) {
   return isAbsolute(env.MIMOCODE_DB) ? env.MIMOCODE_DB : join(dataDir, env.MIMOCODE_DB);
 }
 
+export function getCodebuddyRoots(env = process.env, home = homedir()) {
+  const override = env.VIBE_USAGE_CODEBUDDY_DIRS?.trim();
+  if (override) return override.split(delimiter).map(value => value.trim()).filter(Boolean);
+  return [env.CODEBUDDY_CONFIG_DIR?.trim() || join(home, '.codebuddy')];
+}
+
 export function getZcodeDbPath(env = process.env, home = homedir()) {
   const override = env.VIBE_USAGE_ZCODE_DB?.trim();
   if (override) return isAbsolute(override) ? override : resolve(override);
@@ -441,6 +457,18 @@ export const TOOLS = [
     id: 'zcode',
     dataDir: getZcodeDbPath(),
   },
+  {
+    name: 'CodeBuddy',
+    id: 'codebuddy',
+    dataDir: join(getCodebuddyRoots()[0], 'projects'),
+    detectDataDirs: () => getCodebuddyRoots().map(root => join(root, 'projects')).filter(existsSync),
+  },
+  {
+    name: 'Devin',
+    id: 'devin',
+    dataDir: getDevinDbPath(),
+    detectDataDirs: () => [getDevinDbPath()].filter(existsSync),
+  },
 ];
 
 export function detectInstalledTools(options = {}) {