@vibe-cafe/vibe-usage 0.11.1 → 0.12.0

package/README.md

@@ -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 |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-cafe/vibe-usage",
-  "version": "0.11.1",
+  "version": "0.12.0",
   "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/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/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',