@vibe-cafe/vibe-usage 0.10.5 → 0.10.8

package/README.md

@@ -51,39 +51,43 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 
 | Tool | Data Location |
 |------|---------------|
-| Claude Code | `~/.claude/projects/` (tokens + sessions), `~/.claude/transcripts/` (sessions only); also scans `$CLAUDE_CONFIG_DIR` and data-bearing `~/.claude-*` profiles, selects the most complete duplicate session, and streams logs so large active sessions are not silently omitted. Cache creation tokens are included in input usage. |
+| Alma | Electron app-data `alma/chat_threads.db` (macOS: `~/Library/Application Support/alma/chat_threads.db`; fixture/relocation override: `VIBE_USAGE_ALMA_DB`). Reads the `usage_records` ledger plus workspace names without selecting chat bodies, message metadata, provider credentials, or full workspace paths. Cache writes are included in input usage. The ledger contains assistant responses only, so Alma emits token buckets without session timing. |
+| Claude Code + Claude Desktop Code/Cowork | Claude Code data in `~/.claude/projects/` (tokens + sessions) and `~/.claude/transcripts/` (sessions only), plus Claude Desktop Cowork's per-session `.claude/projects/` directories. Also scans `$CLAUDE_CONFIG_DIR` and data-bearing `~/.claude-*` profiles. All variants use the existing `claude-code` source; the parser selects the most complete copy of each session so shared/copied transcripts are not counted twice. Logs are streamed and cache creation tokens are included in input usage. |
 | Codex CLI | `$CODEX_HOME/sessions/` and `$CODEX_HOME/archived_sessions/` (default `~/.codex`), plus an optional temporary `--extra-codex-home` or manually persisted `codexExtraHome`; a versioned local index avoids re-reading unchanged rollouts and reads only safe append tails for ordinary sessions, while fork/sub-agent replay matching, duplicate suppression, and live/archive/cross-root deduplication retain their existing semantics |
 | Grok | `$GROK_HOME/sessions/<encoded-cwd>/<session-id>/` (default `~/.grok`); token usage from `updates.jsonl` `turn_completed.usage` (per-model `modelUsage`, cache reads, reasoning); project from `summary.json` cwd; honors `GROK_HOME` |
 | GitHub Copilot CLI | `~/.copilot/session-state/*/events.jsonl` |
+| CraftAgent | `~/.craft-agent/workspaces/*/sessions/*/.pi-sessions/*.jsonl`; honors `$CRAFT_AGENT_DIR` / `$CRAFTAGENT_DIR`; cache writes are included in input usage |
 | Cursor | `state.vscdb` (SQLite, reads `cursorAuth/accessToken`, fetches CSV from `cursor.com`); cloud data is stamped with a fixed `cursor-cloud` hostname so multi-machine setups don't double-count |
 | DimAgent | `$DIMCODE_HOME/dimcode.sqlite` (default `~/.dimcode/v2/dimcode.sqlite`); exact usage from `usage_ledger`, with forked ledger/history copies deduplicated |
 | Gemini CLI | `~/.gemini/tmp/<project_hash>/chats/session-*.jsonl` (current line-delimited format) and legacy `session-*.json`; recurses into nested subagent sessions |
 | OpenCode | `~/.local/share/opencode/opencode.db` (SQLite, `json_extract` query) |
-| OpenClaw | `~/.openclaw/agents/`, `~/.openclaw-<profile>/agents/` (profile deployments) |
-| pi | `~/.pi/agent/sessions/` |
+| OpenClaw | `~/.openclaw/agents/`, `~/.openclaw-<profile>/agents/` (profile deployments); cache-creation/cache-write tokens are included in input usage |
+| 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/`; cache writes are included in input usage |
 | 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) |
 | 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/` |
+| Amp | `~/.local/share/amp/threads/`; cache-creation tokens are included in input usage |
 | Droid | `~/.factory/sessions/` |
 | Hermes | `~/.hermes/state.db` + `~/.hermes/profiles/<name>/state.db` (SQLite, multi-profile) |
 | 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 | `<host>/User/globalStorage/saoudrizwan.claude-dev/{state/taskHistory.json,tasks/<id>/ui_messages.json}` (walks all VSCode-fork hosts: Code, Cursor, Windsurf, VSCodium, Trae, ...) |
+| Cline | Standalone `~/.cline/` plus `<host>/User/globalStorage/saoudrizwan.claude-dev/` across VSCode-fork hosts; migrated copies are deduplicated and empty leftover extension stores no longer count as installed |
 | 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) |
 | Antigravity | App 2.0 `~/.gemini/antigravity/conversations/*.db` and `agy` CLI `~/.gemini/antigravity-cli/conversations/*.db` are parsed offline (tokens, real model display name, project, sessions); legacy App `.pb` history falls back to Connect RPC while the language server is running |
+| WorkBuddy | macOS WorkBuddy 5.3.11+: `~/.workbuddy/projects/**/*.jsonl` (fixture/relocation override: `VIBE_USAGE_WORKBUDDY_DIRS`). Uses completed assistant requests and their actual `providerData.requestModelId`, so Auto-routed requests can produce multiple model buckets. Splits cache reads and reasoning from inclusive input/output totals, deduplicates copied request 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`) |
 
 ## How It Works
 
 - Parses local session logs from each AI coding tool
 - Aggregates token usage into 30-minute buckets
-- Extracts session metadata from all parsers: active time (AI generation time, excluding queue/TTFT wait), total duration, message counts
+- Extracts session metadata where the source safely exposes user/assistant timing: active time (AI generation time, excluding queue/TTFT wait), total duration, and message counts. Alma intentionally emits buckets only because its usage ledger contains assistant responses and the parser does not read chat records.
 - Uploads buckets + sessions to your vibecafe.ai dashboard (always gzip-compressed, ~94% smaller)
 - Incremental upload: every parser emits a complete local snapshot, then only buckets/sessions that are new or changed since the last successful upload are sent — a quiet machine uploads nothing. Upload state remains in `~/.vibe-usage/state.json`; failed or still-indexing parsers retain their prior state, while deleted local logs are pruned. Deleting the state file triggers a one-time full re-upload, and `reset` clears it automatically after deleting cloud data
 - Incremental Codex parsing: a versioned, disposable cache under `~/.vibe-usage/cache/codex/` stores per-rollout aggregate results and parser continuation state. Unchanged rollouts require no raw-log reads; an ordinary append reads only the new tail; forks, sub-agents, replacements, truncations, and failed safety checks fall back to the full correctness path. A bounded rolling audit occasionally re-reads one historical file. Very large first-time indexes checkpoint before the Mac app timeout and resume on the next sync instead of restarting
 - The Codex parser cache contains derived aggregates and replay metadata, not raw prompt or response text. It is independent of upload state and can be deleted safely (the next sync rebuilds it). `reset` intentionally keeps it so the required full re-upload does not also require a full disk rescan. Set `VIBE_USAGE_CODEX_CACHE=0` to disable the optimization for diagnosis
-- SQLite-backed tools (Cursor, OpenCode, Kiro, Hermes) are read via Node's built-in `node:sqlite` on Node ≥ 22.5 — no `sqlite3` binary needed (works on Windows out of the box); on older Node it falls back to the system `sqlite3` CLI
+- SQLite-backed tools are read via Node's built-in `node:sqlite` on Node ≥ 22.5 — no `sqlite3` binary needed (works on Windows out of the box); on older Node the CLI falls back to the system `sqlite3` executable
 - For continuous syncing, use `npx @vibe-cafe/vibe-usage daemon` or the [Vibe Usage Mac app](https://github.com/vibe-cafe/vibe-usage-app)
 
 ## Trust Model

package/package.json

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

package/src/claude-roots.js

@@ -2,6 +2,9 @@ import { existsSync, readdirSync, realpathSync, statSync } from 'node:fs';
 import { delimiter, join } from 'node:path';
 import { homedir } from 'node:os';
 
+const MAX_DESKTOP_DISCOVERY_DEPTH = 8;
+const DESKTOP_NON_SESSION_DIRS = new Set(['rpm', 'skills']);
+
 function expandHome(value) {
   const trimmed = value.trim().replace(/[/\\]+$/, '');
   if (trimmed === '~') return homedir();
@@ -15,18 +18,95 @@ function hasClaudeData(root) {
   return existsSync(join(root, 'projects')) || existsSync(join(root, 'transcripts'));
 }
 
+function defaultClaudeDesktopDataDir() {
+  if (process.platform === 'darwin') {
+    return join(homedir(), 'Library', 'Application Support', 'Claude');
+  }
+  if (process.platform === 'win32') {
+    const appData = process.env.APPDATA?.trim();
+    return appData
+      ? join(expandHome(appData), 'Claude')
+      : join(homedir(), 'AppData', 'Roaming', 'Claude');
+  }
+  const configHome = process.env.XDG_CONFIG_HOME?.trim();
+  return join(configHome ? expandHome(configHome) : join(homedir(), '.config'), 'Claude');
+}
+
+function getClaudeDesktopDataDirs() {
+  const override = process.env.VIBE_USAGE_CLAUDE_DESKTOP_DIRS?.trim();
+  return override
+    ? override.split(delimiter).map(expandHome).filter(Boolean)
+    : [defaultClaudeDesktopDataDir()];
+}
+
+function discoverDesktopRoots(dir, depth, roots, onWarning) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch (err) {
+    if (err?.code !== 'ENOENT') {
+      onWarning(`Claude Desktop: cannot read directory ${dir}: ${err.message}`);
+    }
+    return;
+  }
+
+  // Once a session root is found, do not descend into the user's Cowork files.
+  // Those directories can be large and are unrelated to Claude's transcript.
+  const claudeEntry = entries.find(
+    (entry) => entry.name === '.claude' && entry.isDirectory(),
+  );
+  if (claudeEntry) {
+    roots.push(join(dir, claudeEntry.name));
+    return;
+  }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (DESKTOP_NON_SESSION_DIRS.has(entry.name)) continue;
+    const candidate = join(dir, entry.name);
+    if (depth < MAX_DESKTOP_DISCOVERY_DEPTH) {
+      discoverDesktopRoots(candidate, depth + 1, roots, onWarning);
+    }
+  }
+}
+
+/**
+ * Find the private Claude Code state roots created for Claude Desktop Cowork.
+ * Desktop Code itself uses the normal ~/.claude root, while Cowork isolates
+ * each local-agent session below the Electron user-data directory.
+ */
+export function findClaudeDesktopRoots(
+  desktopDataDirs = getClaudeDesktopDataDirs(),
+  onWarning = () => {},
+) {
+  const roots = [];
+  for (const dataDir of desktopDataDirs) {
+    discoverDesktopRoots(
+      join(dataDir, 'local-agent-mode-sessions'),
+      0,
+      roots,
+      onWarning,
+    );
+  }
+  return roots;
+}
+
 /**
- * Return every Claude Code state root visible from this process.
+ * Return every Claude Code-compatible state root visible from this process.
  *
  * In addition to the default and CLAUDE_CONFIG_DIR, discover the documented
  * multi-profile convention (~/.claude-work, ~/.claude-personal, ...). This is
  * important for launchd/systemd and GUI processes, which commonly do not
  * inherit the shell environment used to launch Claude Code.
  *
- * VIBE_USAGE_CLAUDE_DIRS is a test/diagnostic override. It replaces discovery
- * with a path.delimiter-separated root list.
+ * Claude Desktop Code uses the default Claude Code root. Cowork creates a
+ * private .claude root per local-agent session, so those roots are discovered
+ * recursively under the app's user-data directory.
+ *
+ * VIBE_USAGE_CLAUDE_DIRS is a test/diagnostic override. It replaces all normal
+ * and Desktop discovery with a path.delimiter-separated root list.
  */
-export function getClaudeRoots() {
+export function getClaudeRoots({ onWarning = () => {} } = {}) {
   const override = process.env.VIBE_USAGE_CLAUDE_DIRS?.trim();
   const roots = override
     ? override.split(delimiter).map(expandHome).filter(Boolean)
@@ -47,6 +127,8 @@ export function getClaudeRoots() {
     } catch {
       // The default/configured roots remain usable if home discovery fails.
     }
+
+    roots.push(...findClaudeDesktopRoots(getClaudeDesktopDataDirs(), onWarning));
   }
 
   const seen = new Set();

package/src/cline-roots.js

@@ -0,0 +1,40 @@
+import { statSync } from 'node:fs';
+import { delimiter, join } from 'node:path';
+import { homedir } from 'node:os';
+
+const EXTENSION_ID = 'saoudrizwan.claude-dev';
+const HOSTS = ['Code', 'Cursor', 'Windsurf', 'VSCodium', 'Code - Insiders', 'Trae', 'Trae CN'];
+
+function hasTaskHistory(root) {
+  try {
+    return statSync(join(root, 'state', 'taskHistory.json')).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function hostRoots() {
+  const out = [];
+  if (process.platform === 'darwin') {
+    const base = join(homedir(), 'Library', 'Application Support');
+    for (const host of HOSTS) out.push(join(base, host));
+  } else if (process.platform === 'win32') {
+    const base = process.env.APPDATA?.trim() || join(homedir(), 'AppData', 'Roaming');
+    for (const host of HOSTS) out.push(join(base, host));
+  } else {
+    const base = process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), '.config');
+    for (const host of HOSTS) out.push(join(base, host));
+  }
+  return out;
+}
+
+export function findClineDataDirs() {
+  const override = process.env.VIBE_USAGE_CLINE_DIRS?.trim();
+  const candidates = override
+    ? override.split(delimiter).map((value) => value.trim()).filter(Boolean)
+    : [
+        join(homedir(), '.cline'),
+        ...hostRoots().map((root) => join(root, 'User', 'globalStorage', EXTENSION_ID)),
+      ];
+  return [...new Set(candidates)].filter(hasTaskHistory);
+}

package/src/craft-roots.js

@@ -0,0 +1,15 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+export function getCraftWorkspacesDir() {
+  const root = process.env.CRAFT_AGENT_DIR?.trim()
+    || process.env.CRAFTAGENT_DIR?.trim()
+    || join(homedir(), '.craft-agent');
+  return join(root, 'workspaces');
+}
+
+export function findCraftDataDirs() {
+  const workspaces = getCraftWorkspacesDir();
+  return existsSync(workspaces) ? [workspaces] : [];
+}

package/src/parsers/alma.js

@@ -0,0 +1,91 @@
+import { existsSync } from 'node:fs';
+import { basename } from 'node:path';
+import { getAlmaDbPath } from '../tools.js';
+import { aggregateToBuckets } from './index.js';
+import { queryDbJson } from './sqlite.js';
+
+export { getAlmaDbPath as resolveAlmaDbPath };
+
+const ALMA_USAGE_SQL = `
+  SELECT
+    usage_records.model AS model,
+    usage_records.timestamp AS timestamp,
+    usage_records.input_tokens AS inputTokens,
+    usage_records.output_tokens AS outputTokens,
+    usage_records.cached_input_tokens AS cachedInputTokens,
+    usage_records.reasoning_tokens AS reasoningOutputTokens,
+    usage_records.cache_write_input_tokens AS cacheWriteInputTokens,
+    workspaces.name AS workspaceName
+  FROM usage_records
+  LEFT JOIN chat_threads ON chat_threads.id = usage_records.thread_id
+  LEFT JOIN workspaces ON workspaces.id = chat_threads.workspace_id
+`;
+
+function tokenCount(value) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? number : 0;
+}
+
+function safeWorkspaceName(value) {
+  if (typeof value !== 'string') return 'unknown';
+  const normalized = value.trim().replace(/\\/g, '/').replace(/\/+$/, '');
+  return basename(normalized) || 'unknown';
+}
+
+function skippedResult(error) {
+  const message = error?.message || String(error);
+  let reason = message;
+  if (/database is locked/i.test(message)) reason = 'database is locked';
+  else if (/no such (table|column)/i.test(message)) reason = 'incompatible database schema';
+  return {
+    buckets: [],
+    sessions: [],
+    skipped: true,
+    warnings: [`alma: cannot read usage database (${reason})`],
+  };
+}
+
+export async function parse() {
+  const dbPath = getAlmaDbPath();
+  if (!existsSync(dbPath)) return { buckets: [], sessions: [] };
+
+  let rows;
+  try {
+    rows = queryDbJson(dbPath, ALMA_USAGE_SQL);
+  } catch (error) {
+    if (error?.status === 127 || /ENOENT/i.test(error?.message)) {
+      throw new Error('sqlite3 CLI not found. Install sqlite3 (or use Node >= 22.5) to sync Alma data.');
+    }
+    return skippedResult(error);
+  }
+
+  const entries = [];
+  for (const row of rows) {
+    const timestamp = new Date(row.timestamp);
+    if (Number.isNaN(timestamp.getTime())) continue;
+
+    const inputTokens = tokenCount(row.inputTokens) + tokenCount(row.cacheWriteInputTokens);
+    const outputTokens = tokenCount(row.outputTokens);
+    const cachedInputTokens = tokenCount(row.cachedInputTokens);
+    const reasoningOutputTokens = tokenCount(row.reasoningOutputTokens);
+    if (inputTokens + outputTokens + cachedInputTokens + reasoningOutputTokens === 0) continue;
+
+    entries.push({
+      source: 'alma',
+      model: row.model || 'unknown',
+      project: safeWorkspaceName(row.workspaceName),
+      timestamp,
+      inputTokens,
+      outputTokens,
+      cachedInputTokens,
+      reasoningOutputTokens,
+    });
+  }
+
+  return {
+    buckets: aggregateToBuckets(entries),
+    // Alma's usage ledger contains assistant responses only. Reconstructing
+    // user turns would require reading chat records outside the usage contract.
+    sessions: [],
+  };
+}

package/src/parsers/amp.js

@@ -79,17 +79,23 @@ export async function parse() {
 
         const inputTokens = event?.tokens?.input || 0;
         const outputTokens = event?.tokens?.output || 0;
-        if (inputTokens === 0 && outputTokens === 0) continue;
 
         const toMessage = Number.isInteger(event.toMessageId) ? messages[event.toMessageId] : null;
         const cacheReadInputTokens = toMessage?.usage?.cacheReadInputTokens || 0;
+        const cacheCreationInputTokens = toMessage?.usage?.cacheCreationInputTokens || 0;
+        if (
+          inputTokens === 0
+          && outputTokens === 0
+          && cacheReadInputTokens === 0
+          && cacheCreationInputTokens === 0
+        ) continue;
 
         entries.push({
           source: 'amp',
           model: event?.model || 'unknown',
           project: 'unknown',
           timestamp: ts,
-          inputTokens,
+          inputTokens: inputTokens + cacheCreationInputTokens,
           outputTokens,
           cachedInputTokens: cacheReadInputTokens,
           reasoningOutputTokens: 0,
@@ -105,14 +111,20 @@ export async function parse() {
 
         const inputTokens = usage.inputTokens || 0;
         const outputTokens = usage.outputTokens || 0;
-        if (inputTokens === 0 && outputTokens === 0 && (usage.cacheReadInputTokens || 0) === 0) continue;
+        const cacheCreationInputTokens = usage.cacheCreationInputTokens || 0;
+        if (
+          inputTokens === 0
+          && outputTokens === 0
+          && (usage.cacheReadInputTokens || 0) === 0
+          && cacheCreationInputTokens === 0
+        ) continue;
 
         entries.push({
           source: 'amp',
           model: usage.model || 'unknown',
           project: 'unknown',
           timestamp: ts,
-          inputTokens,
+          inputTokens: inputTokens + cacheCreationInputTokens,
           outputTokens,
           cachedInputTokens: usage.cacheReadInputTokens || 0,
           reasoningOutputTokens: 0,

package/src/parsers/claude-code.js

@@ -272,7 +272,9 @@ export async function parse() {
     warnings: [],
     incomplete: false,
   };
-  const roots = getClaudeRoots();
+  const roots = getClaudeRoots({
+    onWarning: (message) => addWarning(ctx, message),
+  });
   const projectGroups = collectCandidates(roots, 'projects', ctx);
   const projectSessionIds = new Set();
 

package/src/parsers/cline.js

@@ -1,40 +1,7 @@
 import { readFileSync, statSync } from 'node:fs';
 import { basename, join } from 'node:path';
-import { homedir } from 'node:os';
 import { aggregateToBuckets, extractSessions } from './index.js';
-
-const EXTENSION_ID = 'saoudrizwan.claude-dev';
-
-// VSCode-fork application names that may host extensions.
-const HOSTS = ['Code', 'Cursor', 'Windsurf', 'VSCodium', 'Code - Insiders', 'Trae', 'Trae CN'];
-
-function getHostRoots() {
-  const out = [];
-  if (process.platform === 'darwin') {
-    const base = join(homedir(), 'Library', 'Application Support');
-    for (const h of HOSTS) out.push(join(base, h));
-  } else if (process.platform === 'win32') {
-    const appData = process.env.APPDATA?.trim() || join(homedir(), 'AppData', 'Roaming');
-    for (const h of HOSTS) out.push(join(appData, h));
-  } else {
-    const xdg = process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), '.config');
-    for (const h of HOSTS) out.push(join(xdg, h));
-  }
-  return out;
-}
-
-export function findClineExtensionDirs() {
-  const dirs = [];
-  for (const root of getHostRoots()) {
-    const ext = join(root, 'User', 'globalStorage', EXTENSION_ID);
-    try {
-      if (statSync(ext).isDirectory()) dirs.push(ext);
-    } catch {
-      // not installed in this host; skip
-    }
-  }
-  return dirs;
-}
+import { findClineDataDirs } from '../cline-roots.js';
 
 function readJsonSafe(path) {
   try { return JSON.parse(readFileSync(path, 'utf-8')); } catch { return null; }
@@ -48,24 +15,44 @@ function projectFromPath(absPath) {
 }
 
 export async function parse() {
-  const extDirs = findClineExtensionDirs();
+  const extDirs = findClineDataDirs();
   if (extDirs.length === 0) return { buckets: [], sessions: [] };
 
   const entries = [];
   const events = [];
 
+  const candidates = new Map();
   for (const extDir of extDirs) {
     const history = readJsonSafe(join(extDir, 'state', 'taskHistory.json'));
     if (!Array.isArray(history)) continue;
 
     for (const item of history) {
+      if (!item || typeof item !== 'object' || !item.id) continue;
+      const taskId = String(item.id);
+      const messagesPath = join(extDir, 'tasks', taskId, 'ui_messages.json');
+      let stat;
+      try {
+        stat = statSync(messagesPath);
+      } catch {
+        continue;
+      }
+      const key = item.ulid ? String(item.ulid) : taskId;
+      const next = { item, taskId, messagesPath, size: stat.size, mtimeMs: stat.mtimeMs };
+      const current = candidates.get(key);
+      if (!current || next.size > current.size || (
+        next.size === current.size && next.mtimeMs > current.mtimeMs
+      )) candidates.set(key, next);
+    }
+  }
+
+  for (const { item, taskId, messagesPath } of candidates.values()) {
       try {
-        if (!item || typeof item !== 'object' || !item.id) continue;
-        const taskId = String(item.id);
-        const project = projectFromPath(item.cwdOnTaskInitialization || item.shadowGitConfigWorkTree);
+        const project = projectFromPath(
+          item.cwdOnTaskInitialization || item.shadowGitConfigWorkTree || item.cwd,
+        );
         const fallbackModel = (item.modelId && String(item.modelId).trim()) || 'cline-unknown';
 
-        const messages = readJsonSafe(join(extDir, 'tasks', taskId, 'ui_messages.json'));
+        const messages = readJsonSafe(messagesPath);
         if (!Array.isArray(messages)) continue;
 
         for (const msg of messages) {
@@ -109,7 +96,6 @@ export async function parse() {
       } catch {
         // Skip this task; keep going for the rest of the history.
       }
-    }
   }
 
   return { buckets: aggregateToBuckets(entries), sessions: extractSessions(events) };

package/src/parsers/craft-agent.js

@@ -0,0 +1,21 @@
+import { getCraftWorkspacesDir } from '../craft-roots.js';
+import { parsePiSessionJsonl } from './pi-session-jsonl.js';
+
+function isCraftPiSession(filePath) {
+  return filePath.split(/[\\/]/).includes('.pi-sessions');
+}
+
+function projectFromCraftPath(filePath) {
+  const parts = filePath.replace(/\\/g, '/').split('/');
+  const sessionsIndex = parts.lastIndexOf('sessions');
+  return parts[sessionsIndex + 1] || 'unknown';
+}
+
+export async function parse() {
+  return parsePiSessionJsonl({
+    source: 'craft-agent',
+    sessionsDirs: [getCraftWorkspacesDir()],
+    includeFile: isCraftPiSession,
+    projectFromPath: projectFromCraftPath,
+  });
+}

package/src/parsers/index.js

@@ -3,6 +3,7 @@ import { parse as parseClaudeCode } from './claude-code.js';
 import { parse as parseCline } from './cline.js';
 import { parse as parseCodex } from './codex.js';
 import { parse as parseCopilotCli } from './copilot-cli.js';
+import { parse as parseCraftAgent } from './craft-agent.js';
 import { parse as parseCursor } from './cursor.js';
 import { parse as parseDimAgent } from './dimagent.js';
 import { parse as parseRooCode } from './roo-code.js';
@@ -10,9 +11,11 @@ import { parse as parseGeminiCli } from './gemini-cli.js';
 import { parse as parseGrok } from './grok.js';
 import { parse as parseOpencode } from './opencode.js';
 import { parse as parseOpenclaw } from './openclaw.js';
+import { parse as parseOmp } from './omp.js';
 import { parse as parseQwenCode } from './qwen-code.js';
 import { parse as parseKimiCode } from './kimi-code.js';
 import { parse as parseAmp } from './amp.js';
+import { parse as parseAlma } from './alma.js';
 import { parse as parseDroid } from './droid.js';
 import { parse as parseAntigravity } from './antigravity.js';
 import { parse as parseHermes } from './hermes.js';
@@ -21,21 +24,25 @@ import { parse as parseMimocode } from './mimocode.js';
 import { parse as parsePiCodingAgent } from './pi-coding-agent.js';
 import { parse as parseZcode } from './zcode.js';
 import { parse as parseTraeCli } from './trae-cli.js';
+import { parse as parseWorkbuddy } from './workbuddy.js';
 
 export const parsers = {
   'claude-code': parseClaudeCode,
   'codex': parseCodex,
   'grok': parseGrok,
   'copilot-cli': parseCopilotCli,
+  'craft-agent': parseCraftAgent,
   'cursor': parseCursor,
   'dimagent': parseDimAgent,
   'gemini-cli': parseGeminiCli,
   'opencode': parseOpencode,
   'openclaw': parseOpenclaw,
+  'omp': parseOmp,
   'pi-coding-agent': parsePiCodingAgent,
   'qwen-code': parseQwenCode,
   'kimi-code': parseKimiCode,
   'amp': parseAmp,
+  'alma': parseAlma,
   'droid': parseDroid,
   'antigravity': parseAntigravity,
   'trae-cli': parseTraeCli,
@@ -44,6 +51,7 @@ export const parsers = {
   'mimocode': parseMimocode,
   'cline': parseCline,
   'roo-code': parseRooCode,
+  'workbuddy': parseWorkbuddy,
   'zcode': parseZcode,
 };
 

package/src/parsers/omp.js

@@ -0,0 +1,10 @@
+import { getOmpSessionDirs } from '../pi-roots.js';
+import { parsePiSessionJsonl } from './pi-session-jsonl.js';
+
+/** Parse Oh My Pi's Pi-compatible JSONL sessions, including profiles/XDG. */
+export async function parse() {
+  return parsePiSessionJsonl({
+    source: 'omp',
+    sessionsDirs: getOmpSessionDirs(),
+  });
+}

package/src/parsers/openclaw.js

@@ -7,6 +7,8 @@ import { aggregateToBuckets, extractSessions } from './index.js';
 // Profile deployments use ~/.openclaw-<profile>/agents/...
 // Legacy paths: ~/.clawdbot, ~/.moltbot, ~/.moldbot
 function getPossibleRoots() {
+  const override = process.env.VIBE_USAGE_OPENCLAW_DIRS?.trim();
+  if (override) return override.split(process.platform === 'win32' ? ';' : ':').filter(Boolean);
   const home = homedir();
   const roots = [
     join(home, '.clawdbot'),
@@ -29,7 +31,8 @@ function getPossibleRoots() {
 /** Normalize usage fields — OpenClaw supports multiple naming conventions */
 function getTokens(usage, ...keys) {
   for (const key of keys) {
-    if (usage[key] != null && usage[key] > 0) return usage[key];
+    const value = Number(usage[key]);
+    if (Number.isFinite(value) && value > 0) return value;
   }
   return 0;
 }
@@ -98,12 +101,31 @@ export async function parse() {
             const usage = msg.usage;
             if (!usage) continue;
 
+            const inputTokens = getTokens(
+              usage,
+              'input',
+              'inputTokens',
+              'input_tokens',
+              'promptTokens',
+              'prompt_tokens',
+            );
+            const cacheWriteTokens = getTokens(
+              usage,
+              'cacheCreation',
+              'cacheCreationInputTokens',
+              'cacheWrite',
+              'cache_creation',
+              'cache_write',
+              'cache_creation_input_tokens',
+              'cache_write_input_tokens',
+            );
+
             entries.push({
               source: 'openclaw',
               model: msg.model || obj.model || 'unknown',
               project,
               timestamp: ts,
-              inputTokens: getTokens(usage, 'input', 'inputTokens', 'input_tokens', 'promptTokens', 'prompt_tokens'),
+              inputTokens: inputTokens + cacheWriteTokens,
               outputTokens: getTokens(usage, 'output', 'outputTokens', 'output_tokens', 'completionTokens', 'completion_tokens'),
               cachedInputTokens: getTokens(usage, 'cacheRead', 'cache_read', 'cache_read_input_tokens'),
               reasoningOutputTokens: 0,