@vibe-cafe/vibe-usage 0.10.31 → 0.10.33

package/README.md

@@ -50,7 +50,7 @@ npx @vibe-cafe/vibe-usage reset        # Delete all data and re-upload from loca
 npx @vibe-cafe/vibe-usage reset --local  # Delete this host's data only and re-upload (`--host` remains a legacy alias)
 npx @vibe-cafe/vibe-usage skill         # Install skill for AI coding assistants
 npx @vibe-cafe/vibe-usage skill --remove  # Remove installed skills
-npx @vibe-cafe/vibe-usage status       # Show config & detected tools
+npx @vibe-cafe/vibe-usage status       # Config, detected tools, and what each tool has uploaded so far
 npx @vibe-cafe/vibe-usage help --all   # Full help (plain `help` shows the short version)
 ```
 
@@ -76,7 +76,7 @@ npx @vibe-cafe/vibe-usage help --all   # Full help (plain `help` shows the short
 | Oh My Pi | `~/.omp/agent/sessions/`, `~/.omp/profiles/*/agent/sessions/`, and `$XDG_DATA_HOME/omp/{sessions,profiles/*/sessions}`; recognizes OMP's `$PI_CODING_AGENT_DIR`, current v3 title slots and path/hashed session directories, deduplicates copied records, includes cache writes in input, and splits reasoning from OMP's inclusive output count |
 | pi | `~/.pi/agent/sessions/` or `$PI_CODING_AGENT_DIR/sessions/`, plus the session directory Pi itself was pointed at via `PI_CODING_AGENT_SESSION_DIR` or `sessionDir` in `~/.pi/agent/settings.json`, plus explicitly added `pi-coding-agent` roots for stores only reachable through `pi --session <file>` (fixture/relocation override: `VIBE_USAGE_PI_SESSION_DIRS`). Cache writes are included in input usage; reasoning is read from Pi's `usage.reasoning` (legacy `usage.reasoningTokens` still accepted) and split out of the inclusive output total |
 | Qwen Code | `~/.qwen/tmp/` |
-| Kimi Code | Current `~/.kimi-code/sessions/wd_<slug>_<hash>/session_<id>/agents/<agent>/wire.jsonl` (`usage.record` deltas, including retry/compaction scope and cache creation; main/subagent wires form one session), data root resolved via `$KIMI_CODE_HOME` like the CLI itself, with project names from `session_index.jsonl`; legacy `~/.kimi/sessions/` is parsed alongside (`kimi migrate` never carries usage over, so both stores are always merged) |
+| Kimi Code | Current `<home>/sessions/wd_<slug>_<hash>/session_<id>/agents/<agent>/wire.jsonl` (`usage.record` deltas, including retry/compaction scope and cache creation; main/subagent wires form one session), with project names from `session_index.jsonl`. Every home with that layout is scanned: the CLI home (`$KIMI_CODE_HOME`, else `~/.kimi-code`) plus the Kimi Work desktop app's embedded runtime home (`<Electron userData>/kimi-desktop/daimon-share/daimon/runtime/kimi-code/home`), which the app never writes into the CLI home; legacy `~/.kimi/sessions/` is parsed alongside (`kimi migrate` never carries usage over, so both stores are always merged) |
 | MiniMax Code (mcode) | `$MCODE_HOME/v2/sqlite/runtime-state.sqlite` (default `~/.minimax/v2/sqlite/runtime-state.sqlite`; fixture override: `VIBE_USAGE_MCODE_DB`). Reads only allow-listed token ledger fields and session workspace/project paths, uses basename-only projects, folds cache writes into input, keeps cache reads and reasoning separate, and never selects raw/message JSON payloads. WAL/lock reads use a disposable snapshot; malformed or incompatible databases are skipped to preserve incremental state. |
 | MiMoCode | `$MIMOCODE_HOME/data/mimocode.db`, `$XDG_DATA_HOME/mimocode/mimocode.db`, or `~/.local/share/mimocode/mimocode.db` (SQLite; exact input, output, reasoning, and cache-read tokens from assistant messages; honors `MIMOCODE_DB`; cache-write tokens are included in input usage) |
 | Amp | `~/.local/share/amp/threads/`; cache-creation tokens are included in input usage |
@@ -84,14 +84,15 @@ npx @vibe-cafe/vibe-usage help --all   # Full help (plain `help` shows the short
 | DeepSeek Harness | `$DSH_HOME/sessions/` (default `~/.dsh`, fixture/relocation override: `VIBE_USAGE_DSH_SESSIONS`). Reads V0–V3 logs, including `session.v3.jsonl.zstd` from DSH `0.1.5-alpha.2`, with multi-frame Zstandard support (Node ≥ 22.15 built-in, `zstd` CLI fallback) and plain JSONL support. Each session uses its highest `session[.vN].jsonl[.zstd]` generation once, so frozen pre-migration logs are not double-counted. Usage comes from `assistant/message`: cache writes join uncached input, cache reads remain separate, and reasoning is split out of inclusive output. Fork history uses V0/V1 `seedLength` or V2/V3's last `session/end-seed` tagged `inherited: true`, and is skipped only when the parent copy confirms it; missing parents retain the sole local history. Unknown versions warn and protect sync state. |
 | Hermes (CLI / Desktop) | `<home>/state.db` + `<home>/profiles/<name>/state.db` (SQLite, multi-profile). Home: `$HERMES_HOME`, otherwise `~/.hermes` on macOS/Linux or `%LOCALAPPDATA%\hermes` on Windows (falls back to an existing `~/.hermes` only when the Windows native root is absent). Cache writes join input; reasoning is separated from inclusive output. Usage is currently a cumulative session total attributed to session start: a session spanning several days does **not** yet provide an accurate daily breakdown. |
 | Kiro | Kiro CLI native event streams `~/.kiro/sessions/cli/*.jsonl` (estimated tokens from message text: input = prompt + tool results, output = reply + tool calls, reasoning = thinking, cacheRead = re-sent context; thinking-block signatures excluded). Falls back to `~/Library/Application Support/kiro-cli/data.sqlite3` / `~/.local/share/kiro-cli/data.sqlite3` + optional `~/.kiro_sessions/*.json` archives, then IDE `q-client.log` whole-credit deltas as `kiro-credits` (floored cumulative diff — the server stores token counts as bigint); legacy IDE `dev_data/devdata.sqlite` token telemetry is opt-in with `VIBE_USAGE_KIRO_LEGACY_TOKENS=1` |
-| Cline | Current CLI/SDK `~/.cline/data/sessions/*/*.messages.json` 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 |
+| 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. |
 | 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. |
-| ZCode | `~/.zcode/cli/db/db.sqlite` (SQLite; reads the `message` table for per-message tokens, model, and project `cwd`/`root`, joined to `session.directory`) |
+| 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.31",
+  "version": "0.10.33",
   "description": "Track your AI coding tool token usage and sync to vibecafe.ai",
   "type": "module",
   "scripts": {

package/src/index.js

@@ -9,6 +9,7 @@ import {
   validateExtraRoot,
 } from './extra-roots.js';
 import { dim as dimText, failure, hint, smallHeader, warn } from './output.js';
+import { loadState } from './state.js';
 import { fetchAccount } from './api.js';
 
 function printSmallHeader() {
@@ -17,6 +18,25 @@ function printSmallHeader() {
   console.log();
 }
 
+/**
+ * Per-source counts of everything `state.json` records as uploaded. Keys are
+ * `${source}|…` (see state.js), so the source is the first segment.
+ */
+function uploadedItemCounts(state) {
+  const countBySource = keys => {
+    const counts = new Map();
+    for (const key of keys) {
+      const source = key.split('|')[0];
+      counts.set(source, (counts.get(source) || 0) + 1);
+    }
+    return counts;
+  };
+  return {
+    buckets: countBySource(Object.keys(state.buckets || {})),
+    sessions: countBySource(Object.keys(state.sessions || {})),
+  };
+}
+
 async function showStatus() {
   const config = loadConfig();
   console.log('\nvibe-usage status\n');
@@ -49,8 +69,21 @@ async function showStatus() {
   if (detected.length === 0) {
     console.log('    (none)\n');
   } else {
+    // "installed" alone cannot separate "syncing fine" from "never uploaded":
+    // a tool whose data dir exists but whose buckets never reached the server
+    // reads exactly like a healthy one, which is how a stale bundled CLI stayed
+    // invisible (issue #100). state.json is the only local record of what was
+    // actually uploaded, so count it per source.
+    const uploaded = uploadedItemCounts(loadState());
     for (const tool of detected) {
-      console.log(`    ${tool.name}`);
+      const buckets = uploaded.buckets.get(tool.id) || 0;
+      const sessions = uploaded.sessions.get(tool.id) || 0;
+      if (buckets || sessions) {
+        console.log(`    ${tool.name}  ·  已上传 ${buckets} buckets / ${sessions} sessions`);
+      } else {
+        console.log(`    ${tool.name}  ·  尚未上传过数据`);
+        console.log(dimText('       本机检测到数据，但本地没有这条工具的上传记录：运行 `npx @vibe-cafe/vibe-usage` 同步'));
+      }
     }
     console.log();
   }

package/src/kimi-roots.js

@@ -0,0 +1,63 @@
+import { existsSync, realpathSync } from 'node:fs';
+import { join, posix, win32 } from 'node:path';
+import { homedir } from 'node:os';
+
+// Root discovery for Kimi Code. The CLI keeps one data home, and the Kimi Work
+// desktop app runs an embedded Kimi Code runtime whose home has the CLI's exact
+// layout (issue #85), so both homes are scanned additively.
+
+// Kimi Work's embedded runtime home, relative to the app's Electron userData.
+const DAIMON_RUNTIME = ['daimon-share', 'daimon', 'runtime', 'kimi-code', 'home'];
+
+/** Kimi Work's embedded Kimi Code home for this platform. */
+export function kimiWorkCodeHome(env = process.env, platform = process.platform, home = homedir()) {
+  const pathImpl = platform === 'win32' ? win32 : posix;
+  const userData = platform === 'darwin'
+    ? pathImpl.join(home, 'Library', 'Application Support')
+    : platform === 'win32'
+      ? (env.APPDATA?.trim() || pathImpl.join(home, 'AppData', 'Roaming'))
+      : (env.XDG_CONFIG_HOME?.trim() || pathImpl.join(home, '.config'));
+  return pathImpl.join(userData, 'kimi-desktop', ...DAIMON_RUNTIME);
+}
+
+// Two roots can name the same directory (symlinks, a relocated home that still
+// resolves to the same store); scanning both would double-count every record.
+function uniquePaths(paths) {
+  const seen = new Set();
+  const result = [];
+  for (const path of paths) {
+    let key = path;
+    try { key = realpathSync(path); } catch { /* not created yet — compare as given */ }
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(path);
+  }
+  return result;
+}
+
+/**
+ * Kimi Code data homes to scan, primary first.
+ *
+ * `VIBE_USAGE_KIMI_CODE_DIR` (test/relocation hook) replaces discovery entirely,
+ * so a fixture never picks up the machine's real stores. Otherwise the CLI home
+ * — `$KIMI_CODE_HOME` when set, exactly like the CLI itself — is scanned
+ * alongside the Kimi Work desktop home; the desktop app never writes into the
+ * CLI home, so the two stores are independent.
+ */
+export function resolveKimiCodeRoots(env = process.env, platform = process.platform, home = homedir()) {
+  const override = env.VIBE_USAGE_KIMI_CODE_DIR?.trim();
+  if (override) return [override];
+  const pathImpl = platform === 'win32' ? win32 : posix;
+  return uniquePaths([
+    env.KIMI_CODE_HOME?.trim() || pathImpl.join(home, '.kimi-code'),
+    kimiWorkCodeHome(env, platform, home),
+  ]);
+}
+
+/** Existing Kimi Code session stores, for tool detection (`status`). */
+export function findKimiCodeDataDirs() {
+  return uniquePaths([
+    ...resolveKimiCodeRoots().map(root => join(root, 'sessions')),
+    join(homedir(), '.kimi', 'sessions'), // legacy store, always parsed alongside
+  ]).filter(existsSync);
+}

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/cline-sdk.js

@@ -5,12 +5,30 @@ import { projectFromCwd, toCount } from './fs-utils.js';
 // Verified with the shipped cline 3.0.61 / @cline/core 0.0.82. SQLite is only
 // the session index: per-call accounting lives in version-1 messages artifacts.
 // Read canonical artifacts, not DB prompt/metadata columns or provider settings.
-export function readClineSdk(sessionDirs, onWarning) {
+//
+// Two failure sizes, because they mean different things (see AGENTS.md):
+// a *format* mismatch means the store moved on and any number we produce would
+// be wrong, so the caller must skip the source and keep its previous upload
+// state; an *IO* failure on one artifact (the desktop app rewrites these files
+// in place, so half-written JSON is normal) drops only that artifact, while the
+// rest of the store still syncs. Transient losses re-upload on the next sync.
+function unsupported(message) {
+  const error = new Error(message);
+  error.clineUnsupported = true;
+  return error;
+}
+
+export function readClineSdk(sessionDirs, { onWarning = () => {}, onFatal = () => {} } = {}) {
   const copies = [];
   for (const dir of sessionDirs) {
     let children;
     try { children = readdirSync(dir, { withFileTypes: true }); }
-    catch (err) { onWarning(`cline: 无法读取会话目录 ${dir}: ${err.message}`); continue; }
+    catch (err) {
+      // Cannot enumerate this root: the snapshot may be missing sessions we
+      // could not even list, so the whole source is unsafe this run.
+      onFatal(`cline: 无法读取会话目录 ${dir}: ${err.message}`);
+      continue;
+    }
     for (const child of children) {
       if (!child.isDirectory()) continue;
       const sessionDir = join(dir, child.name);
@@ -21,10 +39,11 @@ export function readClineSdk(sessionDirs, onWarning) {
         if (!files.length) continue;
         manifest = JSON.parse(readFileSync(join(sessionDir, `${child.name}.json`), 'utf8'));
         if (manifest?.version !== 1 || manifest.session_id !== child.name) {
-          throw new Error('unsupported or inconsistent Cline session manifest');
+          throw unsupported('unsupported or inconsistent Cline session manifest');
         }
       } catch (err) {
-        onWarning(`cline: 无法读取会话目录 ${sessionDir}: ${err.message}`);
+        if (err?.clineUnsupported) onFatal(`cline: 不支持或不一致的会话清单 ${sessionDir}: ${err.message}`);
+        else onWarning(`cline: 跳过无法读取的会话目录 ${sessionDir}: ${err.message}`);
         continue;
       }
       for (const file of files) {
@@ -34,7 +53,7 @@ export function readClineSdk(sessionDirs, onWarning) {
           if (payload?.version !== 1 || !Array.isArray(payload.messages)
             || typeof payload.sessionId !== 'string'
             || (payload.sessionId !== child.name && payload.origin?.parentThreadId !== child.name)) {
-            throw new Error('unsupported or inconsistent Cline session artifact');
+            throw unsupported('unsupported or inconsistent Cline session artifact');
           }
           const project = projectFromCwd(manifest.workspace_root || manifest.cwd);
           // Reduce immediately to accounting/timing metadata. No prompt, response,
@@ -68,7 +87,8 @@ export function readClineSdk(sessionDirs, onWarning) {
             // shared history to the earliest original session deterministically.
             started: Date.parse(manifest.started_at) || 0, messagesPath });
         } catch (err) {
-          onWarning(`cline: 无法读取会话 ${messagesPath}: ${err.message}`);
+          if (err?.clineUnsupported) onFatal(`cline: 不支持或不一致的会话文件 ${messagesPath}: ${err.message}`);
+          else onWarning(`cline: 跳过无法读取的会话文件 ${messagesPath}: ${err.message}`);
         }
       }
     }

package/src/parsers/cline.js

@@ -7,8 +7,13 @@ import { readClineSdk } from './cline-sdk.js';
 
 export async function parse() {
   const warnings = [];
+  // Format drift or an unreadable root means we cannot describe the store:
+  // skip the source so its previous upload state survives. A single unreadable
+  // artifact only drops that artifact (it re-uploads on the next sync).
+  let fatal = false;
   const onWarning = message => warnings.push(message);
-  const { legacyRoots: extDirs, sdkSessionDirs } = findClineStores({ onWarning });
+  const onFatal = message => { fatal = true; warnings.push(message); };
+  const { legacyRoots: extDirs, sdkSessionDirs } = findClineStores({ onWarning: onFatal });
 
   const entries = [];
   const events = [];
@@ -90,8 +95,9 @@ export async function parse() {
       }
   }
 
-  const sdk = readClineSdk(sdkSessionDirs, onWarning);
-  if (warnings.length) return { buckets: [], sessions: [], skipped: true, warnings };
+  const sdk = readClineSdk(sdkSessionDirs, { onWarning, onFatal });
+  if (fatal) return { buckets: [], sessions: [], skipped: true, warnings };
   return { buckets: aggregateToBuckets([...entries, ...sdk.entries]),
-    sessions: extractSessions([...events, ...sdk.events]) };
+    sessions: extractSessions([...events, ...sdk.events]),
+    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,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/parsers/kimi-code.js

@@ -1,8 +1,9 @@
-import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import { readdirSync, readFileSync, existsSync, realpathSync } from 'node:fs';
 import { join, basename } from 'node:path';
 import { homedir } from 'node:os';
 import { createHash } from 'node:crypto';
 import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import { resolveKimiCodeRoots } from '../kimi-roots.js';
 
 /**
  * Kimi Code CLI parser. MoonshotAI/kimi-cli (a.k.a. "Kimi Code").
@@ -19,8 +20,13 @@ import { aggregateToBuckets, extractSessions } from './aggregate.js';
  *    sum to the session total. The model name rides on each record — no config
  *    lookup needed. User turns are `turn.prompt` with origin.kind === "user".
  *    The real working directory per session is recorded in
- *      ~/.kimi-code/session_index.jsonl  -> {sessionId, sessionDir, workDir}
+ *      <home>/session_index.jsonl  -> {sessionId, sessionDir, workDir}
  *    which gives an accurate project name (last path component of workDir).
+ *    Several homes share this layout and are all scanned (see kimi-roots.js):
+ *    the CLI home ($KIMI_CODE_HOME, else ~/.kimi-code) and the Kimi Work
+ *    desktop app's embedded runtime home. The desktop app never writes into the
+ *    CLI home, so the stores are independent and merging them cannot
+ *    double-count.
  *
  * 2. Legacy ("~/.kimi", protocol 1.1 / 1.9). Sessions live at
  *      ~/.kimi/sessions/<md5(workdir)>/<session-id>/wire.jsonl
@@ -39,15 +45,12 @@ import { aggregateToBuckets, extractSessions } from './aggregate.js';
 // Current format: ~/.kimi-code
 // ---------------------------------------------------------------------------
 
-// VIBE_USAGE_KIMI_CODE_DIR overrides the root (test hook). Otherwise resolve
-// the data root the same way the CLI itself does: $KIMI_CODE_HOME, then
-// ~/.kimi-code. Ignoring KIMI_CODE_HOME means users with a custom home get
-// zero usage parsed.
-const KIMI_CODE_DIR = process.env.VIBE_USAGE_KIMI_CODE_DIR?.trim()
-  || process.env.KIMI_CODE_HOME?.trim()
-  || join(homedir(), '.kimi-code');
-const KIMI_CODE_SESSIONS_DIR = join(KIMI_CODE_DIR, 'sessions');
-const KIMI_CODE_SESSION_INDEX = join(KIMI_CODE_DIR, 'session_index.jsonl');
+// VIBE_USAGE_KIMI_CODE_DIR overrides the root (test hook). Otherwise every root
+// from kimi-roots.js is scanned — the CLI home resolved the same way the CLI
+// itself resolves it ($KIMI_CODE_HOME, then ~/.kimi-code) plus the Kimi Work
+// desktop app's embedded runtime home (issue #85), which uses this exact
+// layout. Ignoring KIMI_CODE_HOME means users with a custom home get zero usage
+// parsed; ignoring the desktop home means Kimi Work users get zero usage parsed.
 
 function projectNameFromPath(path) {
   if (typeof path !== 'string' || !path) return null;
@@ -55,17 +58,17 @@ function projectNameFromPath(path) {
 }
 
 /**
- * Map each session directory (absolute path) to a project name, read from
- * ~/.kimi-code/session_index.jsonl. Falls back gracefully if the file is
- * missing or malformed — callers default to the wd_ bucket name.
+ * Map each session directory (absolute path) to a project name, read from the
+ * home's session_index.jsonl. Falls back gracefully if the file is missing or
+ * malformed — callers default to the wd_ bucket name.
  */
-function loadSessionIndex() {
+function loadSessionIndex(indexPath) {
   const map = new Map();
-  if (!existsSync(KIMI_CODE_SESSION_INDEX)) return map;
+  if (!existsSync(indexPath)) return map;
 
   let content;
   try {
-    content = readFileSync(KIMI_CODE_SESSION_INDEX, 'utf-8');
+    content = readFileSync(indexPath, 'utf-8');
   } catch {
     return map;
   }
@@ -141,15 +144,35 @@ function findKimiCodeWireFiles(baseDir) {
   return results;
 }
 
+/**
+ * Every wire file to parse, with its project name, across all Kimi Code homes.
+ * Two roots can resolve to the same store (symlink, relocated home), so the
+ * same physical wire file is returned once.
+ */
+function findKimiCodeWireFilesInAllRoots() {
+  const results = [];
+  const seen = new Set();
+  for (const root of resolveKimiCodeRoots()) {
+    const sessionIndex = loadSessionIndex(join(root, 'session_index.jsonl'));
+    for (const { wireFile, sessionDir, bucketProject } of findKimiCodeWireFiles(join(root, 'sessions'))) {
+      let identity = wireFile;
+      try { identity = realpathSync(wireFile); } catch { /* keep the literal path */ }
+      if (seen.has(identity)) continue;
+      seen.add(identity);
+      results.push({ wireFile, sessionDir, project: sessionIndex.get(sessionDir) || bucketProject || 'unknown' });
+    }
+  }
+  return results;
+}
+
 function parseKimiCode() {
-  const wireFiles = findKimiCodeWireFiles(KIMI_CODE_SESSIONS_DIR);
+  const wireFiles = findKimiCodeWireFilesInAllRoots();
   if (wireFiles.length === 0) return null;
 
-  const sessionIndex = loadSessionIndex();
   const entries = [];
   const sessionEvents = [];
 
-  for (const { wireFile, sessionDir, bucketProject } of wireFiles) {
+  for (const { wireFile, sessionDir, project } of wireFiles) {
     let content;
     try {
       content = readFileSync(wireFile, 'utf-8');
@@ -157,8 +180,6 @@ function parseKimiCode() {
       continue;
     }
 
-    const project = sessionIndex.get(sessionDir) || bucketProject || 'unknown';
-
     for (const line of content.split('\n')) {
       if (!line.trim()) continue;
       let evt;

package/src/parsers/zcode.js

@@ -1,8 +1,8 @@
 import { existsSync } from 'node:fs';
-import { join, basename } from 'node:path';
-import { homedir } from 'node:os';
+import { basename } from 'node:path';
 import { aggregateToBuckets, extractSessions } from './aggregate.js';
 import { queryDbJson, sqliteUnavailableError, isSqliteUnavailableError } from './sqlite.js';
+import { getZcodeDbPath } from '../tools.js';
 
 // ZCode (z.ai / Zhipu's coding agent) stores everything in a SQLite database
 // at ~/.zcode/cli/db/db.sqlite. The `message` table is the canonical source:
@@ -11,7 +11,9 @@ import { queryDbJson, sqliteUnavailableError, isSqliteUnavailableError } from '.
 // than the parallel `model_usage` ledger because `message` gives us BOTH session
 // timing (user + assistant rows) and token usage in one pass, with the project
 // path attached to each message.
-const DB_PATH = join(homedir(), '.zcode', 'cli', 'db', 'db.sqlite');
+export function resolveZcodeDbPath(env = process.env) {
+  return getZcodeDbPath(env);
+}
 
 /**
  * Project name from a ZCode message's path. ZCode records both `cwd` and `root`;
@@ -26,15 +28,20 @@ function projectName(root, cwd, sessionDir) {
 }
 
 export async function parse() {
-  if (!existsSync(DB_PATH)) return { buckets: [], sessions: [] };
+  const dbPath = resolveZcodeDbPath();
+  if (!existsSync(dbPath)) return { buckets: [], sessions: [] };
 
   // Join each message to its session so we can fall back to the session's
   // directory when an individual message has no path (older rows, lite agents).
+  // ZCode renamed the assistant message's model keys from `modelID` /
+  // `providerID` to `modelId` / `providerId`; read both spellings so neither
+  // build reports every bucket as `unknown`.
   const query = `SELECT
     m.session_id AS sessionId,
     m.time_created AS created,
     json_extract(m.data, '$.role') AS role,
     json_extract(m.data, '$.modelID') AS modelID,
+    json_extract(m.data, '$.modelId') AS modelId,
     json_extract(m.data, '$.tokens') AS tokens,
     json_extract(m.data, '$.path.root') AS pathRoot,
     json_extract(m.data, '$.path.cwd') AS pathCwd,
@@ -44,7 +51,7 @@ export async function parse() {
 
   let rows;
   try {
-    rows = queryDbJson(DB_PATH, query);
+    rows = queryDbJson(dbPath, query);
   } catch (err) {
     if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('ZCode');
     throw err;
@@ -88,7 +95,7 @@ export async function parse() {
 
     entries.push({
       source: 'zcode',
-      model: row.modelID || 'unknown',
+      model: row.modelID || row.modelId || 'unknown',
       project,
       timestamp,
       inputTokens: (tokens.input || 0) - cachedInput,

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

@@ -15,6 +15,7 @@ import { findClineDataDirs } from './cline-roots.js';
 import { findColaDataDirs, getColaSessionsDir } from './cola-roots.js';
 import { findCraftDataDirs } from './craft-roots.js';
 import { findHermesDataDirs, getHermesHome } from './hermes-roots.js';
+import { findKimiCodeDataDirs } from './kimi-roots.js';
 import { findOmpDataDirs, findPiDataDirs } from './pi-roots.js';
 import { findQoderDataDirs, getQoderProjectsDir } from './qoder-roots.js';
 import { findWorkbuddyDataDirs } from './workbuddy-roots.js';
@@ -124,13 +125,8 @@ export function findCodexDataDirs(codexExtraHome, extraRoots = []) {
 }
 
 // Kimi Code moved its store from ~/.kimi to ~/.kimi-code; recognize either so
-// users on either version are detected. The parser prefers ~/.kimi-code.
-function findKimiCodeDataDirs() {
-  return [
-    join(homedir(), '.kimi-code', 'sessions'),
-    join(homedir(), '.kimi', 'sessions'),
-  ].filter(existsSync);
-}
+// users on either version are detected. Kimi Work's embedded runtime home is
+// recognized too — see kimi-roots.js, which the parser uses as well.
 
 /** DeepSeek Harness home: DSH_HOME env (same as the dsh CLI) or ~/.dsh. */
 export function getDshHome(env = process.env) {
@@ -165,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)}`);
@@ -176,6 +182,12 @@ export function getMimocodeDbPath(env = process.env) {
   return isAbsolute(env.MIMOCODE_DB) ? env.MIMOCODE_DB : join(dataDir, env.MIMOCODE_DB);
 }
 
+export function getZcodeDbPath(env = process.env, home = homedir()) {
+  const override = env.VIBE_USAGE_ZCODE_DB?.trim();
+  if (override) return isAbsolute(override) ? override : resolve(override);
+  return join(home, '.zcode', 'cli', 'db', 'db.sqlite');
+}
+
 export function findAntigravityDataDirs(extraRoots = []) {
   return [...new Set([
     ...antigravityConversationDirs(homedir()).map(dirname),
@@ -437,7 +449,13 @@ export const TOOLS = [
   {
     name: 'ZCode',
     id: 'zcode',
-    dataDir: join(homedir(), '.zcode', 'cli', 'db', 'db.sqlite'),
+    dataDir: getZcodeDbPath(),
+  },
+  {
+    name: 'Devin',
+    id: 'devin',
+    dataDir: getDevinDbPath(),
+    detectDataDirs: () => [getDevinDbPath()].filter(existsSync),
   },
 ];