@vibe-cafe/vibe-usage 0.10.31 → 0.10.32

package/README.md

@@ -50,7 +50,7 @@ npx @vibe-cafe/vibe-usage reset        # Delete all data and re-upload from loca
 npx @vibe-cafe/vibe-usage reset --local  # Delete this host's data only and re-upload (`--host` remains a legacy alias)
 npx @vibe-cafe/vibe-usage skill         # Install skill for AI coding assistants
 npx @vibe-cafe/vibe-usage skill --remove  # Remove installed skills
-npx @vibe-cafe/vibe-usage status       # Show config & detected tools
+npx @vibe-cafe/vibe-usage status       # Config, detected tools, and what each tool has uploaded so far
 npx @vibe-cafe/vibe-usage help --all   # Full help (plain `help` shows the short version)
 ```
 
@@ -76,7 +76,7 @@ npx @vibe-cafe/vibe-usage help --all   # Full help (plain `help` shows the short
 | 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 |
 | Qwen Code | `~/.qwen/tmp/` |
-| Kimi Code | Current `~/.kimi-code/sessions/wd_<slug>_<hash>/session_<id>/agents/<agent>/wire.jsonl` (`usage.record` deltas, including retry/compaction scope and cache creation; main/subagent wires form one session), data root resolved via `$KIMI_CODE_HOME` like the CLI itself, with project names from `session_index.jsonl`; legacy `~/.kimi/sessions/` is parsed alongside (`kimi migrate` never carries usage over, so both stores are always merged) |
+| Kimi Code | Current `<home>/sessions/wd_<slug>_<hash>/session_<id>/agents/<agent>/wire.jsonl` (`usage.record` deltas, including retry/compaction scope and cache creation; main/subagent wires form one session), with project names from `session_index.jsonl`. Every home with that layout is scanned: the CLI home (`$KIMI_CODE_HOME`, else `~/.kimi-code`) plus the Kimi Work desktop app's embedded runtime home (`<Electron userData>/kimi-desktop/daimon-share/daimon/runtime/kimi-code/home`), which the app never writes into the CLI home; legacy `~/.kimi/sessions/` is parsed alongside (`kimi migrate` never carries usage over, so both stores are always merged) |
 | MiniMax Code (mcode) | `$MCODE_HOME/v2/sqlite/runtime-state.sqlite` (default `~/.minimax/v2/sqlite/runtime-state.sqlite`; fixture override: `VIBE_USAGE_MCODE_DB`). Reads only allow-listed token ledger fields and session workspace/project paths, uses basename-only projects, folds cache writes into input, keeps cache reads and reasoning separate, and never selects raw/message JSON payloads. WAL/lock reads use a disposable snapshot; malformed or incompatible databases are skipped to preserve incremental state. |
 | MiMoCode | `$MIMOCODE_HOME/data/mimocode.db`, `$XDG_DATA_HOME/mimocode/mimocode.db`, or `~/.local/share/mimocode/mimocode.db` (SQLite; exact input, output, reasoning, and cache-read tokens from assistant messages; honors `MIMOCODE_DB`; cache-write tokens are included in input usage) |
 | Amp | `~/.local/share/amp/threads/`; cache-creation tokens are included in input usage |
@@ -84,12 +84,12 @@ npx @vibe-cafe/vibe-usage help --all   # Full help (plain `help` shows the short
 | DeepSeek Harness | `$DSH_HOME/sessions/` (default `~/.dsh`, fixture/relocation override: `VIBE_USAGE_DSH_SESSIONS`). Reads V0–V3 logs, including `session.v3.jsonl.zstd` from DSH `0.1.5-alpha.2`, with multi-frame Zstandard support (Node ≥ 22.15 built-in, `zstd` CLI fallback) and plain JSONL support. Each session uses its highest `session[.vN].jsonl[.zstd]` generation once, so frozen pre-migration logs are not double-counted. Usage comes from `assistant/message`: cache writes join uncached input, cache reads remain separate, and reasoning is split out of inclusive output. Fork history uses V0/V1 `seedLength` or V2/V3's last `session/end-seed` tagged `inherited: true`, and is skipped only when the parent copy confirms it; missing parents retain the sole local history. Unknown versions warn and protect sync state. |
 | Hermes (CLI / Desktop) | `<home>/state.db` + `<home>/profiles/<name>/state.db` (SQLite, multi-profile). Home: `$HERMES_HOME`, otherwise `~/.hermes` on macOS/Linux or `%LOCALAPPDATA%\hermes` on Windows (falls back to an existing `~/.hermes` only when the Windows native root is absent). Cache writes join input; reasoning is separated from inclusive output. Usage is currently a cumulative session total attributed to session start: a session spanning several days does **not** yet provide an accurate daily breakdown. |
 | Kiro | Kiro CLI native event streams `~/.kiro/sessions/cli/*.jsonl` (estimated tokens from message text: input = prompt + tool results, output = reply + tool calls, reasoning = thinking, cacheRead = re-sent context; thinking-block signatures excluded). Falls back to `~/Library/Application Support/kiro-cli/data.sqlite3` / `~/.local/share/kiro-cli/data.sqlite3` + optional `~/.kiro_sessions/*.json` archives, then IDE `q-client.log` whole-credit deltas as `kiro-credits` (floored cumulative diff — the server stores token counts as bigint); legacy IDE `dev_data/devdata.sqlite` token telemetry is opt-in with `VIBE_USAGE_KIRO_LEGACY_TOKENS=1` |
-| Cline | Current CLI/SDK `~/.cline/data/sessions/*/*.messages.json` plus legacy `~/.cline/{,data/}state/taskHistory.json` and editor extension stores. Honors `CLINE_DIR`, `CLINE_DATA_DIR`, and `CLINE_SESSION_DATA_DIR`; copied history is deduplicated |
+| Cline (CLI / SDK / Desktop app) | All variants write the same `~/.cline/data/sessions/*/*.messages.json` per-call metrics (the desktop app's manifest says `source: "desktop"`; its Electron userData holds only WebView caches), plus legacy `~/.cline/{,data/}state/taskHistory.json` and editor extension stores. Honors `CLINE_DIR`, `CLINE_DATA_DIR`, and `CLINE_SESSION_DATA_DIR`; copied history is deduplicated |
 | Roo Code | `<host>/User/globalStorage/rooveterinaryinc.roo-cline/{tasks/_index.json,tasks/<id>/{history_item,ui_messages}.json}` (walks all VSCode-fork hosts) |
 | Trae CLI | macOS: `~/Library/Caches/trae-cli/sessions/`; Windows: `%LOCALAPPDATA%/trae-cli/cache/sessions/`; Linux: `~/.cache/trae-cli/sessions/` (CLI telemetry only; Trae IDE/Trae Work chats are not supported). Token usage is summed per unique LLM call (`model.stream.eino`, plus `model.generate` failovers); nested duplicate spans that share a session `traceID` are not max-merged. `traces.jsonl` / `events.jsonl` are streamed line-by-line so a multi-hundred-MB events file cannot hit Node's string-length limit. |
 | Antigravity | Scans App 2.0 `~/.gemini/antigravity/conversations/`, `agy` CLI `~/.gemini/antigravity-cli/conversations/`, and standalone IDE `~/.gemini/antigravity-ide/conversations/`. `.db` stores, including the same paths below explicitly added alternate Homes, are parsed offline (tokens, model, project, sessions). When Gemini blobs omit `chatStartMetadata.createdAt` or `modelDisplayName`, timestamps fall back to `steps.metadata` and model names to `responseModel`. `.pb` history in the default stores requires the corresponding App/IDE language server to be running; when several servers are open, the parser tries the others for unreadable conversations. Unavailable legacy history produces a warning and preserves prior sync state. |
 | WorkBuddy | Current releases: `~/.workbuddy-ai/projects/**/*.jsonl`; legacy releases: `~/.workbuddy/projects/**/*.jsonl` (fixture/relocation override: `VIBE_USAGE_WORKBUDDY_DIRS`). Reads usage-bearing completed assistant and `function_call` records, using the routed model identifier exposed as `providerData.requestModelId`. Splits cache reads and reasoning from inclusive input/output totals, deduplicates copied record IDs, and extracts local session timing without uploading message content. |
-| ZCode | `~/.zcode/cli/db/db.sqlite` (SQLite; reads the `message` table for per-message tokens, model, and project `cwd`/`root`, joined to `session.directory`) |
+| ZCode | `~/.zcode/cli/db/db.sqlite` (SQLite; reads the `message` table for per-message tokens, model, and project `cwd`/`root`, joined to `session.directory`; fixture/relocation override: `VIBE_USAGE_ZCODE_DB`) |
 | Qoder | International edition (qoder.com). IDE store `~/Library/Application Support/Qoder/SharedClientCache/cache/db/local.db` (Windows `%APPDATA%\Qoder`, Linux `~/.config/Qoder`; honors `QODER_HOME`, fixture override `VIBE_USAGE_QODER_DB`) gives real tokens from `chat_message.token_info` (prompt includes cached; split out) with `model_key` usually a routing tier, reported as `qoder-auto` / `qoder-ultimate` / … so it never collides with a priced model id; message content is never selected, and lock/schema failures fall back to a snapshot or `skipped`. CLI + desktop app transcripts `~/.qoder/projects/**/*.jsonl` (honors `QODER_CONFIG_DIR`, fixture override `VIBE_USAGE_QODER_PROJECTS`; sub-agents under `<session>/subagents/`) are credit-billed with every token field at 0, so they contribute sessions only — credits are account funding and are not collected |
 | Qoder CN | China edition (qoder.com.cn, separate account). Same two shapes under `~/Library/Application Support/QoderCN/SharedClientCache/cache/db/local.db` (`QODER_CN_HOME` / `VIBE_USAGE_QODER_CN_DB`) and `~/.qoder-cn/projects/` (`QODERCN_CONFIG_DIR` / `VIBE_USAGE_QODER_CN_PROJECTS`); reported as source `qoder-cn` |
 

package/package.json

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

package/src/index.js

@@ -9,6 +9,7 @@ import {
   validateExtraRoot,
 } from './extra-roots.js';
 import { dim as dimText, failure, hint, smallHeader, warn } from './output.js';
+import { loadState } from './state.js';
 import { fetchAccount } from './api.js';
 
 function printSmallHeader() {
@@ -17,6 +18,25 @@ function printSmallHeader() {
   console.log();
 }
 
+/**
+ * Per-source counts of everything `state.json` records as uploaded. Keys are
+ * `${source}|…` (see state.js), so the source is the first segment.
+ */
+function uploadedItemCounts(state) {
+  const countBySource = keys => {
+    const counts = new Map();
+    for (const key of keys) {
+      const source = key.split('|')[0];
+      counts.set(source, (counts.get(source) || 0) + 1);
+    }
+    return counts;
+  };
+  return {
+    buckets: countBySource(Object.keys(state.buckets || {})),
+    sessions: countBySource(Object.keys(state.sessions || {})),
+  };
+}
+
 async function showStatus() {
   const config = loadConfig();
   console.log('\nvibe-usage status\n');
@@ -49,8 +69,21 @@ async function showStatus() {
   if (detected.length === 0) {
     console.log('    (none)\n');
   } else {
+    // "installed" alone cannot separate "syncing fine" from "never uploaded":
+    // a tool whose data dir exists but whose buckets never reached the server
+    // reads exactly like a healthy one, which is how a stale bundled CLI stayed
+    // invisible (issue #100). state.json is the only local record of what was
+    // actually uploaded, so count it per source.
+    const uploaded = uploadedItemCounts(loadState());
     for (const tool of detected) {
-      console.log(`    ${tool.name}`);
+      const buckets = uploaded.buckets.get(tool.id) || 0;
+      const sessions = uploaded.sessions.get(tool.id) || 0;
+      if (buckets || sessions) {
+        console.log(`    ${tool.name}  ·  已上传 ${buckets} buckets / ${sessions} sessions`);
+      } else {
+        console.log(`    ${tool.name}  ·  尚未上传过数据`);
+        console.log(dimText('       本机检测到数据，但本地没有这条工具的上传记录：运行 `npx @vibe-cafe/vibe-usage` 同步'));
+      }
     }
     console.log();
   }

package/src/kimi-roots.js

@@ -0,0 +1,63 @@
+import { existsSync, realpathSync } from 'node:fs';
+import { join, posix, win32 } from 'node:path';
+import { homedir } from 'node:os';
+
+// Root discovery for Kimi Code. The CLI keeps one data home, and the Kimi Work
+// desktop app runs an embedded Kimi Code runtime whose home has the CLI's exact
+// layout (issue #85), so both homes are scanned additively.
+
+// Kimi Work's embedded runtime home, relative to the app's Electron userData.
+const DAIMON_RUNTIME = ['daimon-share', 'daimon', 'runtime', 'kimi-code', 'home'];
+
+/** Kimi Work's embedded Kimi Code home for this platform. */
+export function kimiWorkCodeHome(env = process.env, platform = process.platform, home = homedir()) {
+  const pathImpl = platform === 'win32' ? win32 : posix;
+  const userData = platform === 'darwin'
+    ? pathImpl.join(home, 'Library', 'Application Support')
+    : platform === 'win32'
+      ? (env.APPDATA?.trim() || pathImpl.join(home, 'AppData', 'Roaming'))
+      : (env.XDG_CONFIG_HOME?.trim() || pathImpl.join(home, '.config'));
+  return pathImpl.join(userData, 'kimi-desktop', ...DAIMON_RUNTIME);
+}
+
+// Two roots can name the same directory (symlinks, a relocated home that still
+// resolves to the same store); scanning both would double-count every record.
+function uniquePaths(paths) {
+  const seen = new Set();
+  const result = [];
+  for (const path of paths) {
+    let key = path;
+    try { key = realpathSync(path); } catch { /* not created yet — compare as given */ }
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(path);
+  }
+  return result;
+}
+
+/**
+ * Kimi Code data homes to scan, primary first.
+ *
+ * `VIBE_USAGE_KIMI_CODE_DIR` (test/relocation hook) replaces discovery entirely,
+ * so a fixture never picks up the machine's real stores. Otherwise the CLI home
+ * — `$KIMI_CODE_HOME` when set, exactly like the CLI itself — is scanned
+ * alongside the Kimi Work desktop home; the desktop app never writes into the
+ * CLI home, so the two stores are independent.
+ */
+export function resolveKimiCodeRoots(env = process.env, platform = process.platform, home = homedir()) {
+  const override = env.VIBE_USAGE_KIMI_CODE_DIR?.trim();
+  if (override) return [override];
+  const pathImpl = platform === 'win32' ? win32 : posix;
+  return uniquePaths([
+    env.KIMI_CODE_HOME?.trim() || pathImpl.join(home, '.kimi-code'),
+    kimiWorkCodeHome(env, platform, home),
+  ]);
+}
+
+/** Existing Kimi Code session stores, for tool detection (`status`). */
+export function findKimiCodeDataDirs() {
+  return uniquePaths([
+    ...resolveKimiCodeRoots().map(root => join(root, 'sessions')),
+    join(homedir(), '.kimi', 'sessions'), // legacy store, always parsed alongside
+  ]).filter(existsSync);
+}

package/src/parsers/cline-sdk.js

@@ -5,12 +5,30 @@ import { projectFromCwd, toCount } from './fs-utils.js';
 // Verified with the shipped cline 3.0.61 / @cline/core 0.0.82. SQLite is only
 // the session index: per-call accounting lives in version-1 messages artifacts.
 // Read canonical artifacts, not DB prompt/metadata columns or provider settings.
-export function readClineSdk(sessionDirs, onWarning) {
+//
+// Two failure sizes, because they mean different things (see AGENTS.md):
+// a *format* mismatch means the store moved on and any number we produce would
+// be wrong, so the caller must skip the source and keep its previous upload
+// state; an *IO* failure on one artifact (the desktop app rewrites these files
+// in place, so half-written JSON is normal) drops only that artifact, while the
+// rest of the store still syncs. Transient losses re-upload on the next sync.
+function unsupported(message) {
+  const error = new Error(message);
+  error.clineUnsupported = true;
+  return error;
+}
+
+export function readClineSdk(sessionDirs, { onWarning = () => {}, onFatal = () => {} } = {}) {
   const copies = [];
   for (const dir of sessionDirs) {
     let children;
     try { children = readdirSync(dir, { withFileTypes: true }); }
-    catch (err) { onWarning(`cline: 无法读取会话目录 ${dir}: ${err.message}`); continue; }
+    catch (err) {
+      // Cannot enumerate this root: the snapshot may be missing sessions we
+      // could not even list, so the whole source is unsafe this run.
+      onFatal(`cline: 无法读取会话目录 ${dir}: ${err.message}`);
+      continue;
+    }
     for (const child of children) {
       if (!child.isDirectory()) continue;
       const sessionDir = join(dir, child.name);
@@ -21,10 +39,11 @@ export function readClineSdk(sessionDirs, onWarning) {
         if (!files.length) continue;
         manifest = JSON.parse(readFileSync(join(sessionDir, `${child.name}.json`), 'utf8'));
         if (manifest?.version !== 1 || manifest.session_id !== child.name) {
-          throw new Error('unsupported or inconsistent Cline session manifest');
+          throw unsupported('unsupported or inconsistent Cline session manifest');
         }
       } catch (err) {
-        onWarning(`cline: 无法读取会话目录 ${sessionDir}: ${err.message}`);
+        if (err?.clineUnsupported) onFatal(`cline: 不支持或不一致的会话清单 ${sessionDir}: ${err.message}`);
+        else onWarning(`cline: 跳过无法读取的会话目录 ${sessionDir}: ${err.message}`);
         continue;
       }
       for (const file of files) {
@@ -34,7 +53,7 @@ export function readClineSdk(sessionDirs, onWarning) {
           if (payload?.version !== 1 || !Array.isArray(payload.messages)
             || typeof payload.sessionId !== 'string'
             || (payload.sessionId !== child.name && payload.origin?.parentThreadId !== child.name)) {
-            throw new Error('unsupported or inconsistent Cline session artifact');
+            throw unsupported('unsupported or inconsistent Cline session artifact');
           }
           const project = projectFromCwd(manifest.workspace_root || manifest.cwd);
           // Reduce immediately to accounting/timing metadata. No prompt, response,
@@ -68,7 +87,8 @@ export function readClineSdk(sessionDirs, onWarning) {
             // shared history to the earliest original session deterministically.
             started: Date.parse(manifest.started_at) || 0, messagesPath });
         } catch (err) {
-          onWarning(`cline: 无法读取会话 ${messagesPath}: ${err.message}`);
+          if (err?.clineUnsupported) onFatal(`cline: 不支持或不一致的会话文件 ${messagesPath}: ${err.message}`);
+          else onWarning(`cline: 跳过无法读取的会话文件 ${messagesPath}: ${err.message}`);
         }
       }
     }

package/src/parsers/cline.js

@@ -7,8 +7,13 @@ import { readClineSdk } from './cline-sdk.js';
 
 export async function parse() {
   const warnings = [];
+  // Format drift or an unreadable root means we cannot describe the store:
+  // skip the source so its previous upload state survives. A single unreadable
+  // artifact only drops that artifact (it re-uploads on the next sync).
+  let fatal = false;
   const onWarning = message => warnings.push(message);
-  const { legacyRoots: extDirs, sdkSessionDirs } = findClineStores({ onWarning });
+  const onFatal = message => { fatal = true; warnings.push(message); };
+  const { legacyRoots: extDirs, sdkSessionDirs } = findClineStores({ onWarning: onFatal });
 
   const entries = [];
   const events = [];
@@ -90,8 +95,9 @@ export async function parse() {
       }
   }
 
-  const sdk = readClineSdk(sdkSessionDirs, onWarning);
-  if (warnings.length) return { buckets: [], sessions: [], skipped: true, warnings };
+  const sdk = readClineSdk(sdkSessionDirs, { onWarning, onFatal });
+  if (fatal) return { buckets: [], sessions: [], skipped: true, warnings };
   return { buckets: aggregateToBuckets([...entries, ...sdk.entries]),
-    sessions: extractSessions([...events, ...sdk.events]) };
+    sessions: extractSessions([...events, ...sdk.events]),
+    warnings };
 }

package/src/parsers/kimi-code.js

@@ -1,8 +1,9 @@
-import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import { readdirSync, readFileSync, existsSync, realpathSync } from 'node:fs';
 import { join, basename } from 'node:path';
 import { homedir } from 'node:os';
 import { createHash } from 'node:crypto';
 import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import { resolveKimiCodeRoots } from '../kimi-roots.js';
 
 /**
  * Kimi Code CLI parser. MoonshotAI/kimi-cli (a.k.a. "Kimi Code").
@@ -19,8 +20,13 @@ import { aggregateToBuckets, extractSessions } from './aggregate.js';
  *    sum to the session total. The model name rides on each record — no config
  *    lookup needed. User turns are `turn.prompt` with origin.kind === "user".
  *    The real working directory per session is recorded in
- *      ~/.kimi-code/session_index.jsonl  -> {sessionId, sessionDir, workDir}
+ *      <home>/session_index.jsonl  -> {sessionId, sessionDir, workDir}
  *    which gives an accurate project name (last path component of workDir).
+ *    Several homes share this layout and are all scanned (see kimi-roots.js):
+ *    the CLI home ($KIMI_CODE_HOME, else ~/.kimi-code) and the Kimi Work
+ *    desktop app's embedded runtime home. The desktop app never writes into the
+ *    CLI home, so the stores are independent and merging them cannot
+ *    double-count.
  *
  * 2. Legacy ("~/.kimi", protocol 1.1 / 1.9). Sessions live at
  *      ~/.kimi/sessions/<md5(workdir)>/<session-id>/wire.jsonl
@@ -39,15 +45,12 @@ import { aggregateToBuckets, extractSessions } from './aggregate.js';
 // Current format: ~/.kimi-code
 // ---------------------------------------------------------------------------
 
-// VIBE_USAGE_KIMI_CODE_DIR overrides the root (test hook). Otherwise resolve
-// the data root the same way the CLI itself does: $KIMI_CODE_HOME, then
-// ~/.kimi-code. Ignoring KIMI_CODE_HOME means users with a custom home get
-// zero usage parsed.
-const KIMI_CODE_DIR = process.env.VIBE_USAGE_KIMI_CODE_DIR?.trim()
-  || process.env.KIMI_CODE_HOME?.trim()
-  || join(homedir(), '.kimi-code');
-const KIMI_CODE_SESSIONS_DIR = join(KIMI_CODE_DIR, 'sessions');
-const KIMI_CODE_SESSION_INDEX = join(KIMI_CODE_DIR, 'session_index.jsonl');
+// VIBE_USAGE_KIMI_CODE_DIR overrides the root (test hook). Otherwise every root
+// from kimi-roots.js is scanned — the CLI home resolved the same way the CLI
+// itself resolves it ($KIMI_CODE_HOME, then ~/.kimi-code) plus the Kimi Work
+// desktop app's embedded runtime home (issue #85), which uses this exact
+// layout. Ignoring KIMI_CODE_HOME means users with a custom home get zero usage
+// parsed; ignoring the desktop home means Kimi Work users get zero usage parsed.
 
 function projectNameFromPath(path) {
   if (typeof path !== 'string' || !path) return null;
@@ -55,17 +58,17 @@ function projectNameFromPath(path) {
 }
 
 /**
- * Map each session directory (absolute path) to a project name, read from
- * ~/.kimi-code/session_index.jsonl. Falls back gracefully if the file is
- * missing or malformed — callers default to the wd_ bucket name.
+ * Map each session directory (absolute path) to a project name, read from the
+ * home's session_index.jsonl. Falls back gracefully if the file is missing or
+ * malformed — callers default to the wd_ bucket name.
  */
-function loadSessionIndex() {
+function loadSessionIndex(indexPath) {
   const map = new Map();
-  if (!existsSync(KIMI_CODE_SESSION_INDEX)) return map;
+  if (!existsSync(indexPath)) return map;
 
   let content;
   try {
-    content = readFileSync(KIMI_CODE_SESSION_INDEX, 'utf-8');
+    content = readFileSync(indexPath, 'utf-8');
   } catch {
     return map;
   }
@@ -141,15 +144,35 @@ function findKimiCodeWireFiles(baseDir) {
   return results;
 }
 
+/**
+ * Every wire file to parse, with its project name, across all Kimi Code homes.
+ * Two roots can resolve to the same store (symlink, relocated home), so the
+ * same physical wire file is returned once.
+ */
+function findKimiCodeWireFilesInAllRoots() {
+  const results = [];
+  const seen = new Set();
+  for (const root of resolveKimiCodeRoots()) {
+    const sessionIndex = loadSessionIndex(join(root, 'session_index.jsonl'));
+    for (const { wireFile, sessionDir, bucketProject } of findKimiCodeWireFiles(join(root, 'sessions'))) {
+      let identity = wireFile;
+      try { identity = realpathSync(wireFile); } catch { /* keep the literal path */ }
+      if (seen.has(identity)) continue;
+      seen.add(identity);
+      results.push({ wireFile, sessionDir, project: sessionIndex.get(sessionDir) || bucketProject || 'unknown' });
+    }
+  }
+  return results;
+}
+
 function parseKimiCode() {
-  const wireFiles = findKimiCodeWireFiles(KIMI_CODE_SESSIONS_DIR);
+  const wireFiles = findKimiCodeWireFilesInAllRoots();
   if (wireFiles.length === 0) return null;
 
-  const sessionIndex = loadSessionIndex();
   const entries = [];
   const sessionEvents = [];
 
-  for (const { wireFile, sessionDir, bucketProject } of wireFiles) {
+  for (const { wireFile, sessionDir, project } of wireFiles) {
     let content;
     try {
       content = readFileSync(wireFile, 'utf-8');
@@ -157,8 +180,6 @@ function parseKimiCode() {
       continue;
     }
 
-    const project = sessionIndex.get(sessionDir) || bucketProject || 'unknown';
-
     for (const line of content.split('\n')) {
       if (!line.trim()) continue;
       let evt;

package/src/parsers/zcode.js

@@ -1,8 +1,8 @@
 import { existsSync } from 'node:fs';
-import { join, basename } from 'node:path';
-import { homedir } from 'node:os';
+import { basename } from 'node:path';
 import { aggregateToBuckets, extractSessions } from './aggregate.js';
 import { queryDbJson, sqliteUnavailableError, isSqliteUnavailableError } from './sqlite.js';
+import { getZcodeDbPath } from '../tools.js';
 
 // ZCode (z.ai / Zhipu's coding agent) stores everything in a SQLite database
 // at ~/.zcode/cli/db/db.sqlite. The `message` table is the canonical source:
@@ -11,7 +11,9 @@ import { queryDbJson, sqliteUnavailableError, isSqliteUnavailableError } from '.
 // than the parallel `model_usage` ledger because `message` gives us BOTH session
 // timing (user + assistant rows) and token usage in one pass, with the project
 // path attached to each message.
-const DB_PATH = join(homedir(), '.zcode', 'cli', 'db', 'db.sqlite');
+export function resolveZcodeDbPath(env = process.env) {
+  return getZcodeDbPath(env);
+}
 
 /**
  * Project name from a ZCode message's path. ZCode records both `cwd` and `root`;
@@ -26,15 +28,20 @@ function projectName(root, cwd, sessionDir) {
 }
 
 export async function parse() {
-  if (!existsSync(DB_PATH)) return { buckets: [], sessions: [] };
+  const dbPath = resolveZcodeDbPath();
+  if (!existsSync(dbPath)) return { buckets: [], sessions: [] };
 
   // Join each message to its session so we can fall back to the session's
   // directory when an individual message has no path (older rows, lite agents).
+  // ZCode renamed the assistant message's model keys from `modelID` /
+  // `providerID` to `modelId` / `providerId`; read both spellings so neither
+  // build reports every bucket as `unknown`.
   const query = `SELECT
     m.session_id AS sessionId,
     m.time_created AS created,
     json_extract(m.data, '$.role') AS role,
     json_extract(m.data, '$.modelID') AS modelID,
+    json_extract(m.data, '$.modelId') AS modelId,
     json_extract(m.data, '$.tokens') AS tokens,
     json_extract(m.data, '$.path.root') AS pathRoot,
     json_extract(m.data, '$.path.cwd') AS pathCwd,
@@ -44,7 +51,7 @@ export async function parse() {
 
   let rows;
   try {
-    rows = queryDbJson(DB_PATH, query);
+    rows = queryDbJson(dbPath, query);
   } catch (err) {
     if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('ZCode');
     throw err;
@@ -88,7 +95,7 @@ export async function parse() {
 
     entries.push({
       source: 'zcode',
-      model: row.modelID || 'unknown',
+      model: row.modelID || row.modelId || 'unknown',
       project,
       timestamp,
       inputTokens: (tokens.input || 0) - cachedInput,

package/src/tools.js

@@ -15,6 +15,7 @@ import { findClineDataDirs } from './cline-roots.js';
 import { findColaDataDirs, getColaSessionsDir } from './cola-roots.js';
 import { findCraftDataDirs } from './craft-roots.js';
 import { findHermesDataDirs, getHermesHome } from './hermes-roots.js';
+import { findKimiCodeDataDirs } from './kimi-roots.js';
 import { findOmpDataDirs, findPiDataDirs } from './pi-roots.js';
 import { findQoderDataDirs, getQoderProjectsDir } from './qoder-roots.js';
 import { findWorkbuddyDataDirs } from './workbuddy-roots.js';
@@ -124,13 +125,8 @@ export function findCodexDataDirs(codexExtraHome, extraRoots = []) {
 }
 
 // Kimi Code moved its store from ~/.kimi to ~/.kimi-code; recognize either so
-// users on either version are detected. The parser prefers ~/.kimi-code.
-function findKimiCodeDataDirs() {
-  return [
-    join(homedir(), '.kimi-code', 'sessions'),
-    join(homedir(), '.kimi', 'sessions'),
-  ].filter(existsSync);
-}
+// users on either version are detected. Kimi Work's embedded runtime home is
+// recognized too — see kimi-roots.js, which the parser uses as well.
 
 /** DeepSeek Harness home: DSH_HOME env (same as the dsh CLI) or ~/.dsh. */
 export function getDshHome(env = process.env) {
@@ -176,6 +172,12 @@ export function getMimocodeDbPath(env = process.env) {
   return isAbsolute(env.MIMOCODE_DB) ? env.MIMOCODE_DB : join(dataDir, env.MIMOCODE_DB);
 }
 
+export function getZcodeDbPath(env = process.env, home = homedir()) {
+  const override = env.VIBE_USAGE_ZCODE_DB?.trim();
+  if (override) return isAbsolute(override) ? override : resolve(override);
+  return join(home, '.zcode', 'cli', 'db', 'db.sqlite');
+}
+
 export function findAntigravityDataDirs(extraRoots = []) {
   return [...new Set([
     ...antigravityConversationDirs(homedir()).map(dirname),
@@ -437,7 +439,7 @@ export const TOOLS = [
   {
     name: 'ZCode',
     id: 'zcode',
-    dataDir: join(homedir(), '.zcode', 'cli', 'db', 'db.sqlite'),
+    dataDir: getZcodeDbPath(),
   },
 ];