@vibe-cafe/vibe-usage 0.11.1 → 0.12.1

package/README.md

@@ -62,7 +62,7 @@ npx @vibe-cafe/vibe-usage help --all   # Full help (plain `help` shows the short
 
 The versioned `quota` JSON contract is designed for local desktop clients. `discover` only checks ordinary app, config-directory, and executable presence signals: it does not open credentials or use the network. `fetch` invokes only products explicitly named with `--product`, and one provider failure does not prevent results for the others.
 
-- **Kimi Code** reads the official Kimi CLI OAuth file (`$KIMI_SHARE_DIR/credentials/kimi-code.json`, otherwise `~/.kimi/credentials/kimi-code.json`) and calls `https://api.kimi.com/coding/v1/usages`. When the short-lived access token is close to expiry, it uses Kimi's standard OAuth refresh flow and atomically rotates the official credential with owner-only permissions. Refreshes are serialized across Vibe Usage processes and re-check the file before writing so a concurrent Kimi CLI refresh wins safely.
+- **Kimi Code** reads the official Kimi CLI OAuth file — `$KIMI_SHARE_DIR/credentials/kimi-code.json` when configured, otherwise the current CLI home (`$KIMI_CODE_HOME`, else `~/.kimi-code`) and then the legacy `~/.kimi` home, whichever holds a login — and calls `https://api.kimi.com/coding/v1/usages`. When the short-lived access token is close to expiry, it uses Kimi's standard OAuth refresh flow and atomically rotates the official credential with owner-only permissions. Refreshes are serialized across Vibe Usage processes and re-check the file before writing so a concurrent Kimi CLI refresh wins safely.
 - **ZCode / GLM Coding Plan** accepts only a caller-supplied regional key: `BIGMODEL_API_KEY` calls the domestic `https://open.bigmodel.cn/api/monitor/usage/quota/limit`, while the existing `Z_AI_API_KEY` keeps using `https://api.z.ai/api/monitor/usage/quota/limit`. If both are present, the explicitly named BigModel key wins. It does not read ZCode's private OAuth state.
 - **Grok** reads at most the final 2 MiB of the official CLI's ordinary `$GROK_HOME/logs/unified.jsonl` (default `~/.grok/logs/unified.jsonl`). It accepts only the structured `billing: fetched credits config` event and projects the current utilization, period bounds, subscription tier, and event timestamp. It performs no network request, reads no credentials, and never returns or retains other log fields.
 - **Cursor** is detected independently but remains non-fetchable until an official or stable quota protocol is available. Quota monitoring does not read Cursor's login token/database, browser cookies, another app's Keychain, network traffic, or UI.
@@ -76,6 +76,7 @@ Quota results are never uploaded or added to incremental sync state. Credential-
 | 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. Provider-prefixed model identifiers are normalized to their final model segment. 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. |
 | Cindy | Per-owner SQLite ledgers in the two regional Electron user-data roots: macOS `~/Library/Application Support/{CindyGlobal,Cindy}/cindy-*.db`, Windows `%APPDATA%\{CindyGlobal,Cindy}\cindy-*.db`, Linux `${XDG_CONFIG_HOME:-~/.config}/{CindyGlobal,Cindy}/cindy-*.db` (fixture/relocation override: `VIBE_USAGE_CINDY_DIRS`). Cindy-launched Claude Code already writes ordinary `~/.claude` transcripts, so it remains attributed to **Claude Code** and is not read again. Cindy's otherwise-private Codex and Pi daily/model ledger rows augment the existing **Codex** and **pi** sources. Currency rows are summed and cache creation joins input; chat messages, credentials, costs, and owner ids are never selected. The ledger adds token buckets only, without project or session timing. |
+| CodeArts Agent (CodeArts Doer for Coding) | The embedded agent kernel's WAL SQLite store at `~/.codeartsdoer/codearts-data/opencode.db` (fixture/relocation override: `VIBE_USAGE_CODEARTS_AGENT_DIRS`, whose entries may be the database, `codearts-data`, or its `.codeartsdoer` parent). Reads only allow-listed identity/timing/model/project/token fields from `message` joined to `session`; prompt text, tool payloads, errors, costs, credentials and account/quota data are never selected. Input, output, cache reads and reasoning are separate counters; an untyped cache write is priced as the cheaper 5m cache-creation bucket rather than folded into input, since the store gives no per-TTL breakdown to price it more precisely. Child-agent calls keep contributing token usage, while their injected user messages fold into the top-level logical session instead of inflating human prompt/session counts. Copied stores deduplicate by session + message id, and lock/read failures use a disposable WAL snapshot or preserve prior incremental state. |
 | Codex CLI | `$CODEX_HOME/sessions/` and `$CODEX_HOME/archived_sessions/` (default `~/.codex`), plus an optional temporary `--extra-codex-home`, legacy `codexExtraHome`, or explicitly added Codex/Multica roots; a versioned local index avoids re-reading unchanged rollouts and reads only safe append tails for ordinary sessions, same-session continuation files are combined without counting exact live/archive/cross-root copies twice, and fork/sub-agent replay remains excluded |
 | Cola | `~/.cola/sessions/<scope>/*.jsonl` (or `$COLA_DATA_DIR/sessions/`), verified with Cola 1.4.4. Reads assistant token usage and session timing through the shared Pi reader; cache writes join input, cache reads remain separate, and reasoning is split from output. Copied transcripts with new session headers are deduplicated using the original record metadata and attributed to the earliest available session copy. Project names come from `cwd`, never channel/scope names. |
 | Grok | `$GROK_HOME/sessions/<encoded-cwd>/<session-id>/` (default `~/.grok`) plus explicitly added Grok Homes; token usage from `updates.jsonl` `turn_completed.usage` (per-model `modelUsage`, cache reads, reasoning); project from `summary.json` cwd; copied sessions keep the more complete local record |
@@ -84,7 +85,7 @@ Quota results are never uploaded or added to incremental sync state. Credential-
 | 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), with `storage/message/` as the legacy alternative; supports explicitly added data roots |
+| OpenCode | `~/.local/share/opencode/opencode.db` (SQLite) — both the legacy `message` table and the 2.x `session_message` projection are read, merged by message id — with `storage/message/` as the legacy alternative; cache writes are counted as 5m cache creation; supports explicitly added data roots |
 | 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/`, 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 |

package/package.json

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

package/src/codearts-roots.js

@@ -0,0 +1,60 @@
+import { accessSync, constants, realpathSync, statSync } from 'node:fs';
+import { basename, delimiter, join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+
+function normalizeRoot(path, home) {
+  if (path === '~') return home;
+  if (path.startsWith('~/') || path.startsWith('~\\')) return join(home, path.slice(2));
+  return resolve(path);
+}
+
+export function resolveCodeartsAgentRoots(env = process.env, home = homedir()) {
+  const override = env.VIBE_USAGE_CODEARTS_AGENT_DIRS?.trim();
+  if (!override) return [join(home, '.codeartsdoer', 'codearts-data')];
+  return override.split(delimiter)
+    .map(path => path.trim())
+    .filter(Boolean)
+    .map(path => normalizeRoot(path, home));
+}
+
+function findDb(root) {
+  const stat = statSync(root);
+  const candidates = stat.isFile()
+    ? [root]
+    : [join(root, 'opencode.db'), join(root, 'codearts-data', 'opencode.db')];
+
+  for (const candidate of candidates) {
+    try {
+      if (!statSync(candidate).isFile()) continue;
+      if (basename(candidate) !== 'opencode.db') continue;
+      accessSync(candidate, constants.R_OK);
+      return realpathSync(candidate);
+    } catch (err) {
+      if (err.code !== 'ENOENT' && err.code !== 'ENOTDIR') throw err;
+    }
+  }
+  return null;
+}
+
+/**
+ * Locate CodeArts Agent's accounting databases. An override may point at the
+ * data directory, its `.codeartsdoer` parent, or `opencode.db` itself. The
+ * default matches the home-relative location used by the desktop agent kernel;
+ * the override also covers relocated and platform-specific profiles.
+ */
+export function findCodeartsAgentDbs({ env = process.env, home = homedir(), onWarning = () => {} } = {}) {
+  const seen = new Set();
+  const dbs = [];
+  for (const root of resolveCodeartsAgentRoots(env, home)) {
+    try {
+      const db = findDb(root);
+      if (!db || seen.has(db)) continue;
+      seen.add(db);
+      dbs.push(db);
+    } catch (err) {
+      if (err.code === 'ENOENT' || err.code === 'ENOTDIR') continue;
+      onWarning(`CodeArts Agent: 无法读取数据目录 ${root}: ${err.message}`);
+    }
+  }
+  return dbs;
+}

package/src/daemon-service.js

@@ -114,19 +114,40 @@ function escapeXml(value) {
 
 // Variables that relocate a tool's on-disk store. The service runs from a
 // launchd/systemd unit that inherits nothing, so anything the parsers read for
-// discovery has to be captured into the unit at install time.
+// discovery has to be captured into the unit at install time. Keep this list in
+// sync with the store-locating variables the parsers and roots modules read
+// (`grep -rho 'process\.env\.[A-Z_]*' src/parsers src/*-roots.js`): a variable
+// missing here makes the background service sync a different store than the
+// foreground CLI (issue #112). Test-only overrides (`VIBE_USAGE_*`) and
+// accounting knobs are deliberately absent -- they do not relocate a store.
 const PRESERVED_SERVICE_ENV = [
+  'AMP_DATA_DIR',
   'CLINE_DIR',
   'CLINE_DATA_DIR',
   'CLINE_SESSION_DATA_DIR',
+  'CODEBUDDY_CONFIG_DIR',
+  'CODEX_HOME',
   'COLA_DATA_DIR',
+  'CRAFT_AGENT_DIR',
+  'CRAFTAGENT_DIR',
+  'CURSOR_CONFIG_DIR',
+  'DIMCODE_HOME',
+  'DSH_HOME',
+  'GROK_HOME',
   'HERMES_HOME',
+  'KIMI_CODE_HOME',
+  'KIRO_BASE_PATH',
+  'KIRO_CLI_DB_PATH',
+  'KIRO_CLI_SESSIONS_DIR',
+  'KIRO_SESSIONS_DIR',
+  'KIRO_USER_PATH',
   'MCODE_HOME',
   'MIMOCODE_HOME',
   'MIMOCODE_DB',
-  'XDG_DATA_HOME',
+  'PI_CONFIG_DIR',
   'PI_CODING_AGENT_DIR',
   'PI_CODING_AGENT_SESSION_DIR',
+  'XDG_DATA_HOME',
 ];
 
 function serviceEnvironment(claudeConfigDir, env) {

package/src/parsers/codearts-agent.js

@@ -0,0 +1,184 @@
+import { projectFromCwd, toCount } from './fs-utils.js';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import {
+  isSqliteUnavailableError,
+  queryDbJsonSnapshotOnLock,
+  sqliteUnavailableError,
+} from './sqlite.js';
+import { findCodeartsAgentDbs } from '../codearts-roots.js';
+
+const SOURCE = 'codearts-agent';
+
+// CodeArts Agent 26.9.101 uses an OpenCode-derived WAL database, but it is a
+// separate product/account and therefore a separate Vibe Usage source. The
+// recursive map folds child-agent sessions into their top-level user session;
+// all child model calls remain billable while their injected `user` messages
+// never become human prompts. Only identity, timing, model, project and token
+// counters are selected. Message/part content, tools, errors, costs, account
+// data and the CodeArts JSON/log files stay unread.
+const USAGE_SQL = `
+  WITH RECURSIVE session_tree(
+    sessionId, logicalSessionId, logicalDirectory, isChild, trail
+  ) AS (
+    SELECT s.id, s.id, s.directory, 0, ',' || s.id || ','
+    FROM session AS s
+    WHERE s.parent_id IS NULL
+      OR NOT EXISTS (SELECT 1 FROM session AS p WHERE p.id = s.parent_id)
+    UNION ALL
+    SELECT s.id, t.logicalSessionId, t.logicalDirectory, 1,
+      t.trail || s.id || ','
+    FROM session AS s
+    JOIN session_tree AS t ON s.parent_id = t.sessionId
+    WHERE instr(t.trail, ',' || s.id || ',') = 0
+  ), session_map AS (
+    SELECT
+      s.id AS sessionId,
+      coalesce(t.logicalSessionId, s.id) AS logicalSessionId,
+      coalesce(t.logicalDirectory, s.directory) AS logicalDirectory,
+      s.directory AS physicalDirectory,
+      coalesce(t.isChild, 0) AS isChild
+    FROM session AS s
+    LEFT JOIN session_tree AS t ON t.sessionId = s.id
+  )
+  SELECT
+    m.id AS messageId,
+    m.session_id AS physicalSessionId,
+    coalesce(sm.logicalSessionId, m.session_id) AS logicalSessionId,
+    coalesce(sm.isChild, 0) AS isChild,
+    sm.logicalDirectory AS logicalDirectory,
+    sm.physicalDirectory AS physicalDirectory,
+    m.time_created AS columnCreated,
+    json_extract(m.data, '$.role') AS role,
+    json_extract(m.data, '$.time.created') AS dataCreated,
+    coalesce(
+      json_extract(m.data, '$.modelID'),
+      json_extract(m.data, '$.modelId'),
+      json_extract(m.data, '$.model.modelID'),
+      json_extract(m.data, '$.model.modelId')
+    ) AS model,
+    json_extract(m.data, '$.path.root') AS rootPath,
+    json_extract(m.data, '$.path.cwd') AS cwdPath,
+    json_extract(m.data, '$.tokens.input') AS inputTokens,
+    json_extract(m.data, '$.tokens.output') AS outputTokens,
+    json_extract(m.data, '$.tokens.cache.read') AS cacheReadTokens,
+    json_extract(m.data, '$.tokens.cache.write') AS cacheWriteTokens,
+    json_extract(m.data, '$.tokens.reasoning') AS reasoningTokens
+  FROM message AS m
+  LEFT JOIN session_map AS sm ON sm.sessionId = m.session_id
+  ORDER BY m.time_created, m.id
+`;
+
+function timestampFrom(value, fallback) {
+  const raw = value ?? fallback;
+  if (raw == null) return null;
+  const number = Number(raw);
+  let date;
+  if (Number.isFinite(number) && number > 0) {
+    date = new Date(number < 1e12 ? number * 1000 : number);
+  } else if (typeof raw === 'string') {
+    date = new Date(raw);
+  } else {
+    return null;
+  }
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+
+function tokenFootprint(row) {
+  return toCount(row.inputTokens) + toCount(row.outputTokens)
+    + toCount(row.cacheReadTokens) + toCount(row.cacheWriteTokens)
+    + toCount(row.reasoningTokens);
+}
+
+function projectFor(row) {
+  return projectFromCwd(
+    row.rootPath || row.cwdPath || row.logicalDirectory || row.physicalDirectory,
+  );
+}
+
+export async function parse() {
+  const warnings = [];
+  const dbs = findCodeartsAgentDbs({ onWarning: message => warnings.push(message) });
+  const records = new Map();
+
+  for (const dbPath of dbs) {
+    let rows;
+    try {
+      rows = queryDbJsonSnapshotOnLock(dbPath, USAGE_SQL, {
+        tempPrefix: 'vibe-usage-codearts-agent',
+      });
+    } catch (err) {
+      if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('CodeArts Agent');
+      warnings.push(`CodeArts Agent: 无法读取 ${dbPath}: ${err.message}`);
+      continue;
+    }
+
+    for (const [index, row] of rows.entries()) {
+      const timestamp = timestampFrom(row.dataCreated, row.columnCreated);
+      if (!timestamp) continue;
+      const sessionId = row.physicalSessionId == null ? '' : String(row.physicalSessionId);
+      const messageId = row.messageId == null ? '' : String(row.messageId);
+      const key = sessionId && messageId
+        ? JSON.stringify([sessionId, messageId])
+        : JSON.stringify([dbPath, index]);
+      const candidate = { ...row, timestamp };
+      const previous = records.get(key);
+      if (!previous || tokenFootprint(candidate) > tokenFootprint(previous)) {
+        records.set(key, candidate);
+      }
+    }
+  }
+
+  // A partial multi-profile read would look like legitimate deletion to the
+  // incremental sync layer. Suppress the entire source until every discovered
+  // database can be read again.
+  if (warnings.length) return { buckets: [], sessions: [], skipped: true, warnings };
+
+  const entries = [];
+  const events = [];
+  const sessionsWithUserPrompt = new Set();
+
+  for (const row of records.values()) {
+    const project = projectFor(row);
+    const logicalSessionId = String(row.logicalSessionId || row.physicalSessionId || 'unknown');
+    if (row.role) {
+      const isHumanPrompt = row.role === 'user' && !row.isChild;
+      events.push({
+        sessionId: logicalSessionId,
+        source: SOURCE,
+        project,
+        timestamp: row.timestamp,
+        role: isHumanPrompt ? 'user' : 'assistant',
+      });
+      if (isHumanPrompt) sessionsWithUserPrompt.add(logicalSessionId);
+    }
+
+    if (row.role !== 'assistant') continue;
+    const inputTokens = toCount(row.inputTokens);
+    const outputTokens = toCount(row.outputTokens);
+    const cachedInputTokens = toCount(row.cacheReadTokens);
+    const reasoningOutputTokens = toCount(row.reasoningTokens);
+    // The store only gives one cache-write total with no per-TTL breakdown,
+    // so an untyped write is priced as the cheaper 5m bucket rather than
+    // folded into input: better to undercharge than overcharge an unknown TTL.
+    const cacheCreation5mTokens = toCount(row.cacheWriteTokens);
+    if (inputTokens + outputTokens + cachedInputTokens + reasoningOutputTokens
+      + cacheCreation5mTokens === 0) continue;
+
+    entries.push({
+      source: SOURCE,
+      model: row.model || 'unknown',
+      project,
+      timestamp: row.timestamp,
+      inputTokens,
+      outputTokens,
+      cachedInputTokens,
+      reasoningOutputTokens,
+      cacheCreation5mTokens,
+    });
+  }
+
+  return {
+    buckets: aggregateToBuckets(entries),
+    sessions: extractSessions(events.filter(event => sessionsWithUserPrompt.has(event.sessionId))),
+  };
+}

package/src/parsers/cursor.js

@@ -264,7 +264,25 @@ export async function parse() {
   const cacheReadIdx = idx('Cache Read');
   const outputIdx = idx('Output Tokens');
 
-  if (dateIdx < 0 || modelIdx < 0) return { buckets: [], sessions: [] };
+  // A renamed column used to degrade silently: every row then parsed as zero
+  // tokens, the run uploaded an empty snapshot, and sync.js pruned Cursor's
+  // incremental state as if the account had gone quiet — the dashboard just
+  // stopped counting Cursor. Treat a header we do not recognise as a skipped
+  // run instead: the state survives and the user gets a warning.
+  const hasTokenColumn =
+    inputCacheWriteIdx >= 0 || inputNoCacheIdx >= 0 || cacheReadIdx >= 0 || outputIdx >= 0;
+  if (dateIdx < 0 || modelIdx < 0 || !hasTokenColumn) {
+    return {
+      buckets: [],
+      sessions: [],
+      skipped: true,
+      warnings: [
+        'cursor: 导出表头与预期不符（需要 Date、Model 及至少一个 token 列），本次已跳过以保护增量状态；' +
+        'Cursor 可能更改了导出接口，请反馈。' +
+        `当前表头: ${header.slice(0, 8).join(', ')}`,
+      ],
+    };
+  }
 
   const entries = [];
   for (let r = 1; r < rows.length; r++) {

package/src/parsers/droid.js

@@ -1,9 +1,45 @@
 import { readdirSync, readFileSync, existsSync } from 'node:fs';
 import { join, basename, dirname } from 'node:path';
-import { homedir } from 'node:os';
+import { getDroidSessionsDir, getDroidSettingsPaths } from '../tools.js';
 import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import { readJsonSafe } from './fs-utils.js';
+
+// Factory session sidecars store the local slot id (`custom:gpt-6-astra-[gw]-0`),
+// not the API model. `customModels[].model` is what the provider actually sees.
+// A bare routing word would collide with Cursor's pricing entry (PR #83).
+const ROUTING_TIER_IDS = new Set([
+  'auto', 'default', 'default-model', 'fast', 'turbo', 'lite', 'ultimate', 'performance', 'efficient',
+]);
+const CUSTOM_SLOT_ID = /^custom:(.+)-\[([^\]]+)\]-(\d+)$/;
+
+export function loadDroidCustomModelCatalog() {
+  const catalog = new Map();
+  for (const settingsPath of getDroidSettingsPaths()) {
+    const data = readJsonSafe(settingsPath);
+    if (!data) continue;
+    for (const list of [data.customModels, data.custom_models]) {
+      if (!Array.isArray(list)) continue;
+      for (const entry of list) {
+        if (!entry || typeof entry !== 'object') continue;
+        const id = typeof entry.id === 'string' ? entry.id.trim() : '';
+        const model = typeof entry.model === 'string' ? entry.model.trim() : '';
+        if (id && model) catalog.set(id, model);
+      }
+    }
+  }
+  return catalog;
+}
 
-const DROID_SESSIONS_DIR = join(homedir(), '.factory', 'sessions');
+export function resolveDroidModel(raw, catalog = new Map()) {
+  const id = typeof raw === 'string' ? raw.trim() : '';
+  if (!id) return 'unknown';
+  const mapped = catalog instanceof Map ? catalog.get(id) : undefined;
+  const resolved = (typeof mapped === 'string' && mapped.trim())
+    ? mapped.trim()
+    : (id.match(CUSTOM_SLOT_ID)?.[1] || id);
+  const lower = resolved.toLowerCase();
+  return ROUTING_TIER_IDS.has(lower) ? `droid-${lower}` : resolved;
+}
 
 function findJsonlFiles(dir) {
   const results = [];
@@ -37,7 +73,8 @@ function toSafeNumber(value) {
 export async function parse() {
   const entries = [];
   const sessionEvents = [];
-  const sessionFiles = findJsonlFiles(DROID_SESSIONS_DIR);
+  const sessionFiles = findJsonlFiles(getDroidSessionsDir());
+  const catalog = loadDroidCustomModelCatalog();
 
   for (const filePath of sessionFiles) {
     const sessionId = basename(filePath, '.jsonl');
@@ -92,20 +129,28 @@ export async function parse() {
     const tokenUsage = settings?.tokenUsage;
     if (!tokenUsage) continue;
 
+    // Factory already stores uncached prompt in inputTokens. Its session log
+    // records `inputTokens` + `cacheReadInputTokens` = `totalInputTokens`;
+    // subtracting cacheReadTokens here zeros BYOK input whenever cache > input.
     const cacheReadTokens = toSafeNumber(tokenUsage.cacheReadTokens);
     const thinkingTokens = toSafeNumber(tokenUsage.thinkingTokens);
-    const inputTokens = Math.max(0, toSafeNumber(tokenUsage.inputTokens) - cacheReadTokens);
+    const cacheCreation5mTokens = toSafeNumber(tokenUsage.cacheCreationTokens);
+    const inputTokens = toSafeNumber(tokenUsage.inputTokens);
     const outputTokens = Math.max(0, toSafeNumber(tokenUsage.outputTokens) - thinkingTokens);
+    if (inputTokens + outputTokens + cacheReadTokens + thinkingTokens + cacheCreation5mTokens === 0) {
+      continue;
+    }
 
     entries.push({
       source: 'droid',
-      model: settings.model || 'unknown',
+      model: resolveDroidModel(settings.model, catalog),
       project,
       timestamp: firstMessageTimestamp,
       inputTokens,
       outputTokens,
       cachedInputTokens: cacheReadTokens,
       reasoningOutputTokens: thinkingTokens,
+      cacheCreation5mTokens,
     });
   }
 

package/src/parsers/grok.js

@@ -148,6 +148,62 @@ async function forEachJsonlLine(filePath, onLine, strict = false) {
   }
 }
 
+/**
+ * Grok 1.0 moved per-turn token accounting out of the ACP stream into a
+ * dedicated `<session>/usage.json` ledger — `grok usage <session-id>` is its
+ * documented reader, and the sessions guide says to use that "instead of
+ * reading session files". Older builds (0.2.x) wrote the same numbers into
+ * `updates.jsonl` `turn_completed.usage`; those sessions have no usage.json.
+ *
+ * The ledger holds token totals per turn but neither timestamps nor a model
+ * id, so callers pair its turns with the session's `turn_completed` events by
+ * order and fall back to the summary's model.
+ */
+function readUsageLedger(sessionPath, strict = false) {
+  const ledgerPath = join(sessionPath, 'usage.json');
+  if (!existsSync(ledgerPath)) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(ledgerPath, 'utf-8'));
+  } catch (err) {
+    if (strict) throw err;
+    return null;
+  }
+  if (!parsed || typeof parsed !== 'object') return null;
+  const turns = Array.isArray(parsed.turns) ? parsed.turns : [];
+  const session = parsed.session && typeof parsed.session === 'object' ? parsed.session : null;
+  if (turns.length === 0 && !session) return null;
+  return { session, turns };
+}
+
+/** Map one ledger record (turn or session totals) onto the usage shape the
+ *  ACP stream uses. Cache writes are folded into input — Grok publishes no
+ *  separate cache-write rate and pre-1.0 those tokens were part of
+ *  `inputTokens`, so folding keeps cross-version totals identical and leaves
+ *  the Anthropic-only cache-creation columns untouched. Any per-model
+ *  `modelUsage` map is carried through (and folded the same way) so the
+ *  caller's model attribution works exactly like the ACP path. */
+function ledgerRecordUsage(record) {
+  if (!record || typeof record !== 'object') return null;
+  const fold = (entry) => {
+    if (!entry || typeof entry !== 'object') return entry;
+    const input = Math.max(0, Number(entry.inputTokens) || 0);
+    const cacheCreation = Math.max(0, Number(entry.cacheCreationTokens) || 0);
+    return { ...entry, inputTokens: input + cacheCreation };
+  };
+  const folded = fold(record);
+  const modelUsage = record.modelUsage && typeof record.modelUsage === 'object'
+    ? Object.fromEntries(Object.entries(record.modelUsage).map(([model, entry]) => [model, fold(entry)]))
+    : null;
+  const usage = { ...folded, ...(modelUsage ? { modelUsage } : {}) };
+  const total =
+    Number(usage.inputTokens || 0) +
+    Number(usage.cachedReadTokens || 0) +
+    Number(usage.outputTokens || 0) +
+    Number(usage.reasoningTokens || 0);
+  return total > 0 ? usage : null;
+}
+
 function listSessionDirs(sessionsDir, strict = false) {
   const results = [];
   if (!existsSync(sessionsDir)) {
@@ -231,6 +287,7 @@ export async function parse({ extraRoots = [] } = {}) {
 
   const entries = [];
   const sessionEvents = [];
+  const unreadSessions = [];
 
   const candidates = [];
   for (const sessionsDir of roots) {
@@ -287,9 +344,14 @@ export async function parse({ extraRoots = [] } = {}) {
       const cwd = summary.info?.cwd || summary.git_root_dir || null;
       const project = cwd ? projectFromPath(cwd) : projectFallback;
       const fallbackModel = summary.current_model_id || 'unknown';
+      const sessionEntryStart = entries.length;
 
       // Prefer updates.jsonl turn_completed for exact usage + message timings.
+      // `turnTimestamps` keeps their order so a 1.x usage.json ledger (which
+      // has no timestamps of its own) can be paired turn-by-turn below.
       let sawUserOrAssistant = false;
+      let usageFromUpdates = 0;
+      const turnTimestamps = [];
       await forEachJsonlLine(join(sessionPath, 'updates.jsonl'), (obj) => {
         const update = obj?.params?.update;
         if (!update || typeof update !== 'object') return;
@@ -298,12 +360,15 @@ export async function parse({ extraRoots = [] } = {}) {
         const timestamp = toDate(obj.timestamp);
 
         if (kind === 'turn_completed' && timestamp) {
+          turnTimestamps.push(timestamp);
+          const before = entries.length;
           emitTurnUsage(entries, {
             usage: update.usage,
             project,
             timestamp,
             fallbackModel,
           });
+          if (entries.length > before) usageFromUpdates += 1;
         }
 
         if (!timestamp) return;
@@ -329,6 +394,37 @@ export async function parse({ extraRoots = [] } = {}) {
         }
       }, strict);
 
+      // 1.x sessions keep per-turn totals in usage.json instead of the ACP
+      // stream. Consulted only when updates.jsonl yielded no usage, so a
+      // session that carries both is never counted twice.
+      if (usageFromUpdates === 0) {
+        const ledger = readUsageLedger(sessionPath, strict);
+        const records = ledger?.turns?.length ? ledger.turns : (ledger?.session ? [ledger.session] : []);
+        if (records.length > 0) {
+          const sessionTimestamp = toDate(summary.updated_at || summary.last_active_at || summary.created_at);
+          for (const [index, record] of records.entries()) {
+            const usage = ledgerRecordUsage(record);
+            if (!usage) continue;
+            const timestamp = turnTimestamps[index] || sessionTimestamp;
+            if (!timestamp) continue;
+            emitTurnUsage(entries, { usage, project, timestamp, fallbackModel });
+          }
+        }
+      }
+
+      // Canary for the next on-disk format move: a session whose signals.json
+      // reports completed turns (and a model) but whose usage we could not read
+      // from either source is a silent collection gap, not an idle session —
+      // 1.0 moved the ledger to usage.json exactly like this.
+      if (entries.length === sessionEntryStart) {
+        const signals = readJsonSafe(join(sessionPath, 'signals.json'));
+        const turnCount = Number(signals?.turnCount) || 0;
+        const modelsUsed = Array.isArray(signals?.modelsUsed) ? signals.modelsUsed.filter(Boolean) : [];
+        if (turnCount > 0 && modelsUsed.length > 0) {
+          unreadSessions.push({ sessionId, turnCount });
+        }
+      }
+
       // Fallback timing from events.jsonl when updates lack message chunks
       // (short/aborted sessions, older builds).
       if (!sawUserOrAssistant) {
@@ -391,5 +487,11 @@ export async function parse({ extraRoots = [] } = {}) {
   return {
     buckets: aggregateToBuckets(entries),
     sessions: extractSessions(sessionEvents),
+    ...(unreadSessions.length > 0 && {
+      warnings: [
+        `grok: ${unreadSessions.length} 个会话有已完成轮次但未读到用量（例如 ${unreadSessions[0].sessionId}，${unreadSessions[0].turnCount} 轮），` +
+        '可能是 Grok 又更改了用量落盘格式，请反馈；本次未上传这些会话的用量。',
+      ],
+    }),
   };
 }

package/src/parsers/index.js

@@ -1,5 +1,6 @@
 import { parse as parseClaudeCode } from './claude-code.js';
 import { parse as parseCline } from './cline.js';
+import { parse as parseCodeartsAgent } from './codearts-agent.js';
 import { parse as parseCodex } from './codex.js';
 import { parse as parseCopilotCli } from './copilot-cli.js';
 import { parse as parseCraftAgent } from './craft-agent.js';
@@ -33,6 +34,7 @@ import { parse as parseCodebuddy } from './codebuddy.js';
 
 export const parsers = {
   'claude-code': parseClaudeCode,
+  'codearts-agent': parseCodeartsAgent,
   'codex': parseCodex,
   'cola': parseCola,
   'grok': parseGrok,

package/src/parsers/opencode.js

@@ -4,18 +4,57 @@ import { aggregateToBuckets, extractSessions } from './aggregate.js';
 import { queryDbJson, sqliteUnavailableError, isSqliteUnavailableError } from './sqlite.js';
 import { getOpenCodeStores } from '../opencode-roots.js';
 
-function readSqlite(path) {
-  // Select only accounting/timing metadata, never message text or tool inputs.
-  // Keep the existing top-level model/project precedence for old uploads.
-  const query = `SELECT id, session_id AS sessionID,
+// Select only accounting/timing metadata, never message text or tool inputs.
+// Keep the existing top-level model/project precedence for old uploads.
+const V1_QUERY = `SELECT id, session_id AS sessionID,
     json_extract(data, '$.role') AS role,
     json_extract(data, '$.time.created') AS created,
     coalesce(json_extract(data, '$.modelID'), json_extract(data, '$.model.modelID')) AS modelID,
     json_extract(data, '$.tokens') AS tokens,
     json_extract(data, '$.path.root') AS rootPath
     FROM message ORDER BY id`;
-  try { return queryDbJson(path, query); }
-  catch (err) {
+
+// OpenCode 2.x stores the same accounting in the event-sourced projection
+// `session_message`: the row's `type` is the role, `data.model.id` the model,
+// `data.tokens` the counters. Message data carries no `path`, so the project
+// comes from the session row's `directory`; the session table is `session_v2`
+// in 2.x and `session` before that (both names in the wild, issue #114). Only
+// column/JSON expressions are selected -- never message text, tool payloads,
+// or costs.
+function v2Query(sessionTable) {
+  return `SELECT m.id AS id, m.session_id AS sessionID,
+    m.type AS role,
+    coalesce(json_extract(m.data, '$.time.created'), m.time_created) AS created,
+    coalesce(json_extract(m.data, '$.model.id'), json_extract(m.data, '$.modelID')) AS modelID,
+    json_extract(m.data, '$.tokens') AS tokens,
+    s.directory AS directory
+    FROM session_message m
+    ${sessionTable ? `LEFT JOIN ${sessionTable} s ON s.id = m.session_id` : ''}
+    WHERE m.type IN ('user', 'assistant')
+    ORDER BY m.id`;
+}
+
+function readSqlite(path) {
+  try {
+    const tables = new Set(queryDbJson(path,
+      `SELECT name FROM sqlite_master WHERE type = 'table'
+       AND name IN ('message', 'session_message', 'session', 'session_v2')`)
+      .map(row => row.name));
+    if (!tables.has('message') && !tables.has('session_message')) {
+      throw new Error(`不认识的表结构（没有 message / session_message 表）: ${path}`);
+    }
+    // Read both shapes when a migrated store keeps both: copies are merged by
+    // (session, message id), and the legacy row is seen first so an equal copy
+    // never renames a project that earlier uploads already used.
+    const rows = [];
+    if (tables.has('message')) rows.push(...queryDbJson(path, V1_QUERY));
+    if (tables.has('session_message')) {
+      const sessionTable = tables.has('session_v2') ? 'session_v2'
+        : (tables.has('session') ? 'session' : null);
+      rows.push(...queryDbJson(path, v2Query(sessionTable)));
+    }
+    return rows;
+  } catch (err) {
     if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('OpenCode');
     throw err;
   }
@@ -71,14 +110,24 @@ export async function parse({ extraRoots = [] } = {}) {
   for (const row of records.values()) {
     // Keep the existing project derivation and token semantics. Additional roots
     // must not rename previously uploaded projects/models or alter their counts.
-    const project = row.rootPath ? basename(row.rootPath) : 'unknown';
+    // V2 message rows carry no `path`, so they fall back to the session
+    // directory; they come from a store the parser could not read before, so
+    // nothing previously uploaded is relabelled by that fallback.
+    const project = row.rootPath ? basename(row.rootPath)
+      : (row.directory ? basename(row.directory) : 'unknown');
     const base = { source: 'opencode', project, timestamp: row.timestamp };
     events.push({ ...base, sessionId: row.sessionId, role: row.role === 'user' ? 'user' : 'assistant' });
     const tokens = row.tokens;
     if (!row.modelID || !tokens || (!tokens.input && !tokens.output)) continue;
     entries.push({ ...base, model: row.modelID,
       inputTokens: tokens.input || 0, outputTokens: tokens.output || 0,
-      cachedInputTokens: tokens.cache?.read || 0, reasoningOutputTokens: tokens.reasoning || 0 });
+      cachedInputTokens: tokens.cache?.read || 0, reasoningOutputTokens: tokens.reasoning || 0,
+      // The store writes one cache-write total with no per-TTL breakdown and no
+      // separate `tokens.total` column to reconcile against, so it goes to the
+      // cheaper 5m cache-creation bucket -- the same rule as CodeArts Agent,
+      // which reads this exact layout. Dropping it (the behaviour until
+      // 2026-09-26) under-billed every Claude/Anthropic run through OpenCode.
+      cacheCreation5mTokens: tokens.cache?.write || 0 });
   }
   return { buckets: aggregateToBuckets(entries), sessions: extractSessions(events) };
 }

package/src/quotas/providers/kimi-code.js

@@ -2,6 +2,7 @@ import {
   accessSync,
   closeSync,
   constants as fsConstants,
+  existsSync,
   fsyncSync,
   mkdirSync,
   openSync,
@@ -134,9 +135,35 @@ export function parseKimiUsage(payload, now = new Date()) {
   });
 }
 
+// Kimi Code has two credential locations in the wild. kimi-cli (1.x) keeps
+// `$KIMI_SHARE_DIR/credentials/kimi-code.json`, defaulting to `~/.kimi`, while
+// the current CLI (2.x) writes `$KIMI_CODE_HOME/credentials/kimi-code.json`,
+// defaulting to `~/.kimi-code` -- the same home the session parser already
+// resolves. Reading only the legacy path reported `missing_credentials` for
+// every 2.x user whose login sits in the new home (issue #112), while their
+// usage parsed fine, so the quota card contradicted the token tables.
+export function kimiCredentialPaths(environment = process.env, home = homedir()) {
+  const directories = [
+    environment.KIMI_SHARE_DIR?.trim(),
+    environment.KIMI_CODE_HOME?.trim(),
+    join(home, '.kimi-code'),
+    join(home, '.kimi'),
+  ];
+  return directories.filter(Boolean).map(directory => join(directory, 'credentials', 'kimi-code.json'));
+}
+
+/**
+ * The credential file to read and, on refresh, to rotate atomically.
+ *
+ * A login that exists wins over one that does not, in the order above: an
+ * explicitly configured home outranks the CLI default, and the current CLI
+ * home outranks the legacy one. With no login anywhere the current CLI's path
+ * is returned so `missing_credentials` (and any rotation that follows a later
+ * login) names the file the installed CLI actually writes.
+ */
 export function kimiCredentialPath(environment = process.env, home = homedir()) {
-  const shareDirectory = environment.KIMI_SHARE_DIR?.trim() || join(home, '.kimi');
-  return join(shareDirectory, 'credentials', 'kimi-code.json');
+  const paths = kimiCredentialPaths(environment, home);
+  return paths.find(path => existsSync(path)) || paths[0];
 }
 
 function readCredentials(path) {

package/src/state.js

@@ -121,8 +121,13 @@ export function clearState() {
 }
 
 // Composite key must mirror the server dedup key so a project rename or
-// uploadProject toggle changes the key and naturally forces a re-send
-// (server cleanup pass then reconciles the stale-named rows).
+// uploadProject toggle changes the key and naturally forces a re-send under
+// the new name. Nothing retires the row uploaded under the OLD key: ingest
+// only upserts on (user_id, source, model, project, hostname, bucket_start),
+// and there is no server-side reconciliation pass. The stale row survives
+// until `vibe-usage reset` or a one-off server-side cleanup, so a rename
+// double-counts tokens on the dashboard in the meantime. Verified against the
+// server 2026-09-19; weigh this before changing what a parser reports.
 export function bucketKey(b) {
   return `${b.source}|${b.model}|${b.project}|${b.hostname}|${b.bucketStart}`;
 }

package/src/tools.js

@@ -12,6 +12,7 @@ import {
   grokSessionsDir,
 } from './extra-roots.js';
 import { findClineDataDirs } from './cline-roots.js';
+import { findCodeartsAgentDbs, resolveCodeartsAgentRoots } from './codearts-roots.js';
 import { findColaDataDirs, getColaSessionsDir } from './cola-roots.js';
 import { findCraftDataDirs } from './craft-roots.js';
 import { findHermesDataDirs, getHermesHome } from './hermes-roots.js';
@@ -145,6 +146,31 @@ export function getDshSessionsDir() {
   return join(getDshHome(), 'sessions');
 }
 
+export function getDroidSessionsDir() {
+  const testDir = process.env.VIBE_USAGE_DROID_SESSIONS?.trim();
+  if (testDir) return testDir;
+  return join(homedir(), '.factory', 'sessions');
+}
+
+// Factory settings hold customModels[].id → API model. Fixture sessions must
+// not read the real ~/.factory/settings.json (API keys, and it would leak
+// machine catalog into tests).
+export function getDroidSettingsPaths() {
+  const override = process.env.VIBE_USAGE_DROID_SETTINGS?.trim();
+  if (override) return [override];
+  if (process.env.VIBE_USAGE_DROID_SESSIONS?.trim()) return [];
+  const home = join(homedir(), '.factory');
+  return [
+    join(home, 'settings.json'),
+    join(home, 'settings.local.json'),
+    join(home, 'config.json'),
+  ];
+}
+
+export function findDroidDataDirs() {
+  return [getDroidSessionsDir()].filter(existsSync);
+}
+
 // Detect DeepSeek Harness when its sessions tree exists (or the test override).
 export function findDshDataDirs() {
   return [getDshSessionsDir()].filter(existsSync);
@@ -279,6 +305,12 @@ export const TOOLS = [
     dataDir: join(homedir(), '.claude', 'projects'),
     detectDataDirs: ({ extraRoots } = {}) => findClaudeCodeDataDirs(extraRootList(extraRoots?.['claude-code'])),
   },
+  {
+    name: 'CodeArts Agent',
+    id: 'codearts-agent',
+    dataDir: resolveCodeartsAgentRoots()[0],
+    detectDataDirs: () => findCodeartsAgentDbs(),
+  },
   {
     name: 'Codex CLI',
     id: 'codex',
@@ -402,6 +434,7 @@ export const TOOLS = [
     name: 'Droid',
     id: 'droid',
     dataDir: join(homedir(), '.factory', 'sessions'),
+    detectDataDirs: findDroidDataDirs,
   },
   {
     name: 'DeepSeek Harness',