@vibe-cafe/vibe-usage 0.11.0 → 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 |
@@ -249,6 +250,10 @@ For OpenCode, each root uses its SQLite database when present; only roots withou
 
 The first `npx @vibe-cafe/vibe-usage` run installs a user-level service (systemd on Linux, launchd on macOS, Task Scheduler on Windows — no admin rights needed) that syncs every 30 minutes and starts automatically on login. Nothing else to do.
 
+Switching the CLI to a different account (running `init` again, or `config set apiKey`) rebinds the upload state, so the next sync re-uploads your full local history to the new account instead of treating it as already sent.
+
+换绑账号后（重新 `init` 或 `config set apiKey`），下一次同步会自动全量重传本地历史，不会因为旧账号的同步记录而漏传。
+
 <details>
 <summary>Managing the service, and how it is launched</summary>
 

package/package.json

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

@@ -8,6 +8,8 @@ import { createHash, randomBytes } from 'node:crypto';
 // already uploaded successfully. Lets each sync skip re-sending unchanged
 // history: parsers stay stateless (still parse everything from disk every run),
 // but only new/changed items hit the network.
+// The file also records the upload target it belongs to (`identity`), so state
+// left by a previous account can never suppress that account's history.
 // VIBE_USAGE_STATE_DIR overrides the dir (test hook).
 const STATE_DIR = process.env.VIBE_USAGE_STATE_DIR?.trim() || join(homedir(), '.vibe-usage');
 const isDev = process.env.VIBE_USAGE_DEV === '1';
@@ -17,14 +19,57 @@ export function getStatePath() {
   return STATE_FILE;
 }
 
-export function loadState() {
+// The upload target this state belongs to: which server, and which account on
+// it. state.json only records what was already uploaded *to that target*, so
+// after a re-bind (`init` again, `config set apiKey`, or a desktop app
+// rewriting config.json) the old hashes must not make sync skip history the new
+// account has never received.
+//
+// The key is stored only as a fingerprint. The raw apiKey must never appear in
+// state.json — it is an ordinary-permission file next to the parser state, not
+// a credential store; config.json (mode 0600) remains the only place it lives.
+export function stateIdentity({ apiUrl, apiKey } = {}) {
+  return {
+    apiUrl: apiUrl || '',
+    keyFingerprint: apiKey
+      ? createHash('sha256').update(String(apiKey)).digest('hex').slice(0, 16)
+      : '',
+  };
+}
+
+function isIdentity(value) {
+  return !!value
+    && typeof value === 'object'
+    && typeof value.apiUrl === 'string'
+    && typeof value.keyFingerprint === 'string';
+}
+
+function sameIdentity(a, b) {
+  return a.apiUrl === b.apiUrl && a.keyFingerprint === b.keyFingerprint;
+}
+
+// `identity` is optional: callers that only read the recorded counts (e.g.
+// `status`) pass nothing and keep the pre-0.11.1 behaviour of taking the file
+// at face value.
+export function loadState(identity) {
   if (!existsSync(STATE_FILE)) return { buckets: {}, sessions: {} };
   try {
     const parsed = JSON.parse(readFileSync(STATE_FILE, 'utf-8'));
-    return {
-      buckets: parsed.buckets ?? {},
-      sessions: parsed.sessions ?? {},
-    };
+    const buckets = parsed.buckets ?? {};
+    const sessions = parsed.sessions ?? {};
+    if (!isIdentity(identity) || !isIdentity(parsed.identity)) {
+      // No identity recorded — written by a CLI older than 0.11.1. Adopt the
+      // entries as-is rather than forcing a re-upload: on upgrade day that
+      // would make every installed client re-send its whole history at once.
+      // The next saveState() stamps the current identity, so any later re-bind
+      // is caught.
+      return { buckets, sessions };
+    }
+    if (sameIdentity(parsed.identity, identity)) return { buckets, sessions };
+    // Bound to a different account or server: nothing recorded here was ever
+    // uploaded to the current target, so start empty and re-send local history.
+    // `identityChanged` is a runtime signal for the caller, never persisted.
+    return { buckets: {}, sessions: {}, identityChanged: true };
   } catch {
     // Corrupt/unreadable state must not lose data — treat as empty, which
     // triggers a one-time full re-upload (same as a fresh install).
@@ -32,14 +77,28 @@ export function loadState() {
   }
 }
 
-export function saveState(state) {
+export function saveState(state, identity) {
   mkdirSync(STATE_DIR, { recursive: true });
+  // Only the durable fields are written: `identityChanged` is loadState()'s
+  // one-run signal, not state. A CLI older than 0.11.1 reads just
+  // buckets/sessions, so the extra top-level `identity` key is ignored there —
+  // a file written by this version stays readable by older clients.
+  const payload = {
+    buckets: state.buckets ?? {},
+    sessions: state.sessions ?? {},
+  };
+  if (isIdentity(identity)) {
+    payload.identity = {
+      apiUrl: identity.apiUrl,
+      keyFingerprint: identity.keyFingerprint,
+    };
+  }
   // Atomic replace: write to a unique temp file then rename over the target.
   // A crash mid-write can no longer truncate state.json into an unreadable
   // file that loadState() would treat as empty (triggering a full re-upload).
   const tempPath = `${STATE_FILE}.${process.pid}.${randomBytes(6).toString('hex')}.tmp`;
   try {
-    writeFileSync(tempPath, JSON.stringify(state) + '\n', 'utf-8');
+    writeFileSync(tempPath, JSON.stringify(payload) + '\n', 'utf-8');
     renameSync(tempPath, STATE_FILE);
   } finally {
     // No-op after a successful rename (the temp file is already gone); cleans
@@ -62,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/sync.js

@@ -1,7 +1,7 @@
 import { hostname as osHostname } from 'node:os';
 import { loadConfig, saveConfig } from './config.js';
 import {
-  loadState, saveState, pruneState,
+  loadState, saveState, pruneState, stateIdentity,
   bucketKey, bucketHash, sessionKey, sessionHash,
 } from './state.js';
 import { ingest, fetchSettings } from './api.js';
@@ -119,6 +119,13 @@ export async function runSync({
   // Resolve it before parsing or loading upload state so failure is a true
   // no-op: no data upload and no state mutation.
   const apiUrl = config.apiUrl || 'https://vibecafe.ai';
+  // state.json records what was already uploaded to *this* account on *this*
+  // server. Passing the identity into loadState() makes state left by a
+  // previous account fall away, so a re-bind re-uploads the local history
+  // instead of diffing it against uploads the new account never received.
+  // Built from the same `apiUrl` the ingest calls below use, so the recorded
+  // target and the actual target can never drift apart.
+  const identity = stateIdentity({ apiUrl, apiKey: config.apiKey });
   let uploadProject;
   try {
     const settings = await fetchSettings(apiUrl, config.apiKey);
@@ -223,11 +230,14 @@ export async function runSync({
     // Successful parsers emitted no live items. Prune their old keys even on
     // this fast path; otherwise deleting the final local log would leave dead
     // state entries forever. Failed-parser sources remain protected.
-    const state = loadState();
+    const state = loadState(identity);
+    if (state.identityChanged && !quiet) {
+      console.log(dim('检测到上传账号已更换，本次全量重传本地历史'));
+    }
     const before = Object.keys(state.buckets).length + Object.keys(state.sessions).length;
     pruneState(state, new Set(), new Set(), okSources);
     const pruned = before - (Object.keys(state.buckets).length + Object.keys(state.sessions).length);
-    if (pruned > 0) saveState(state);
+    if (pruned > 0) saveState(state, identity);
     if (!quiet && parserProgress.length > 0) {
       for (const p of parserProgress) {
         console.log(dim(`  ${p.source}: 正在建立本地索引 ${p.completed}/${p.total}（下次同步继续）`));
@@ -283,7 +293,10 @@ export async function runSync({
   // an active one sends just the current 30-min bucket.
   // Missing/corrupt state.json => empty maps => one-time full upload, then
   // incremental forever after.
-  const state = loadState();
+  const state = loadState(identity);
+  if (state.identityChanged && !quiet) {
+    console.log(dim('检测到上传账号已更换，本次全量重传本地历史'));
+  }
   const changedBuckets = [];
   const changedSessions = [];
   const liveBucketKeys = new Set();
@@ -321,7 +334,7 @@ export async function runSync({
   const before = Object.keys(state.buckets).length + Object.keys(state.sessions).length;
   pruneState(state, liveBucketKeys, liveSessionKeys, okSources);
   const pruned = before - (Object.keys(state.buckets).length + Object.keys(state.sessions).length);
-  if (pruned > 0) saveState(state);
+  if (pruned > 0) saveState(state, identity);
 
   if (changedBuckets.length === 0 && changedSessions.length === 0) {
     if (!quiet) console.log(dim('无新增数据。'));
@@ -422,7 +435,7 @@ export async function runSync({
           batchStateChanged = true;
         }
       }
-      if (batchStateChanged) saveState(state);
+      if (batchStateChanged) saveState(state, identity);
     }
 
     if (totalBatches > 1 || allBucketsToSend.length > 0) {

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',