@vibe-cafe/vibe-usage 0.10.30 → 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)
 ```
 
@@ -63,7 +63,7 @@ npx @vibe-cafe/vibe-usage help --all   # Full help (plain `help` shows the short
 | 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. |
-| 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, while fork/sub-agent replay matching, duplicate suppression, and live/archive/cross-root deduplication retain their existing semantics |
+| 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 |
 | GitHub Copilot CLI | `~/.copilot/session-state/*/events.jsonl` |
@@ -71,12 +71,12 @@ npx @vibe-cafe/vibe-usage help --all   # Full help (plain `help` shows the short
 | Cursor | `state.vscdb` (SQLite, reads `cursorAuth/accessToken`, fetches CSV from `cursor.com`); cloud data is stamped with a fixed `cursor-cloud` hostname so multi-machine setups don't double-count |
 | DimAgent | `$DIMCODE_HOME/dimcode.sqlite` (default `~/.dimcode/v2/dimcode.sqlite`); exact usage from `usage_ledger`, with forked ledger/history copies deduplicated |
 | Gemini CLI | `~/.gemini/tmp/<project_hash>/chats/session-*.jsonl` (current line-delimited format) and legacy `session-*.json`; recurses into nested subagent sessions |
-| OpenCode | `~/.local/share/opencode/opencode.db` (SQLite, `json_extract` query) |
+| OpenCode | `~/.local/share/opencode/opencode.db` (SQLite), with `storage/message/` as the legacy alternative; supports explicitly added data roots |
 | OpenClaw | `~/.openclaw/agents/`, `~/.openclaw-<profile>/agents/` (profile deployments); cache-creation/cache-write tokens are included in input usage |
 | Oh My Pi | `~/.omp/agent/sessions/`, `~/.omp/profiles/*/agent/sessions/`, and `$XDG_DATA_HOME/omp/{sessions,profiles/*/sessions}`; recognizes OMP's `$PI_CODING_AGENT_DIR`, current v3 title slots and path/hashed session directories, deduplicates copied records, includes cache writes in input, and splits reasoning from OMP's inclusive output count |
 | pi | `~/.pi/agent/sessions/` or `$PI_CODING_AGENT_DIR/sessions/`, plus the session directory Pi itself was pointed at via `PI_CODING_AGENT_SESSION_DIR` or `sessionDir` in `~/.pi/agent/settings.json`, plus explicitly added `pi-coding-agent` roots for stores only reachable through `pi --session <file>` (fixture/relocation override: `VIBE_USAGE_PI_SESSION_DIRS`). Cache writes are included in input usage; reasoning is read from Pi's `usage.reasoning` (legacy `usage.reasoningTokens` still accepted) and split out of the inclusive output total |
 | 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` |
 
@@ -100,7 +100,7 @@ npx @vibe-cafe/vibe-usage help --all   # Full help (plain `help` shows the short
 - Extracts session metadata where the source safely exposes user/assistant timing: active time (AI generation time, excluding queue/TTFT wait), total duration, and message counts. Alma intentionally emits buckets only; Cindy's daily-ledger augmentation adds no timing data to the native Codex/pi sessions because doing so would require reading Cindy chat records.
 - Uploads buckets + sessions to your vibecafe.ai dashboard (always gzip-compressed, ~94% smaller)
 - Incremental upload: every parser emits a complete local snapshot, then only buckets/sessions that are new or changed since the last successful upload are sent — a quiet machine uploads nothing. Upload state remains in `~/.vibe-usage/state.json`; failed or still-indexing parsers retain their prior state, while deleted local logs are pruned. Deleting the state file triggers a one-time full re-upload, and `reset` clears it automatically after deleting cloud data
-- Incremental Codex parsing: a versioned, disposable cache under `~/.vibe-usage/cache/codex/` stores per-rollout aggregate results and parser continuation state. Unchanged rollouts require no raw-log reads; an ordinary append reads only the new tail; forks, sub-agents, replacements, truncations, and failed safety checks fall back to the full correctness path. A bounded rolling audit occasionally re-reads one historical file. Very large first-time indexes checkpoint before the Mac app timeout and resume on the next sync instead of restarting
+- Incremental Codex parsing: a versioned, disposable cache under `~/.vibe-usage/cache/codex/` stores per-rollout aggregate results and parser continuation state. Unchanged rollouts require no raw-log reads; an ordinary append reads only the new tail; forks, sub-agents, replacements, truncations, and failed safety checks fall back to the full correctness path. Multi-file sessions have a combined cache that rebuilds when any segment changes. A bounded rolling audit occasionally re-reads one historical file or continuation group. Very large first-time indexes checkpoint before the Mac app timeout and resume on the next sync instead of restarting
 - The Codex parser cache contains derived aggregates and replay metadata, not raw prompt or response text. It is independent of upload state and can be deleted safely (the next sync rebuilds it). `reset` intentionally keeps it so the required full re-upload does not also require a full disk rescan. Set `VIBE_USAGE_CODEX_CACHE=0` to disable the optimization for diagnosis
 - SQLite-backed tools are read via Node's built-in `node:sqlite` on Node ≥ 22.5 — no `sqlite3` binary needed (works on Windows out of the box); on older Node the CLI falls back to the system `sqlite3` executable
 - Continuous syncing is on by default: the first run installs a background service (see [Background sync](#background-sync)); the [Vibe Usage Mac app](https://github.com/vibe-cafe/vibe-usage-app) is the menu-bar alternative
@@ -203,6 +203,13 @@ Add isolated runtime data without editing JSON by hand:
 # <workspace>/<task>/codex-home directories are at most three levels below it.
 npx @vibe-cafe/vibe-usage config add-root codex /path/to/multica-container
 
+# Claude Code expects a .claude root containing projects/ or transcripts/.
+# Use the source id claude-code (not claude).
+npx @vibe-cafe/vibe-usage config add-root claude-code /mnt/c/Users/you/.claude
+
+# OpenCode accepts a data root containing opencode.db or storage/message/.
+npx @vibe-cafe/vibe-usage config add-root opencode /path/to/other/opencode
+
 # Grok expects a Grok Home containing sessions/.
 npx @vibe-cafe/vibe-usage config add-root grok /path/to/grok-home
 
@@ -221,6 +228,8 @@ npx @vibe-cafe/vibe-usage config remove-root grok /path/to/grok-home
 
 Default roots are always scanned and existing `codexExtraHome` configurations remain valid. Additional roots are only scanned after they are explicitly added. If a configured root later becomes unavailable, that tool is skipped for the current sync so its incremental upload state is not pruned.
 
+For OpenCode, each root uses its SQLite database when present; only roots without a database use legacy JSON. Copied records across roots are counted once using session/message ids, keeping the most complete copy. A broken database is reported and preserves sync state instead of silently substituting potentially stale JSON. Existing model names take precedence; nested model fields are only a fallback when the old field is absent. Claude Code retains its existing session and request deduplication rules.
+
 ## Background sync
 
 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.

package/package.json

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

package/src/claude-roots.js

@@ -2,6 +2,8 @@ import { existsSync, readdirSync, realpathSync, statSync } from 'node:fs';
 import { delimiter, join } from 'node:path';
 import { homedir } from 'node:os';
 
+import { validateExtraRoot } from './extra-roots.js';
+
 const MAX_DESKTOP_DISCOVERY_DEPTH = 8;
 const DESKTOP_NON_SESSION_DIRS = new Set(['rpm', 'skills']);
 
@@ -106,7 +108,7 @@ export function findClaudeDesktopRoots(
  * VIBE_USAGE_CLAUDE_DIRS is a test/diagnostic override. It replaces all normal
  * and Desktop discovery with a path.delimiter-separated root list.
  */
-export function getClaudeRoots({ onWarning = () => {} } = {}) {
+export function getClaudeRoots({ onWarning = () => {}, extraRoots = [] } = {}) {
   const override = process.env.VIBE_USAGE_CLAUDE_DIRS?.trim();
   const roots = override
     ? override.split(delimiter).map(expandHome).filter(Boolean)
@@ -133,6 +135,13 @@ export function getClaudeRoots({ onWarning = () => {} } = {}) {
     }
   }
 
+  // Append explicit extra roots (e.g. another OS's .claude directory).
+  for (const root of extraRoots) {
+    const result = validateExtraRoot('claude-code', root);
+    if (!result.ok) onWarning(`Claude Code: 额外目录不可用 ${root}: ${result.reason}`);
+    if (!roots.includes(result.path)) roots.push(result.path);
+  }
+
   const seen = new Set();
   const unique = [];
   for (const root of roots) {
@@ -149,9 +158,9 @@ export function getClaudeRoots({ onWarning = () => {} } = {}) {
   return unique;
 }
 
-export function findClaudeCodeDataDirs() {
+export function findClaudeCodeDataDirs(extraRoots = []) {
   const dirs = [];
-  for (const root of getClaudeRoots()) {
+  for (const root of getClaudeRoots({ extraRoots })) {
     for (const name of ['projects', 'transcripts']) {
       const candidate = join(root, name);
       try {

package/src/extra-roots.js

@@ -1,9 +1,10 @@
 import { accessSync, closeSync, constants, openSync, readSync, readdirSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, join, resolve } from 'node:path';
+import { openCodeStore } from './opencode-roots.js';
 import { codexSessionDirs } from './codex-roots.js';
 
-export const EXTRA_ROOT_SOURCES = ['antigravity', 'codex', 'grok', 'pi-coding-agent'];
+export const EXTRA_ROOT_SOURCES = ['antigravity', 'claude-code', 'codex', 'grok', 'opencode', 'pi-coding-agent'];
 
 // Probing a candidate Pi store has three outcomes, never two: a confirmed
 // session, a directory proven to hold none, and one that could not be read.
@@ -278,6 +279,11 @@ function probePiSessions(dir, depth = 2) {
   return unreadable ? PI_SESSIONS_UNREADABLE : PI_SESSIONS_ABSENT;
 }
 
+export function claudeProjectsDir(value) {
+  const root = normalizeExtraRoot(value);
+  return [join(root, 'projects'), join(root, 'transcripts')].filter(isReadableDirectory);
+}
+
 export function validateExtraRoot(source, value) {
   if (!EXTRA_ROOT_SOURCES.includes(source)) {
     return { ok: false, path: value, reason: `不支持的工具: ${source}` };
@@ -291,6 +297,22 @@ export function validateExtraRoot(source, value) {
       reason: '需要是 Codex Home，或包含 */*/codex-home 的 Multica 容器',
     };
   }
+  if (source === 'claude-code') {
+    const dirs = claudeProjectsDir(path);
+    return {
+      ok: dirs.length > 0,
+      path,
+      reason: '需要包含 projects/ 或 transcripts/',
+    };
+  }
+  if (source === 'opencode') {
+    try {
+      return { ok: openCodeStore(path) !== null, path,
+        reason: '需要包含可读的 opencode.db 或 storage/message/' };
+    } catch (err) {
+      return { ok: false, path, reason: `无法读取 OpenCode 目录: ${err.message}` };
+    }
+  }
   if (source === 'pi-coding-agent') {
     // piSessionsDir only returns a directory it has already confirmed by
     // content, so there is nothing left to re-check here.

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();
   }
@@ -269,7 +302,7 @@ const FULL_HELP = `
     ${BARE} config get <key>   Get a config value
     ${BARE} config set <key> <value>  Set a config value
     ${BARE} config set codexExtraHome <path>  Persist another Codex Home
-    ${BARE} config add-root <tool> <path>  Add a Codex, Grok, Antigravity, or Pi data root
+    ${BARE} config add-root <tool> <path>  Add a Claude Code, Codex, Grok, OpenCode, Antigravity, or Pi data root
     ${BARE} config remove-root <tool> <path>  Remove an added data root
     ${BARE} config roots  Show added data roots as JSON
     ${BARE} help         Show the short help

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/opencode-roots.js

@@ -0,0 +1,46 @@
+import { accessSync, constants, realpathSync, statSync } from 'node:fs';
+import { delimiter, join } from 'node:path';
+import { homedir } from 'node:os';
+
+function readable(path, directory) {
+  try {
+    const stat = statSync(path);
+    if (directory ? !stat.isDirectory() : !stat.isFile()) throw new Error(`格式不正确: ${path}`);
+    accessSync(path, constants.R_OK);
+    return true;
+  } catch (err) {
+    if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return false;
+    throw err;
+  }
+}
+
+// SQLite wins within each store; JSON is the legacy alternative, not a second
+// copy of the same migrated history. A failed SQLite read must protect state.
+export function openCodeStore(root) {
+  const db = join(root, 'opencode.db');
+  if (readable(db, false)) return { kind: 'sqlite', path: db };
+  const messages = join(root, 'storage', 'message');
+  if (readable(messages, true)) return { kind: 'json', path: messages };
+  return null;
+}
+
+export function getOpenCodeStores({ extraRoots = [], onWarning = () => {} } = {}) {
+  const override = process.env.VIBE_USAGE_OPENCODE_DIRS?.trim();
+  const defaults = override ? override.split(delimiter).map(p => p.trim()).filter(Boolean)
+    : [join(homedir(), '.local', 'share', 'opencode')];
+  const seen = new Set(), stores = [];
+  for (const root of [...defaults, ...extraRoots]) {
+    try {
+      const store = openCodeStore(root);
+      if (!store) {
+        if (extraRoots.includes(root)) onWarning(`OpenCode: 额外目录缺少 opencode.db 或 storage/message/: ${root}`);
+        continue;
+      }
+      const canonical = realpathSync(store.path);
+      if (seen.has(canonical)) continue;
+      seen.add(canonical);
+      stores.push({ ...store, path: canonical });
+    } catch (err) { onWarning(`OpenCode: 无法读取数据目录 ${root}: ${err.message}`); }
+  }
+  return stores;
+}

package/src/parsers/claude-code.js

@@ -331,7 +331,7 @@ function* iterateUsageEntries(ctx) {
   for (const entry of ctx.entriesByKey.values()) yield entry;
 }
 
-export async function parse() {
+export async function parse({ extraRoots = [] } = {}) {
   const ctx = {
     entriesByKey: new Map(),
     anonymousEntries: [],
@@ -341,6 +341,7 @@ export async function parse() {
   };
   const roots = getClaudeRoots({
     onWarning: (message) => addWarning(ctx, message),
+    extraRoots,
   });
   const projectGroups = collectCandidates(roots, 'projects', ctx);
   const projectSessionIds = new Set();

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/codex-cache.js

@@ -14,7 +14,7 @@ import { join } from 'node:path';
 // separate from ~/.vibe-usage/state.json, whose hashes are the authoritative
 // record of successful uploads and must remain backward-compatible.
 export const CODEX_CACHE_SCHEMA_VERSION = 1;
-export const CODEX_PARSER_ALGORITHM_VERSION = 3;
+export const CODEX_PARSER_ALGORITHM_VERSION = 4;
 
 function hash(value, length = 24) {
   return createHash('sha256').update(value).digest('hex').slice(0, length);

package/src/parsers/codex-segments.js

@@ -0,0 +1,108 @@
+import { createHash } from 'node:crypto';
+
+const hash = value => createHash('sha256').update(JSON.stringify(value)).digest('base64url');
+function pick(value, keys) {
+  if (!value || typeof value !== 'object') return value;
+  return Object.fromEntries(keys.filter(key => Object.hasOwn(value, key)).map(key => [key, value[key]]));
+}
+const usageKeys = ['input_tokens', 'output_tokens', 'cached_input_tokens', 'cache_read_input_tokens', 'reasoning_output_tokens', 'total_tokens'];
+
+// Retain only fields consumed by the existing token/timing parser. Full JSON is
+// hashed transiently to identify exact copies; chat/tool text is never retained.
+function accountingRecord(obj, context) {
+  const next = { type: obj.type, timestamp: obj.timestamp };
+  const p = obj.payload;
+  if (obj.type === 'session_meta' && p) {
+    next.payload = pick(p, ['id', 'timestamp', 'cwd', 'forked_from_id', 'parent_thread_id', 'thread_source']);
+    if (p.git) next.payload.git = pick(p.git, ['repository_url']);
+    if (typeof p.source === 'string') next.payload.source = p.source;
+    else if (p.source && typeof p.source === 'object' && 'subagent' in p.source) {
+      next.payload.source = { subagent: { thread_spawn: pick(p.source.subagent?.thread_spawn, ['parent_thread_id']) } };
+    }
+  } else if (obj.type === 'turn_context') {
+    next.payload = pick(p, ['model', 'service_tier']);
+  } else if (obj.type === 'event_msg' && p) {
+    next.payload = pick(p, ['type', 'started_at', 'model']);
+    if (p.type === 'token_count') {
+      next._tokenFingerprint = hash(p).slice(0, 16);
+      next._segmentContext = { ...context };
+      if (p.info) next.payload.info = {
+        ...pick(p.info, ['model']),
+        total_token_usage: pick(p.info.total_token_usage, usageKeys),
+        last_token_usage: pick(p.info.last_token_usage, usageKeys),
+      };
+    } else if (p.type === 'thread_settings_applied') {
+      next.payload.thread_settings = pick(p.thread_settings, ['model', 'service_tier']);
+    }
+  }
+  return JSON.stringify(next);
+}
+
+/**
+ * Merge exact cross-file copies with multiplicity: occurrence N of a record in
+ * one file matches occurrence N in another. Repetitions within a file survive.
+ * Preserve each file's order (including rewritten-timestamp fork replay); use
+ * timestamps only to order independent segments. Contradictory order fails the
+ * source instead of inventing a potentially double-counting sequence.
+ */
+export async function mergeCodexSegments(members, readLines) {
+  const nodes = new Map();
+  let canonicalKey = null;
+  for (const [fileIndex, file] of members.entries()) {
+    const occurrences = new Map();
+    let previous = null;
+    const context = {};
+    for await (const line of readLines(file.filePath, file.snapshotSize)) {
+      let obj;
+      try { obj = JSON.parse(line); } catch { continue; }
+      if (!obj || typeof obj !== 'object') continue;
+      const settings = obj.type === 'turn_context' ? obj.payload
+        : obj.type === 'event_msg' && obj.payload?.type === 'thread_settings_applied' ? obj.payload.thread_settings : null;
+      if (settings?.model) context.model = settings.model;
+      if (Object.hasOwn(settings || {}, 'service_tier')) context.serviceTier = settings.service_tier;
+      const fingerprint = hash(obj);
+      const occurrence = (occurrences.get(fingerprint) || 0) + 1;
+      occurrences.set(fingerprint, occurrence);
+      const key = `${fingerprint}:${occurrence}`;
+      if (fileIndex === 0 && canonicalKey === null && obj.type === 'session_meta') canonicalKey = key;
+      if (!nodes.has(key)) nodes.set(key, {
+        key, line: accountingRecord(obj, context), time: Date.parse(obj.timestamp),
+        ordinal: nodes.size, successors: new Set(), incoming: 0,
+      });
+      if (previous && previous !== key && !nodes.get(previous).successors.has(key)) {
+        nodes.get(previous).successors.add(key);
+        nodes.get(key).incoming++;
+      }
+      previous = key;
+    }
+  }
+  const ready = [...nodes.values()].filter(node => !node.incoming);
+  const result = [];
+  function compare(a, b) {
+    if (a.key === canonicalKey || b.key === canonicalKey) return a.key === canonicalKey ? -1 : 1;
+    if (Number.isFinite(a.time) && Number.isFinite(b.time) && a.time !== b.time) return a.time - b.time;
+    return a.ordinal - b.ordinal;
+  }
+  while (ready.length) {
+    ready.sort(compare);
+    const node = ready.shift();
+    result.push(node.line);
+    for (const key of node.successors) {
+      const next = nodes.get(key);
+      if (--next.incoming === 0) ready.push(next);
+    }
+  }
+  if (result.length !== nodes.size) throw new Error('Codex continuation copies have conflicting record order');
+  return result;
+}
+
+// The disposable group cache is invalidated by ANY member changing, appearing,
+// disappearing, or moving. It never shares the selected physical file's cache.
+export function codexSegmentSignature(members) {
+  return {
+    size: members.reduce((sum, file) => sum + file.snapshotSize, 0),
+    mtimeMs: Math.max(...members.map(file => file.signature.mtimeMs)),
+    dev: 'codex-segments',
+    ino: hash(members.map(file => [file.filePath, file.signature]).sort((a, b) => a[0].localeCompare(b[0]))),
+  };
+}

package/src/parsers/codex.js

@@ -10,6 +10,7 @@ import {
 import { join } from 'node:path';
 import { createInterface } from 'node:readline';
 import { createHash } from 'node:crypto';
+import { mergeCodexSegments, codexSegmentSignature } from './codex-segments.js';
 import { aggregateToBuckets } from './aggregate.js';
 import { mergeCindyHarnessUsage, readCindyHarnessUsage } from './cindy-ledger.js';
 import {
@@ -314,7 +315,7 @@ const OWN_TASK_START_WINDOW_MS = 5_000;
  * full prefix. Together they bound matching to source records that existed at
  * spawn without over-skipping child work when the parent later grows.
  */
-async function indexSessionFile(filePath, snapshotSize) {
+async function indexSessionFile(filePath, snapshotSize, lines = null) {
   let sessionId = null;
   let forkedFromId = null;
   let parentThreadId = null;
@@ -332,7 +333,7 @@ async function indexSessionFile(filePath, snapshotSize) {
   let firstTaskBoundary = null;
   let ownTaskBoundary = null;
 
-  for await (const line of readLines(filePath, snapshotSize)) {
+  for await (const line of (lines ?? readLines(filePath, snapshotSize))) {
     if (!line.trim()) continue;
     try {
       const obj = JSON.parse(line);
@@ -361,7 +362,7 @@ async function indexSessionFile(filePath, snapshotSize) {
         }
       } else if (obj.type === 'event_msg' && obj.payload?.type === 'token_count') {
         rawTokenCount++;
-        tokenFingerprints.push(tokenFingerprint(obj.payload));
+        tokenFingerprints.push(lines ? obj._tokenFingerprint : tokenFingerprint(obj.payload));
         if (recordTimestamp == null) {
           tokenTimes.push(Number.POSITIVE_INFINITY);
           pendingTokenTimeIndexes.push(tokenTimes.length - 1);
@@ -612,6 +613,7 @@ function mergeBucketLists(lists) {
 async function parseSessionFile(filePath, snapshotSize, fm, boundary, {
   previousTail = null,
   captureTail = false,
+  lines = null,
 } = {}) {
   const entries = [];
   const sessionEvents = [];
@@ -632,7 +634,7 @@ async function parseSessionFile(filePath, snapshotSize, fm, boundary, {
   let prevTotal = previousTail?.prevTotal || null;
   let prevCumulativeTotal = previousTail?.prevCumulativeTotal ?? null;
   const start = previousTail?.parsedBytes || 0;
-  for await (const line of readLines(filePath, snapshotSize, start)) {
+  for await (const line of (lines ?? readLines(filePath, snapshotSize, start))) {
     if (!line.trim()) continue;
     try {
       const obj = JSON.parse(line);
@@ -750,8 +752,11 @@ async function parseSessionFile(filePath, snapshotSize, fm, boundary, {
       const timestamp = obj.timestamp ? new Date(obj.timestamp) : null;
       if (!timestamp || isNaN(timestamp.getTime())) continue;
 
-      const rawModel = info.model || payload.model || turnContextModel || 'unknown';
-      const model = decorateCodexModel(rawModel, serviceTier, timestamp.getTime());
+      const segmentContext = lines ? obj._segmentContext : null;
+      const rawModel = info.model || payload.model || segmentContext?.model || turnContextModel || 'unknown';
+      const effectiveTier = Object.hasOwn(segmentContext || {}, 'serviceTier')
+        ? normalizeCodexServiceTier(segmentContext.serviceTier) : serviceTier;
+      const model = decorateCodexModel(rawModel, effectiveTier, timestamp.getTime());
 
         // OpenAI API: input_tokens INCLUDES cached, output_tokens INCLUDES reasoning.
         // Normalize to Anthropic-style semantics where each field is non-overlapping.
@@ -967,13 +972,12 @@ async function parseNativeCodex({ codexExtraHome, extraRoots = [] } = {}) {
         cacheStats.filesRead++;
         updateFileCache(file, { header: file.header });
       } catch {
-        if (file.strict) {
-          return {
-            buckets: [], sessions: [], skipped: true,
-            warnings: [`codex: 额外根目录读取失败，已保留上次同步数据: ${file.codexHome}`],
-          };
-        }
-        continue;
+        // An unreadable header may hide another segment of a known session.
+        // Never upload the remaining readable segment as its complete total.
+        return {
+          buckets: [], sessions: [], skipped: true,
+          warnings: ['codex: 会话文件读取失败，已保留上次同步数据'],
+        };
       }
     }
     if (file.header.sessionId) {
@@ -1045,8 +1049,55 @@ async function parseNativeCodex({ codexExtraHome, extraRoots = [] } = {}) {
     }
   }
 
-  // Select the most complete physical copy exactly as before. Unique ordinary
-  // sessions have no full record count, but cannot compete with another copy.
+  // Duplicate ids can be disjoint continuation segments, not just archives.
+  // Keep physical caches intact and give each combined session its own cache.
+  const groupedFiles = [];
+  let groupAudited = false;
+  for (const id of duplicateIds) {
+    const members = candidatesById.get(id);
+    if (members.some(file => !fileMeta.has(file.filePath))) {
+      return { buckets: [], sessions: [], skipped: true,
+        warnings: ['codex: 同一会话的部分文件读取失败，已保留上次同步数据'] };
+    }
+    members.sort((a, b) => (fileMeta.get(b.filePath).parsedRecordCount || 0)
+      - (fileMeta.get(a.filePath).parsedRecordCount || 0) || a.filePath.localeCompare(b.filePath));
+    const selected = members[0];
+    const filePath = `${selected.codexHome}/.vibe-usage-session-${createHash('sha256').update(id).digest('hex')}`;
+    const signature = codexSegmentSignature(members);
+    let cache = members.some(file => auditPaths.has(file.filePath)) ? null
+      : loadCodexFileCache(selected.codexHome, filePath, signature);
+    if (cache?.result && !groupAudited && auditPaths.size === 0
+      && signature.size <= auditMaxBytes()
+      && (cache.lastAuditedAt || 0) <= Date.now() - auditIntervalMs()) {
+      cache = null;
+      groupAudited = true;
+      cacheStats.audited++;
+    }
+    const group = { ...selected, filePath, signature, snapshotSize: signature.size,
+      cache, members, lines: null, appendTail: null, priorTail: null };
+    try {
+      let meta = cache?.index;
+      if (!meta) {
+        group.lines = await mergeCodexSegments(members, readLines);
+        cacheStats.filesRead += members.length;
+        meta = await indexSessionFile(filePath, null, group.lines);
+        updateFileCache(group, { header: group.header, index: meta });
+      } else cacheStats.indexHits++;
+      fileMeta.set(filePath, meta);
+      needsIndex.add(filePath);
+      for (const member of members) fileMeta.delete(member.filePath);
+      groupedFiles.push(group);
+    } catch (err) {
+      return { buckets: [], sessions: [], skipped: true,
+        warnings: [`codex: 无法合并会话分段，已保留上次同步数据: ${err.message}`] };
+    }
+    if (overBudget()) return { buckets: [], sessions: [], skipped: true,
+      indexing: { phase: 'segments', completed: groupedFiles.length, total: duplicateIds.size }, cache: cacheStats };
+  }
+  files.push(...groupedFiles);
+
+  // One index per logical session, including all continuation segments, feeds
+  // the unchanged fork/subagent replay boundary logic.
   const sessionById = new Map();
   for (const file of files) {
     const meta = fileMeta.get(file.filePath);
@@ -1077,11 +1128,16 @@ async function parseNativeCodex({ codexExtraHome, extraRoots = [] } = {}) {
       const previousTail = !needsIndex.has(file.filePath) && !auditPaths.has(file.filePath)
         ? file.appendTail
         : null;
+      if (file.members && !file.lines) {
+        file.lines = await mergeCodexSegments(file.members, readLines);
+        cacheStats.filesRead += file.members.length;
+      }
       const parsed = await parseSessionFile(file.filePath, file.snapshotSize, fm, boundary, {
         previousTail,
         captureTail: !needsIndex.has(file.filePath),
+        lines: file.lines,
       });
-      cacheStats.filesRead++;
+      if (!file.members) cacheStats.filesRead++;
       if (previousTail) cacheStats.tailHits++;
       const { tail, ...summary } = parsed;
       if (tail) {
@@ -1098,6 +1154,7 @@ async function parseNativeCodex({ codexExtraHome, extraRoots = [] } = {}) {
       file.priorTail = null;
       if (auditPaths.has(file.filePath)) cacheStats.audited++;
     }
+    file.lines = null; // Never retain the transient combined transcript after parsing.
     results.push(result);
 
     if (overBudget() && i < files.length - 1) {

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/opencode.js

@@ -1,151 +1,84 @@
-import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import { readdirSync, readFileSync } from 'node:fs';
 import { join, basename } from 'node:path';
-import { homedir } from 'node:os';
 import { aggregateToBuckets, extractSessions } from './aggregate.js';
 import { queryDbJson, sqliteUnavailableError, isSqliteUnavailableError } from './sqlite.js';
-
-const DATA_DIR = join(homedir(), '.local', 'share', 'opencode');
-const DB_PATH = join(DATA_DIR, 'opencode.db');
-const MESSAGES_DIR = join(DATA_DIR, 'storage', 'message');
-
-/**
- * Parse opencode usage data.
- * Tries SQLite database first (opencode >= v0.2), falls back to legacy JSON files.
- */
-export async function parse() {
-  if (existsSync(DB_PATH)) {
-    try {
-      return parseFromSqlite();
-    } catch (err) {
-      process.stderr.write(`warn: opencode sqlite parse failed (${err.message}), trying legacy json...\n`);
-    }
-  }
-  return parseFromJson();
-}
-
-function parseFromSqlite() {
-  const query = `SELECT
-    session_id as sessionID,
-    json_extract(data, '$.role') as role,
-    json_extract(data, '$.time.created') as created,
-    json_extract(data, '$.modelID') as modelID,
-    json_extract(data, '$.tokens') as tokens,
-    json_extract(data, '$.path.root') as rootPath
-    FROM message`;
-
-  let rows;
-  try {
-    rows = queryDbJson(DB_PATH, query);
-  } catch (err) {
+import { getOpenCodeStores } from '../opencode-roots.js';
+
+function readSqlite(path) {
+  // Select only accounting/timing metadata, never message text or tool inputs.
+  // Keep the existing top-level model/project precedence for old uploads.
+  const query = `SELECT id, session_id AS sessionID,
+    json_extract(data, '$.role') AS role,
+    json_extract(data, '$.time.created') AS created,
+    coalesce(json_extract(data, '$.modelID'), json_extract(data, '$.model.modelID')) AS modelID,
+    json_extract(data, '$.tokens') AS tokens,
+    json_extract(data, '$.path.root') AS rootPath
+    FROM message ORDER BY id`;
+  try { return queryDbJson(path, query); }
+  catch (err) {
     if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('OpenCode');
     throw err;
   }
-  if (!rows.length) return { buckets: [], sessions: [] };
-
-  const entries = [];
-  const sessionEvents = [];
-  for (const row of rows) {
-    const timestamp = new Date(row.created);
-    if (isNaN(timestamp.getTime())) continue;
-
-    const project = row.rootPath ? basename(row.rootPath) : 'unknown';
-    const sessionId = row.sessionID || 'unknown';
-
-    sessionEvents.push({
-      sessionId,
-      source: 'opencode',
-      project,
-      timestamp,
-      role: row.role === 'user' ? 'user' : 'assistant',
-    });
+}
 
-    if (!row.modelID) continue;
-    let tokens;
-    try {
-      tokens = typeof row.tokens === 'string' ? JSON.parse(row.tokens) : row.tokens;
-    } catch {
-      continue;
+function readJson(path) {
+  const rows = [];
+  for (const dir of readdirSync(path, { withFileTypes: true })) {
+    if (!dir.isDirectory() || !dir.name.startsWith('ses_')) continue;
+    const sessionPath = join(path, dir.name);
+    for (const file of readdirSync(sessionPath).sort()) {
+      if (!file.endsWith('.json')) continue;
+      const data = JSON.parse(readFileSync(join(sessionPath, file), 'utf8'));
+      rows.push({ id: data.id || basename(file, '.json'), sessionID: dir.name,
+        role: data.role, created: data.time?.created,
+        modelID: data.modelID || data.model?.modelID,
+        tokens: data.tokens, rootPath: data.path?.root });
     }
-    if (!tokens || (!tokens.input && !tokens.output)) continue;
-
-    entries.push({
-      source: 'opencode',
-      model: row.modelID || 'unknown',
-      project,
-      timestamp,
-      inputTokens: tokens.input || 0,
-      outputTokens: tokens.output || 0,
-      cachedInputTokens: tokens.cache?.read || 0,
-      reasoningOutputTokens: tokens.reasoning || 0,
-    });
   }
-
-  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
+  return rows;
 }
 
-function parseFromJson() {
-  if (!existsSync(MESSAGES_DIR)) return { buckets: [], sessions: [] };
-
-  const entries = [];
-  const sessionEvents = [];
-  let sessionDirs;
-  try {
-    sessionDirs = readdirSync(MESSAGES_DIR, { withFileTypes: true })
-      .filter(d => d.isDirectory() && d.name.startsWith('ses_'));
-  } catch {
-    return { buckets: [], sessions: [] };
-  }
+function tokenSize(row) {
+  const t = row.tokens;
+  return ['input', 'output', 'reasoning'].reduce((n, key) => n + (Number(t?.[key]) || 0), 0)
+    + (Number(t?.cache?.read) || 0);
+}
 
-  for (const sessionDir of sessionDirs) {
-    const sessionPath = join(MESSAGES_DIR, sessionDir.name);
-    let msgFiles;
+export async function parse({ extraRoots = [] } = {}) {
+  const warnings = [];
+  const stores = getOpenCodeStores({ extraRoots, onWarning: message => warnings.push(message) });
+  const records = new Map();
+  for (const store of stores) {
     try {
-      msgFiles = readdirSync(sessionPath).filter(f => f.endsWith('.json'));
-    } catch {
-      continue;
-    }
-
-    for (const file of msgFiles) {
-      const filePath = join(sessionPath, file);
-
-      let data;
-      try {
-        data = JSON.parse(readFileSync(filePath, 'utf-8'));
-      } catch {
-        continue;
+      const rows = store.kind === 'sqlite' ? readSqlite(store.path) : readJson(store.path);
+      for (const [index, row] of rows.entries()) {
+        const timestamp = new Date(row.created);
+        if (!Number.isFinite(timestamp.getTime())) continue;
+        if (typeof row.tokens === 'string') row.tokens = JSON.parse(row.tokens);
+        const sessionId = row.sessionID || 'unknown';
+        // Message ids are unique within an OpenCode session. Across stores,
+        // keep the most complete copy; never dedup unrelated equal-sized calls.
+        // Missing ids cannot prove that two stores hold the same record.
+        const key = JSON.stringify([sessionId, row.id || `${store.path}:${index}`]);
+        const old = records.get(key);
+        if (!old || tokenSize(row) > tokenSize(old)) records.set(key, { ...row, timestamp, sessionId });
       }
-
-      const timestamp = new Date(data.time?.created);
-      if (isNaN(timestamp.getTime())) continue;
-
-      const rootPath = data.path?.root;
-      const project = rootPath ? basename(rootPath) : 'unknown';
-
-      sessionEvents.push({
-        sessionId: sessionDir.name,
-        source: 'opencode',
-        project,
-        timestamp,
-        role: data.role === 'user' ? 'user' : 'assistant',
-      });
-
-      if (!data.modelID) continue;
-      const tokens = data.tokens;
-      if (!tokens) continue;
-      if (!tokens.input && !tokens.output) continue;
-
-      entries.push({
-        source: 'opencode',
-        model: data.modelID || 'unknown',
-        project,
-        timestamp,
-        inputTokens: tokens.input || 0,
-        outputTokens: tokens.output || 0,
-        cachedInputTokens: tokens.cache?.read || 0,
-        reasoningOutputTokens: tokens.reasoning || 0,
-      });
-    }
+    } catch (err) { warnings.push(`OpenCode: 无法读取 ${store.path}: ${err.message}`); }
   }
+  if (warnings.length) return { buckets: [], sessions: [], skipped: true, warnings };
 
-  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
+  const entries = [], events = [];
+  for (const row of records.values()) {
+    // Keep the existing project derivation and token semantics. Additional roots
+    // must not rename previously uploaded projects/models or alter their counts.
+    const project = row.rootPath ? basename(row.rootPath) : 'unknown';
+    const base = { source: 'opencode', project, timestamp: row.timestamp };
+    events.push({ ...base, sessionId: row.sessionId, role: row.role === 'user' ? 'user' : 'assistant' });
+    const tokens = row.tokens;
+    if (!row.modelID || !tokens || (!tokens.input && !tokens.output)) continue;
+    entries.push({ ...base, model: row.modelID,
+      inputTokens: tokens.input || 0, outputTokens: tokens.output || 0,
+      cachedInputTokens: tokens.cache?.read || 0, reasoningOutputTokens: tokens.reasoning || 0 });
+  }
+  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(events) };
 }

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

@@ -1,6 +1,7 @@
 import { existsSync, readdirSync, statSync } from 'node:fs';
 import { dirname, isAbsolute, join, posix, resolve, win32 } from 'node:path';
 import { homedir } from 'node:os';
+import { getOpenCodeStores } from './opencode-roots.js';
 import { findClaudeCodeDataDirs } from './claude-roots.js';
 import { findCindyDataDirs, getCindyDataRoots } from './cindy-roots.js';
 import { codexSessionDirs, resolveCodexHomes } from './codex-roots.js';
@@ -14,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';
@@ -123,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) {
@@ -175,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),
@@ -258,7 +261,7 @@ export const TOOLS = [
     name: 'Claude Code',
     id: 'claude-code',
     dataDir: join(homedir(), '.claude', 'projects'),
-    detectDataDirs: findClaudeCodeDataDirs,
+    detectDataDirs: ({ extraRoots } = {}) => findClaudeCodeDataDirs(extraRootList(extraRoots?.['claude-code'])),
   },
   {
     name: 'Codex CLI',
@@ -311,6 +314,9 @@ export const TOOLS = [
     name: 'OpenCode',
     id: 'opencode',
     dataDir: join(homedir(), '.local', 'share', 'opencode'),
+    detectDataDirs: ({ extraRoots } = {}) => getOpenCodeStores({
+      extraRoots: extraRootList(extraRoots?.opencode),
+    }).map(store => store.path),
   },
   {
     name: 'OpenClaw',
@@ -433,7 +439,7 @@ export const TOOLS = [
   {
     name: 'ZCode',
     id: 'zcode',
-    dataDir: join(homedir(), '.zcode', 'cli', 'db', 'db.sqlite'),
+    dataDir: getZcodeDbPath(),
   },
 ];