@vibe-cafe/vibe-usage 0.10.21 → 0.10.23

package/README.md

@@ -72,14 +72,16 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 | Amp | `~/.local/share/amp/threads/`; cache-creation tokens are included in input usage |
 | Droid | `~/.factory/sessions/` |
 | DeepSeek Harness | `$DSH_HOME/sessions/` (default `~/.dsh`, fixture/relocation override: `VIBE_USAGE_DSH_SESSIONS`). Reads multi-frame Zstandard `session.jsonl.zstd` logs (built-in `node:zlib` zstd on Node ≥ 22.15, `zstd` CLI fallback) and plain `session.jsonl` logs. Usage comes from `assistant/message`: cache writes join uncached input, cache reads remain separate, and reasoning is split out of inclusive output. Fork/subagent history is de-duplicated from the immutable header: `parentSession` identifies the source and `seedLength` gives the exact leading event boundary. Inherited messages are skipped only when matching source seqs remain in the parent file; missing parents fail open. `session/end-seed` positions are not used because resumes can append the marker after real history. |
-| Hermes | `~/.hermes/state.db` + `~/.hermes/profiles/<name>/state.db` (SQLite, multi-profile) |
+| Hermes | `$HERMES_HOME/state.db` (default `~/.hermes/state.db`) + `profiles/<name>/state.db` (SQLite, multi-profile). 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 | 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). 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 | App 2.0 `~/.gemini/antigravity/conversations/*.db` and `agy` CLI `~/.gemini/antigravity-cli/conversations/*.db`, plus the same paths below explicitly added alternate Homes, are parsed offline (tokens, real model display name when present, project, sessions). Gemini 3.7 CLI blobs omit `chatStartMetadata.createdAt` and `modelDisplayName`; usage still comes from `gen_metadata`, timestamps fall back to `steps.metadata` at the same idx, and the model name falls back to `responseModel`. Legacy App `.pb` history falls back to Connect RPC only for the primary App store while the language server is running |
+| 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`) |
+| 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` |
 
 ## How It Works
 
@@ -93,6 +95,24 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 - 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)
 
+## Cursor 网络排查
+
+Cursor 用量需要从 `cursor.com` 下载 CSV。`Cursor usage export skipped (network: …)` 表示这次下载失败；CLI 会保留 Cursor 的历史同步状态，下次同步重新尝试。
+
+- `ENOTFOUND` / `EAI_AGAIN`：检查 DNS 和终端网络。
+- `UND_ERR_CONNECT_TIMEOUT` / `ETIMEDOUT` / `ECONNRESET`：检查到 Cursor 的连接及终端代理。浏览器或 Cursor 应用能联网，不代表 Node.js 使用了相同代理。
+- `CERT_*` / `UNABLE_TO_VERIFY_LEAF_SIGNATURE` 等：检查系统时间和代理或公司网络的 CA 证书配置；自定义 CA 可通过 `NODE_EXTRA_CA_CERTS` 指定。
+- `timeout after …ms`：导出或下载超时，稍后重试；网络较慢时可设置 `VIBE_USAGE_CURSOR_FETCH_TIMEOUT_MS=60000`。
+- `Cursor session rejected`：在 Cursor 的 Account 设置中重新登录，再同步。
+
+需要 HTTP/HTTPS 代理时，Node.js **22.21+ 或 24.5+** 可用 `NODE_USE_ENV_PROXY=1` 启用环境变量代理（[Node.js 官方说明](https://nodejs.org/en/learn/http/enterprise-network-configuration)）。以下为 macOS/Linux 终端示例，代理地址须替换为实际地址：
+
+```bash
+HTTPS_PROXY=http://127.0.0.1:7890 NODE_USE_ENV_PROXY=1 npx @vibe-cafe/vibe-usage sync
+```
+
+这些环境变量只影响当前命令；已经运行的桌面应用和后台服务有各自的进程环境。持续失败时，请提供完整的 Cursor 报错、操作系统、`node -v` 和 CLI 版本，以便区分具体原因。
+
 ## Trust Model
 
 vibe-usage parses **local tool logs and local application state** on a machine the user fully controls. The reported data is self-reported telemetry — local logs, parsers, and upload requests can all be modified by the user.

package/package.json

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

package/src/extra-roots.js

@@ -86,6 +86,7 @@ export function antigravityConversationDirs(value) {
   return [
     join(root, '.gemini', 'antigravity', 'conversations'),
     join(root, '.gemini', 'antigravity-cli', 'conversations'),
+    join(root, '.gemini', 'antigravity-ide', 'conversations'),
   ];
 }
 

package/src/parsers/antigravity.js

@@ -20,9 +20,8 @@ import { listDbCascades, readDbUsageRecords, readDbWorkspaceUri, readDbSessionEv
  */
 
 const SOURCE = 'antigravity';
-const CONVERSATIONS_DIR = join(homedir(), '.gemini', 'antigravity', 'conversations');
-// `agy` CLI stores conversations in a separate, App-independent directory.
-const CLI_CONVERSATIONS_DIR = join(homedir(), '.gemini', 'antigravity-cli', 'conversations');
+// App, CLI, and the standalone IDE each have their own conversation store.
+const CONVERSATIONS_DIRS = antigravityConversationDirs(homedir());
 
 // User sources → role 'user'; Model source → role 'assistant'; System sources → skip
 const USER_SOURCES = new Set([
@@ -33,24 +32,25 @@ const ASSISTANT_SOURCES = new Set([
   'CORTEX_STEP_SOURCE_MODEL',
 ]);
 
-// ── Process discovery (single instance) ──────────────────────────────
+// ── Process discovery ───────────────────────────────────────────────
 
 const IS_WIN = process.platform === 'win32';
 
 /**
- * Find ONE running language server process with a CSRF token.
- * Returns { pid, csrfToken } or null.
+ * Find running language servers with CSRF tokens. The App and standalone IDE
+ * can run together, and one server cannot read the other's legacy cascades.
  */
-function findLanguageServer() {
+function findLanguageServers() {
   try {
-    return IS_WIN ? findLanguageServerWin() : findLanguageServerUnix();
+    return IS_WIN ? findLanguageServersWin() : findLanguageServersUnix();
   } catch {
-    return null;
+    return [];
   }
 }
 
-function findLanguageServerUnix() {
+function findLanguageServersUnix() {
   const out = execSync("ps aux | grep -i 'antigravity.*language_server'", { encoding: 'utf-8', timeout: 5000 });
+  const servers = [];
   for (const line of out.split('\n')) {
     if (!line.trim()) continue;
     if (line.includes('grep')) continue;
@@ -59,19 +59,19 @@ function findLanguageServerUnix() {
     const pid = parts[1];
     const csrfMatch = line.match(/--csrf_token\s+([0-9a-f-]+)/);
     const csrfToken = csrfMatch ? csrfMatch[1] : '';
-    if (csrfToken) return { pid, csrfToken };
+    if (csrfToken) servers.push({ pid, csrfToken });
   }
-  return null;
+  return servers;
 }
 
-function findLanguageServerWin() {
+function findLanguageServersWin() {
   // Prefer PowerShell/CIM: wmic is disabled by default on Windows 11 23H2+
   // and removed entirely from 25H2 onward. Fall back to wmic for old/stripped
   // environments without PowerShell. Each probe is independently time-boxed and
   // failures are swallowed, so a missing/hung tool never blocks the next one or
   // the parsers that run after antigravity.
   const out = queryProcessesWinPowerShell() ?? queryProcessesWinWmic();
-  if (!out) return null;
+  if (!out) return [];
   return parseWinProcessList(out);
 }
 
@@ -117,20 +117,20 @@ function queryProcessesWinWmic() {
 
 /**
  * Parse "ProcessId=..." / "CommandLine=..." records (from either PowerShell or
- * wmic /format:list) and return the first language_server that carries a
- * --csrf_token, or null. PowerShell emits an explicit "---" separator per
+ * wmic /format:list) and return each language_server that carries a
+ * --csrf_token. PowerShell emits an explicit "---" separator per
  * process; wmic does not and may emit the two fields in either order, so a
  * record also ends whenever a field we've already captured reappears.
  */
-function parseWinProcessList(out) {
+export function parseWinProcessList(out) {
+  const servers = [];
   let pid = '';
   let cmdLine = '';
   const finish = () => {
     if (pid && cmdLine && !/WMIC\.exe|powershell\.exe|pwsh\.exe/i.test(cmdLine)) {
       const csrfMatch = cmdLine.match(/--csrf_token\s+([0-9a-f-]+)/);
-      if (csrfMatch) return { pid, csrfToken: csrfMatch[1] };
+      if (csrfMatch) servers.push({ pid, csrfToken: csrfMatch[1] });
     }
-    return null;
   };
   const reset = () => { pid = ''; cmdLine = ''; };
   for (const line of out.split('\n')) {
@@ -140,14 +140,14 @@ function parseWinProcessList(out) {
     // Record boundary: explicit "---", or a field that would overwrite one we
     // already hold (next process began without a separator, e.g. wmic output).
     if (trimmed === '---' || (isPid && pid) || (isCmd && cmdLine)) {
-      const found = finish();
-      if (found) return found;
+      finish();
       reset();
     }
     if (isPid) pid = trimmed.slice('ProcessId='.length);
     else if (isCmd) cmdLine = trimmed.slice('CommandLine='.length);
   }
-  return finish();
+  finish();
+  return servers;
 }
 
 function findListeningPorts(pid) {
@@ -296,7 +296,7 @@ function projectFromUri(uri) {
  * List cascade IDs backed by a legacy `.pb` file (App history). `.db` cascades
  * are handled separately via offline parsing.
  */
-function listPbCascades(conversationsDir = CONVERSATIONS_DIR) {
+function listPbCascades(conversationsDir) {
   try {
     const out = [];
     for (const f of readdirSync(conversationsDir)) {
@@ -320,6 +320,7 @@ function modelFromRecord(rec) {
 export async function parse({ extraRoots = [] } = {}) {
   const entries = [];
   const sessionEvents = [];
+  const warnings = [];
   const seenResponseIds = new Set();
 
   const extraDirs = [];
@@ -356,7 +357,7 @@ export async function parse({ extraRoots = [] } = {}) {
   const fixtureDirs = process.env.VIBE_USAGE_ANTIGRAVITY_DIRS?.trim();
   const defaultDirs = fixtureDirs
     ? fixtureDirs.split(delimiter).filter(Boolean)
-    : [CONVERSATIONS_DIR, CLI_CONVERSATIONS_DIR];
+    : CONVERSATIONS_DIRS;
   const strictDirs = new Set(extraDirs);
   const conversationDirs = [...new Set([...defaultDirs, ...extraDirs])];
   const candidates = [];
@@ -444,13 +445,14 @@ export async function parse({ extraRoots = [] } = {}) {
   }
 
   // ── Path 2: RPC fallback, only for legacy .pb cascades not already parsed ──
-  const pbDir = defaultDirs[0] || CONVERSATIONS_DIR;
-  const pbCascades = listPbCascades(pbDir).filter((id) => !dbHandled.has(id));
+  const pbCascades = [...new Set(defaultDirs.flatMap(listPbCascades))]
+    .filter((id) => !dbHandled.has(id));
   if (pbCascades.length > 0) {
-    const server = findLanguageServer();
-    const ports = server ? findListeningPorts(server.pid) : [];
-    const baseUrl = ports.length > 0 ? await probeHttpPort(ports, server.csrfToken) : null;
-    if (baseUrl) {
+    const pending = new Set(pbCascades);
+    for (const server of findLanguageServers()) {
+      const ports = findListeningPorts(server.pid);
+      const baseUrl = ports.length > 0 ? await probeHttpPort(ports, server.csrfToken) : null;
+      if (!baseUrl) continue;
       const rpc = (method, body) =>
         rpcPost(
           baseUrl,
@@ -459,7 +461,7 @@ export async function parse({ extraRoots = [] } = {}) {
           server.csrfToken,
         );
 
-      for (const cascadeId of pbCascades) {
+      for (const cascadeId of pending) {
         let resp;
         try {
           resp = await rpc('GetCascadeTrajectory', { cascadeId });
@@ -468,6 +470,7 @@ export async function parse({ extraRoots = [] } = {}) {
         }
         const trajectory = resp?.trajectory;
         if (!trajectory) continue;
+        pending.delete(cascadeId);
 
         const steps = trajectory.steps || [];
         const metadataList = trajectory.generatorMetadata || [];
@@ -519,11 +522,16 @@ export async function parse({ extraRoots = [] } = {}) {
           sessionEvents.push({ sessionId: cascadeId, source: SOURCE, project, timestamp: ts, role });
         }
       }
+      if (pending.size === 0) break;
+    }
+    if (pending.size > 0) {
+      warnings.push(`antigravity: ${pending.size} 个旧格式会话未能读取，请打开对应的 Antigravity IDE/App 后重新同步；已保留上次同步状态。`);
     }
   }
 
   return {
     buckets: aggregateToBuckets(entries),
     sessions: extractSessions(sessionEvents),
+    ...(warnings.length > 0 ? { skipped: true, warnings } : {}),
   };
 }

package/src/parsers/cursor.js

@@ -82,6 +82,41 @@ export function resolveCursorFetchTimeout(value) {
 
 const FETCH_TIMEOUT_MS = resolveCursorFetchTimeout(process.env.VIBE_USAGE_CURSOR_FETCH_TIMEOUT_MS);
 
+function usageNetworkError(error, signal) {
+  // Node fetch usually exposes only "fetch failed" at the top level. DNS,
+  // TLS and connection codes live in cause (or AggregateError.errors when
+  // both IPv4 and IPv6 fail). Report codes, not raw messages that may contain
+  // URLs with proxy credentials or authentication headers.
+  const codes = new Set();
+  const seen = new Set();
+  function visit(err) {
+    if (!err || typeof err !== 'object' || seen.has(err)) return;
+    seen.add(err);
+    if (typeof err.code === 'string' && /^[A-Z][A-Z0-9_]{1,63}$/.test(err.code)) {
+      codes.add(err.code);
+    }
+    visit(err.cause);
+    if (Array.isArray(err.errors)) err.errors.forEach(visit);
+  }
+  visit(error);
+
+  const timedOut = error?.name === 'TimeoutError' || signal.reason?.name === 'TimeoutError';
+  const reason = timedOut
+    ? `timeout after ${FETCH_TIMEOUT_MS}ms`
+    : `network: ${[...codes].join(', ') || 'fetch failed'}`;
+  let hint = '请检查终端网络和代理配置；浏览器能访问 Cursor 不代表 Node.js 使用了相同代理。';
+  if (timedOut) {
+    hint = 'Cursor 用量导出超时，请稍后重试；可通过 VIBE_USAGE_CURSOR_FETCH_TIMEOUT_MS 增大导出等待时间。';
+  } else if (codes.has('ENOTFOUND') || codes.has('EAI_AGAIN')) {
+    hint = '域名解析失败，请检查 DNS 和终端代理配置。';
+  } else if ([...codes].some(code => /CERT|SELF_SIGNED|UNABLE_TO_VERIFY|ERR_TLS_/.test(code))) {
+    hint = 'TLS 证书校验失败，请检查系统时间及代理或公司网络的 CA 证书配置。';
+  }
+  const err = new Error(`Cursor usage export skipped (${reason}). ${hint}`);
+  err.skip = true;
+  return err;
+}
+
 async function fetchUsageCsv(token) {
   const url = `${(process.env.CURSOR_WEB_BASE_URL?.trim() || 'https://cursor.com').replace(/\/+$/, '')}/api/dashboard/export-usage-events-csv?strategy=tokens`;
   const sub = decodeJwtSub(token);
@@ -110,20 +145,19 @@ async function fetchUsageCsv(token) {
   const failures = [];
   for (const headers of attempts) {
     let resp;
+    const signal = AbortSignal.timeout(FETCH_TIMEOUT_MS);
     try {
       resp = await fetch(url, {
         headers: { ...baseHeaders, ...headers },
-        signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+        signal,
       });
+      // The export may time out or disconnect after headers have arrived.
+      // Keep body consumption under the same deadline and soft-skip handling.
+      if (resp.ok) return await resp.text();
     } catch (e) {
-      // Hard-fail on network/timeout: stop trying further headers (won't fix
-      // a downed host) and signal a soft skip to the caller.
-      const reason = e.name === 'TimeoutError' ? 'timeout' : `network: ${e.message}`;
-      const err = new Error(`Cursor usage export skipped (${reason})`);
-      err.skip = true;
-      throw err;
+      // Changing credentials cannot repair a network failure.
+      throw usageNetworkError(e, signal);
     }
-    if (resp.ok) return await resp.text();
     failures.push(`${resp.status} ${resp.statusText}`);
     // Only auth rejections are worth retrying with different credentials.
     // 429/5xx are transient server-side states — soft-skip like network errors
@@ -198,7 +232,7 @@ export async function parse() {
   try {
     csv = await fetchUsageCsv(token);
   } catch (err) {
-    // Network/timeout → silent skip (avoid noisy daemon logs every 5 min).
+    // Network/timeout → skip with diagnostics (quiet sync suppresses these).
     // Auth failure → bubble up so user sees they need to re-login in Cursor.
     // Tell sync.js this was not a successful empty snapshot so it preserves
     // Cursor's incremental state instead of pruning it as dead history.

package/src/parsers/hermes.js

@@ -2,6 +2,7 @@ import { existsSync, readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import { toCount } from './fs-utils.js';
 import { queryDbJson, sqliteUnavailableError, isSqliteUnavailableError } from './sqlite.js';
 
 const HERMES_HOME = process.env.HERMES_HOME || join(homedir(), '.hermes');
@@ -26,6 +27,8 @@ export async function parse() {
   for (const { path: dbPath, profile } of dbs) {
     let sessionRows;
     try {
+      const columns = new Set(queryDb(dbPath, 'PRAGMA table_info(sessions)').map(row => row.name));
+      const cacheWriteColumn = columns.has('cache_write_tokens') ? 'cache_write_tokens' : '0';
       sessionRows = queryDb(dbPath, `SELECT
         id,
         model,
@@ -33,9 +36,11 @@ export async function parse() {
         input_tokens as inputTokens,
         output_tokens as outputTokens,
         cache_read_tokens as cacheReadTokens,
+        ${cacheWriteColumn} as cacheWriteTokens,
         reasoning_tokens as reasoningTokens
         FROM sessions
-        WHERE input_tokens > 0 OR output_tokens > 0`);
+        WHERE input_tokens > 0 OR output_tokens > 0
+          OR cache_read_tokens > 0 OR ${cacheWriteColumn} > 0 OR reasoning_tokens > 0`);
     } catch (err) {
       if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('Hermes');
       throw err;
@@ -47,15 +52,19 @@ export async function parse() {
       if (isNaN(timestamp.getTime())) continue;
 
       // Hermes stores input_tokens exclusive of cache (Anthropic-style semantics)
+      // and output_tokens inclusive of reasoning (CanonicalUsage.total_tokens
+      // adds prompt + output only). Split reasoning instead of counting it twice.
+      const output = toCount(row.outputTokens);
+      const reasoning = Math.min(output, toCount(row.reasoningTokens));
       entries.push({
         source: 'hermes',
         model: row.model || 'unknown',
         project: profile,
         timestamp,
-        inputTokens: row.inputTokens || 0,
-        outputTokens: row.outputTokens || 0,
-        cachedInputTokens: row.cacheReadTokens || 0,
-        reasoningOutputTokens: row.reasoningTokens || 0,
+        inputTokens: toCount(row.inputTokens) + toCount(row.cacheWriteTokens),
+        outputTokens: output - reasoning,
+        cachedInputTokens: toCount(row.cacheReadTokens),
+        reasoningOutputTokens: reasoning,
       });
     }
 

package/src/parsers/index.js

@@ -26,6 +26,7 @@ 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';
+import { parseQoder, parseQoderCn } from './qoder.js';
 
 export const parsers = {
   'claude-code': parseClaudeCode,
@@ -40,6 +41,8 @@ export const parsers = {
   'openclaw': parseOpenclaw,
   'omp': parseOmp,
   'pi-coding-agent': parsePiCodingAgent,
+  'qoder': parseQoder,
+  'qoder-cn': parseQoderCn,
   'qwen-code': parseQwenCode,
   'kimi-code': parseKimiCode,
   'amp': parseAmp,

package/src/parsers/qoder.js

@@ -0,0 +1,334 @@
+import { createReadStream, existsSync, readdirSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { join, basename, extname } from 'node:path';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import { projectFromCwd, toCount } from './fs-utils.js';
+import { isSqliteUnavailableError, queryDbJsonSnapshotOnLock, sqliteUnavailableError } from './sqlite.js';
+import { QODER_EDITIONS, getQoderProjectsDir, getQoderDbPath } from '../qoder-roots.js';
+
+/**
+ * Qoder (Alibaba's agentic coding platform). Two editions with fully separate
+ * accounts, billing, model pools and data directories — see ../qoder-roots.js:
+ *
+ *   'qoder'     international qoder.com     ~/.qoder      Application Support/Qoder
+ *   'qoder-cn'  China qoder.com.cn          ~/.qoder-cn   Application Support/QoderCN
+ *
+ * Each edition has two local data shapes, verified on 2026-09-04 against
+ * Qoder CLI 1.1.42, Qoder desktop app 0.1.6 and both IDEs 1.28.0:
+ *
+ * 1. The IDE's SQLite store <ideDataDir>/SharedClientCache/cache/db/local.db:
+ *    table chat_message with `token_info` JSON { prompt_tokens, cached_tokens,
+ *    completion_tokens, max_input_tokens } and `model_info` JSON { model_key }.
+ *    Real tokens (prompt_tokens INCLUDES cached_tokens), no credits. `model_key`
+ *    is usually a routing tier ('auto', 'ultimate', 'performance', 'efficient',
+ *    'lite') rather than a concrete model; tiers are reported as `qoder-<tier>`
+ *    so they stay unmatched server-side (see normalizeQoderModel).
+ *    → token buckets + sessions.
+ *
+ * 2. JSONL transcripts (CLI + desktop app share them — the app embeds the CLI):
+ *    <configDir>/projects/<cwd-slug>/<sessionId>.jsonl plus sub-agent files at
+ *    <configDir>/projects/<cwd-slug>/<sessionId>/subagents/agent-*.jsonl.
+ *    Claude Code-shaped records { type, timestamp, uuid, sessionId, cwd,
+ *    message:{ id, role, model, content, usage } }. Qoder bills these in
+ *    CREDITS: `message.usage` is { input_tokens:0, output_tokens:0, …,
+ *    credits, original_credits, billable } — every token field is 0. One
+ *    assistant message is written as several lines (one per content block);
+ *    only the last line of a message carries `usage`.
+ *    → sessions only. The credit amount is an account funding path and is not
+ *    collected (cost-accounting invariant in AGENTS.md); token fields are read
+ *    so that a future Qoder build that reports tokens is counted without a
+ *    parser change.
+ */
+
+const DEFAULT_MODEL = 'qoder-agent';
+const MAX_WARNINGS = 10;
+
+// Qoder's routing tiers are not models. Left bare, `auto` collides with the
+// Cursor `auto` entry in the server pricing map and gets billed at Cursor's
+// rate, so tiers are namespaced (`qoder-auto`, …) — those never match a price
+// and render as unmatched, which is the truthful state. Concrete model keys
+// (`qmodel_38max`, …) are passed through unchanged.
+const ROUTING_TIERS = new Set(['auto', 'ultimate', 'performance', 'efficient', 'lite']);
+
+function normalizeQoderModel(key) {
+  const k = typeof key === 'string' ? key.trim() : '';
+  if (!k) return DEFAULT_MODEL;
+  return ROUTING_TIERS.has(k.toLowerCase()) ? `qoder-${k.toLowerCase()}` : k;
+}
+
+function toDate(value) {
+  if (value == null || value === '') return null;
+  if (typeof value === 'number') {
+    const ms = value < 1e12 ? value * 1000 : value;
+    const d = new Date(ms);
+    return Number.isNaN(d.getTime()) ? null : d;
+  }
+  const s = String(value).trim();
+  if (/^\d+(\.\d+)?$/.test(s)) return toDate(Number(s));
+  const d = new Date(s);
+  return Number.isNaN(d.getTime()) ? null : d;
+}
+
+function warn(ctx, message) {
+  if (ctx.warnings.length < MAX_WARNINGS) ctx.warnings.push(`${ctx.source}: ${message}`);
+}
+
+// ── JSONL layer (CLI + desktop app) ────────────────────────────────────────
+
+function listJsonlFiles(root, ctx) {
+  const out = [];
+  const walk = dir => {
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch (err) {
+      ctx.skipped = true;
+      warn(ctx, `cannot read ${dir}: ${err.message}`);
+      return;
+    }
+    for (const entry of entries) {
+      const p = join(dir, entry.name);
+      if (entry.isDirectory()) walk(p);
+      else if (entry.isFile() && extname(entry.name) === '.jsonl') out.push(p);
+    }
+  };
+  walk(root);
+  return out;
+}
+
+// A `user` record is a human prompt unless it is a tool result being fed back.
+function isHumanPrompt(record) {
+  if (record.humanInput) return true;
+  if (record.origin && record.origin.kind === 'human') return true;
+  if (record.toolUseResult) return false;
+  const content = record.message?.content;
+  if (Array.isArray(content)) {
+    return !content.some(c => c && typeof c === 'object' && c.type === 'tool_result');
+  }
+  return true;
+}
+
+async function parseTranscriptFile(filePath, ctx) {
+  const { source, entries, events } = ctx;
+  const fallbackSession = basename(filePath, '.jsonl');
+  // One assistant message spans several lines; keep the last usage-bearing
+  // record per message id so a call is counted exactly once.
+  const usageByMessage = new Map();
+
+  const rl = createInterface({ input: createReadStream(filePath, { encoding: 'utf-8' }), crlfDelay: Infinity });
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!record || typeof record !== 'object') continue;
+    const type = record.type;
+    if (type !== 'user' && type !== 'assistant') continue;
+
+    const timestamp = toDate(record.timestamp);
+    if (!timestamp) continue;
+    const sessionId = record.sessionId || record.session_id || fallbackSession;
+    const project = projectFromCwd(record.cwd);
+    const message = record.message && typeof record.message === 'object' ? record.message : {};
+
+    if (type === 'user') {
+      if (isHumanPrompt(record)) {
+        events.push({ sessionId, source, project, timestamp, role: 'user' });
+      }
+      continue;
+    }
+
+    events.push({ sessionId, source, project, timestamp, role: 'assistant' });
+
+    const usage = message.usage;
+    if (!usage || typeof usage !== 'object') continue;
+    const key = `${sessionId}|${message.id || record.uuid || `${filePath}:${usageByMessage.size}`}`;
+    usageByMessage.set(key, {
+      usage,
+      model: normalizeQoderModel(message.model),
+      project,
+      timestamp,
+    });
+  }
+
+  for (const { usage, model, project, timestamp } of usageByMessage.values()) {
+    // Cache writes join input (same convention as the Claude Code parser).
+    const input = toCount(usage.input_tokens) + toCount(usage.cache_creation_input_tokens);
+    const cached = toCount(usage.cache_read_input_tokens ?? usage.cached_tokens);
+    const output = toCount(usage.output_tokens);
+    if (input + cached + output === 0) continue; // credit-billed call: tokens not reported
+    entries.push({
+      source,
+      model,
+      project,
+      timestamp,
+      inputTokens: input,
+      outputTokens: output,
+      cachedInputTokens: cached,
+      reasoningOutputTokens: 0,
+    });
+  }
+}
+
+async function parseTranscripts(edition, ctx) {
+  const root = getQoderProjectsDir(edition);
+  if (!existsSync(root)) return;
+  for (const file of listJsonlFiles(root, ctx)) {
+    try {
+      await parseTranscriptFile(file, ctx);
+    } catch (err) {
+      // A half-written or unreadable transcript: keep prior upload state, retry next run.
+      ctx.skipped = true;
+      warn(ctx, `cannot read ${file}: ${err.message}`);
+    }
+  }
+}
+
+// ── SQLite layer (IDE) ─────────────────────────────────────────────────────
+
+const IDE_COLUMNS = `
+  cm.id AS id,
+  cm.session_id AS sessionId,
+  cm.request_id AS requestId,
+  cm.role AS role,
+  cm.token_info AS tokenInfo,
+  cm.model_info AS modelInfo,
+  cm.gmt_create AS created`;
+
+// Only token/model/timing columns are selected; message content, tool results
+// and summaries are never read.
+const IDE_QUERY_WITH_SESSION = `SELECT ${IDE_COLUMNS},
+  cs.project_uri AS projectUri,
+  cs.project_name AS projectName,
+  cs.preferred_model_info AS preferredModelInfo
+  FROM chat_message cm
+  LEFT JOIN chat_session cs ON cs.session_id = cm.session_id
+  WHERE cm.role IN ('user', 'assistant')`;
+
+const IDE_QUERY_PLAIN = `SELECT ${IDE_COLUMNS}
+  FROM chat_message cm
+  WHERE cm.role IN ('user', 'assistant')`;
+
+function isMissingTable(err, table) {
+  return err && typeof err.message === 'string' && new RegExp(`no such table:\\s*${table}`, 'i').test(err.message);
+}
+
+function queryIdeRows(dbPath) {
+  const opts = { tempPrefix: 'vibe-usage-qoder-' };
+  try {
+    return queryDbJsonSnapshotOnLock(dbPath, IDE_QUERY_WITH_SESSION, opts);
+  } catch (err) {
+    // Older Qoder CN builds have no chat_session table; degrade to unattributed projects.
+    if (isMissingTable(err, 'chat_session')) return queryDbJsonSnapshotOnLock(dbPath, IDE_QUERY_PLAIN, opts);
+    if (isMissingTable(err, 'chat_message')) return [];
+    throw err;
+  }
+}
+
+function parseJson(value) {
+  if (!value) return null;
+  if (typeof value === 'object') return value;
+  try {
+    const parsed = JSON.parse(String(value));
+    return parsed && typeof parsed === 'object' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function ideProject(row) {
+  const uri = typeof row.projectUri === 'string' ? row.projectUri.trim() : '';
+  if (uri) {
+    if (uri.startsWith('file://')) {
+      try {
+        return projectFromCwd(decodeURIComponent(new URL(uri).pathname));
+      } catch {
+        // fall through to project_name
+      }
+    } else {
+      return projectFromCwd(uri);
+    }
+  }
+  const name = typeof row.projectName === 'string' ? row.projectName.trim() : '';
+  // '.' is Qoder's "no project" sentinel.
+  return name && name !== '.' ? name : 'unknown';
+}
+
+function ideModel(row) {
+  const info = parseJson(row.modelInfo);
+  const preferred = parseJson(row.preferredModelInfo);
+  const key = info?.model_key || info?.modelKey || preferred?.model_key || preferred?.modelKey;
+  return normalizeQoderModel(key);
+}
+
+function parseIde(edition, ctx) {
+  const { source, entries, events } = ctx;
+  const dbPath = getQoderDbPath(edition);
+  if (!existsSync(dbPath)) return;
+
+  let rows;
+  try {
+    rows = queryIdeRows(dbPath);
+  } catch (err) {
+    if (isSqliteUnavailableError(err)) throw sqliteUnavailableError(`${QODER_EDITIONS[edition].label} IDE`);
+    // Schema drift or a transient read failure: fail soft so incremental state
+    // for this source is not pruned.
+    ctx.skipped = true;
+    warn(ctx, `cannot read ${dbPath}: ${err.message}`);
+    return;
+  }
+
+  for (const row of rows) {
+    const timestamp = toDate(row.created);
+    if (!timestamp) continue;
+    const project = ideProject(row);
+    const sessionId = row.sessionId || 'unknown';
+    const role = row.role === 'user' ? 'user' : 'assistant';
+    events.push({ sessionId, source, project, timestamp, role });
+    if (role !== 'assistant') continue;
+
+    const tokens = parseJson(row.tokenInfo);
+    if (!tokens) continue;
+    const prompt = toCount(tokens.prompt_tokens);
+    const cached = Math.min(prompt, toCount(tokens.cached_tokens));
+    const completion = toCount(tokens.completion_tokens);
+    if (prompt + completion === 0) continue;
+
+    entries.push({
+      source,
+      model: ideModel(row),
+      project,
+      timestamp,
+      // prompt_tokens already includes cached_tokens.
+      inputTokens: prompt - cached,
+      outputTokens: completion,
+      cachedInputTokens: cached,
+      reasoningOutputTokens: 0,
+    });
+  }
+}
+
+// ── Entry points ───────────────────────────────────────────────────────────
+
+async function parseEdition(edition) {
+  const ctx = { source: QODER_EDITIONS[edition].source, entries: [], events: [], warnings: [], skipped: false };
+  await parseTranscripts(edition, ctx);
+  parseIde(edition, ctx);
+  return {
+    buckets: aggregateToBuckets(ctx.entries),
+    sessions: extractSessions(ctx.events),
+    skipped: ctx.skipped,
+    warnings: ctx.warnings,
+  };
+}
+
+export async function parseQoder() {
+  return parseEdition('qoder');
+}
+
+export async function parseQoderCn() {
+  return parseEdition('qoder-cn');
+}

package/src/qoder-roots.js

@@ -0,0 +1,82 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+// Path resolution for the two Qoder editions (same role as the other *-roots.js
+// modules: shared by tools.js detection and the parser, free of parser imports).
+//
+//   edition     CLI config dir   IDE data dir (macOS)
+//   'qoder'     ~/.qoder         ~/Library/Application Support/Qoder
+//   'qoder-cn'  ~/.qoder-cn      ~/Library/Application Support/QoderCN
+//
+// Verified against Qoder CLI 1.1.42 (both editions are one bundle branded via
+// QODERCLI_SITE) and IDE 1.28.0 product.json / extension code on 2026-09-04.
+
+const DB_RELATIVE = join('SharedClientCache', 'cache', 'db', 'local.db');
+
+export const QODER_EDITIONS = {
+  qoder: {
+    source: 'qoder',
+    label: 'Qoder',
+    cliDirName: '.qoder',
+    cliEnv: 'QODER_CONFIG_DIR',
+    ideDirName: 'Qoder',
+    ideHomeEnv: 'QODER_HOME',
+    testProjectsEnv: 'VIBE_USAGE_QODER_PROJECTS',
+    testDbEnv: 'VIBE_USAGE_QODER_DB',
+  },
+  'qoder-cn': {
+    source: 'qoder-cn',
+    label: 'Qoder CN',
+    cliDirName: '.qoder-cn',
+    cliEnv: 'QODERCN_CONFIG_DIR',
+    ideDirName: 'QoderCN',
+    ideHomeEnv: 'QODER_CN_HOME',
+    testProjectsEnv: 'VIBE_USAGE_QODER_CN_PROJECTS',
+    testDbEnv: 'VIBE_USAGE_QODER_CN_DB',
+  },
+};
+
+function expandHome(p) {
+  if (!p) return p;
+  return p.startsWith('~') ? join(homedir(), p.slice(1)) : p;
+}
+
+/** CLI/app transcript root: <configDir>/projects. Honors Qoder's own config-dir env. */
+export function getQoderProjectsDir(edition) {
+  const e = QODER_EDITIONS[edition];
+  const test = process.env[e.testProjectsEnv]?.trim();
+  if (test) return expandHome(test);
+  const cfg = process.env[e.cliEnv]?.trim();
+  const root = cfg ? expandHome(cfg).replace(/[/\\]+$/, '') : join(homedir(), e.cliDirName);
+  return join(root, 'projects');
+}
+
+/** IDE SQLite store. Honors QODER_HOME / QODER_CN_HOME like Qoder's own language server. */
+export function getQoderDbPath(edition) {
+  const e = QODER_EDITIONS[edition];
+  const test = process.env[e.testDbEnv]?.trim();
+  if (test) return expandHome(test);
+  const home = process.env[e.ideHomeEnv]?.trim();
+  if (home) return join(expandHome(home), 'cache', 'db', 'local.db');
+  let root;
+  if (process.platform === 'darwin') {
+    root = join(homedir(), 'Library', 'Application Support', e.ideDirName);
+  } else if (process.platform === 'win32') {
+    const appData = process.env.APPDATA?.trim() || join(homedir(), 'AppData', 'Roaming');
+    root = join(appData, e.ideDirName);
+  } else {
+    const xdg = process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), '.config');
+    root = join(xdg, e.ideDirName);
+  }
+  return join(root, DB_RELATIVE);
+}
+
+/**
+ * Installed-detection for tools.js. `~/.qoder` alone proves nothing — the IDE
+ * also uses it (product.json dataFolderName) for extensions — so look for the
+ * transcript directory or the IDE database specifically.
+ */
+export function findQoderDataDirs(edition) {
+  return [getQoderProjectsDir(edition), getQoderDbPath(edition)].filter(existsSync);
+}

package/src/tools.js

@@ -13,6 +13,7 @@ import {
 import { findClineDataDirs } from './cline-roots.js';
 import { findCraftDataDirs } from './craft-roots.js';
 import { findOmpDataDirs, findPiDataDirs } from './pi-roots.js';
+import { findQoderDataDirs, getQoderProjectsDir } from './qoder-roots.js';
 import { findWorkbuddyDataDirs } from './workbuddy-roots.js';
 
 export function getAlmaDbPath(env = process.env, platform = process.platform, home = homedir()) {
@@ -174,8 +175,7 @@ export function getMimocodeDbPath(env = process.env) {
 
 export function findAntigravityDataDirs(extraRoots = []) {
   return [...new Set([
-    join(homedir(), '.gemini', 'antigravity'),
-    join(homedir(), '.gemini', 'antigravity-cli'),
+    ...antigravityConversationDirs(homedir()).map(dirname),
     ...extraRoots.flatMap(root => antigravityConversationDirs(root).map(dirname)),
   ])].filter(existsSync);
 }
@@ -324,6 +324,20 @@ export const TOOLS = [
       findPiDataDirs(extraRootList(extraRoots?.['pi-coding-agent']))
     ),
   },
+  {
+    name: 'Qoder',
+    id: 'qoder',
+    // CLI + desktop app transcripts; the IDE's SharedClientCache/cache/db/local.db
+    // is detected too. `~/.qoder` alone is not proof (the IDE stores extensions there).
+    dataDir: getQoderProjectsDir('qoder'),
+    detectDataDirs: () => findQoderDataDirs('qoder'),
+  },
+  {
+    name: 'Qoder CN',
+    id: 'qoder-cn',
+    dataDir: getQoderProjectsDir('qoder-cn'),
+    detectDataDirs: () => findQoderDataDirs('qoder-cn'),
+  },
   {
     name: 'Qwen Code',
     id: 'qwen-code',