@vibe-cafe/vibe-usage 0.10.29 → 0.10.31

package/README.md

@@ -38,7 +38,7 @@ npx @vibe-cafe/vibe-usage init         # Re-run setup via browser login (also ho
 npx @vibe-cafe/vibe-usage init --manual-key <vbu_...>   # Skip browser, use pre-issued key (CI/headless)
 npx @vibe-cafe/vibe-usage sync         # Manual sync
 npx @vibe-cafe/vibe-usage sync --extra-codex-home /path/to/.codex  # Add another Codex Home for this run only
-npx @vibe-cafe/vibe-usage summary       # Print last 7 days as markdown (cost / tokens / by model / by project)
+npx @vibe-cafe/vibe-usage summary       # Print last 7 days as markdown (cost / tokens / by tool / by model / by project)
 npx @vibe-cafe/vibe-usage summary --days N  # Same, over the last N days (1-90)
 npx @vibe-cafe/vibe-usage daemon       # Continuous sync (every 30m, foreground)
 npx @vibe-cafe/vibe-usage daemon install    # Install background service (systemd/launchd/Task Scheduler)
@@ -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,7 +71,7 @@ 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 |
@@ -84,7 +84,7 @@ 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 | Standalone `~/.cline/` plus `<host>/User/globalStorage/saoudrizwan.claude-dev/` across VSCode-fork hosts; migrated copies are deduplicated and empty leftover extension stores no longer count as installed |
+| 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 |
 | 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. |
@@ -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.29",
+  "version": "0.10.31",
   "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/cline-roots.js

@@ -1,18 +1,10 @@
-import { statSync } from 'node:fs';
+import { realpathSync, statSync } from 'node:fs';
 import { delimiter, join } from 'node:path';
 import { homedir } from 'node:os';
 
 const EXTENSION_ID = 'saoudrizwan.claude-dev';
 const HOSTS = ['Code', 'Cursor', 'Windsurf', 'VSCodium', 'Code - Insiders', 'Trae', 'Trae CN'];
 
-function hasTaskHistory(root) {
-  try {
-    return statSync(join(root, 'state', 'taskHistory.json')).isFile();
-  } catch {
-    return false;
-  }
-}
-
 function hostRoots() {
   const out = [];
   if (process.platform === 'darwin') {
@@ -28,13 +20,50 @@ function hostRoots() {
   return out;
 }
 
-export function findClineDataDirs() {
+/** Both legacy stores and the shared Cline 3.x CLI/extension SDK store. */
+export function findClineStores({ onWarning = () => {} } = {}) {
+  function isPath(path, directory = false) {
+    try {
+      const stat = statSync(path);
+      return directory ? stat.isDirectory() : stat.isFile();
+    } catch (err) {
+      if (err.code !== 'ENOENT' && err.code !== 'ENOTDIR') {
+        onWarning(`cline: 无法读取数据目录 ${path}: ${err.message}`);
+      }
+      return false;
+    }
+  }
+  function unique(paths) {
+    const seen = new Set();
+    return paths.filter(path => {
+      let key;
+      try { key = realpathSync(path); } catch { key = path; }
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
   const override = process.env.VIBE_USAGE_CLINE_DIRS?.trim();
-  const candidates = override
-    ? override.split(delimiter).map((value) => value.trim()).filter(Boolean)
-    : [
-        join(homedir(), '.cline'),
-        ...hostRoots().map((root) => join(root, 'User', 'globalStorage', EXTENSION_ID)),
-      ];
-  return [...new Set(candidates)].filter(hasTaskHistory);
+  const home = join(homedir(), '.cline');
+  const configuredHome = process.env.CLINE_DIR?.trim() || home;
+  const dataDir = process.env.CLINE_DATA_DIR?.trim() || join(configuredHome, 'data');
+  const roots = override
+    ? override.split(delimiter).map(value => value.trim()).filter(Boolean)
+    : [home, configuredHome, dataDir,
+        ...hostRoots().map(root => join(root, 'User', 'globalStorage', EXTENSION_ID))];
+  // Accept either a Cline home or its data directory. Keep the old standalone
+  // and editor stores so upgrading the runtime does not discard old history.
+  const dataRoots = unique(roots.flatMap(root => [root, join(root, 'data')]));
+  const legacyRoots = dataRoots.filter(root => isPath(join(root, 'state', 'taskHistory.json')));
+  const sessionDirs = override
+    ? dataRoots.map(root => join(root, 'sessions'))
+    : [...dataRoots.map(root => join(root, 'sessions')),
+        process.env.CLINE_SESSION_DATA_DIR?.trim()].filter(Boolean);
+  const sdkSessionDirs = unique(sessionDirs).filter(dir => isPath(dir, true));
+  return { legacyRoots: unique(legacyRoots), sdkSessionDirs };
+}
+
+export function findClineDataDirs() {
+  const { legacyRoots, sdkSessionDirs } = findClineStores();
+  return [...legacyRoots, ...sdkSessionDirs];
 }

package/src/daemon-service.js

@@ -115,6 +115,9 @@ function escapeXml(value) {
 // launchd/systemd unit that inherits nothing, so anything the parsers read for
 // discovery has to be captured into the unit at install time.
 const PRESERVED_SERVICE_ENV = [
+  'CLINE_DIR',
+  'CLINE_DATA_DIR',
+  'CLINE_SESSION_DATA_DIR',
   'COLA_DATA_DIR',
   'HERMES_HOME',
   'MCODE_HOME',

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

@@ -252,7 +252,7 @@ const FULL_HELP = `
     ${BARE} init --manual-key <vbu_...>   Skip browser, use a pre-issued key (CI/headless)
     ${BARE} sync         Manually sync usage data
     ${BARE} sync --extra-codex-home <path>  Use another Codex Home for this run
-    ${BARE} summary       Print last 7 days as markdown (cost/tokens/model/project)
+    ${BARE} summary       Print last 7 days as markdown (cost/tokens/tool/model/project)
     ${BARE} summary --days N   Same, but over the last N days (1-90)
     ${BARE} daemon       Continuous sync (every 30m, foreground)
     ${BARE} daemon install    Install background service (systemd/launchd/Task Scheduler)
@@ -269,7 +269,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/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

@@ -0,0 +1,106 @@
+import { readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+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) {
+  const copies = [];
+  for (const dir of sessionDirs) {
+    let children;
+    try { children = readdirSync(dir, { withFileTypes: true }); }
+    catch (err) { onWarning(`cline: 无法读取会话目录 ${dir}: ${err.message}`); continue; }
+    for (const child of children) {
+      if (!child.isDirectory()) continue;
+      const sessionDir = join(dir, child.name);
+      let files, manifest;
+      try {
+        files = readdirSync(sessionDir, { withFileTypes: true })
+          .filter(file => file.isFile() && file.name.endsWith('.messages.json'));
+        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');
+        }
+      } catch (err) {
+        onWarning(`cline: 无法读取会话目录 ${sessionDir}: ${err.message}`);
+        continue;
+      }
+      for (const file of files) {
+        const messagesPath = join(sessionDir, file.name);
+        try {
+          const payload = JSON.parse(readFileSync(messagesPath, 'utf8'));
+          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');
+          }
+          const project = projectFromCwd(manifest.workspace_root || manifest.cwd);
+          // Reduce immediately to accounting/timing metadata. No prompt, response,
+          // system prompt, tool arguments, credentials, or stored costs survive.
+          const messages = payload.messages.flatMap(message => {
+            if (!message || !['user', 'assistant'].includes(message.role)) return [];
+            if (message.role === 'user' && (payload.agent !== 'lead'
+              || message.metadata?.kind || message.metadata?.userRunSpan === 0
+              || ['system', 'status', 'error', 'tool'].includes(message.metadata?.displayRole)
+              || (Array.isArray(message.content) && message.content.some(block =>
+                block?.type === 'tool_result' || block?.type === 'tool-result')))) return [];
+            if (typeof message.ts !== 'number' || !Number.isFinite(message.ts)
+              || !Number.isFinite(new Date(message.ts).getTime())) return [];
+            // Legacy migration inserts a cumulative metric on an old assistant
+            // without a timestamp. Never re-date that summary to the migration.
+            const metric = message.role === 'assistant' ? message.metrics : null;
+            const input = toCount(metric?.inputTokens);
+            const cachedInputTokens = Math.min(input, toCount(metric?.cacheReadTokens));
+            return [{
+              id: typeof message.id === 'string' ? message.id : null,
+              role: message.role,
+              timestamp: message.ts,
+              model: message.modelInfo?.id || manifest.model || 'cline-unknown',
+              inputTokens: input - cachedInputTokens,
+              outputTokens: toCount(metric?.outputTokens),
+              cachedInputTokens,
+            }];
+          });
+          copies.push({ sessionId: child.name, artifactId: payload.sessionId, project, messages,
+            // Restored/forked artifacts retain message ids/timestamps; attribute
+            // shared history to the earliest original session deterministically.
+            started: Date.parse(manifest.started_at) || 0, messagesPath });
+        } catch (err) {
+          onWarning(`cline: 无法读取会话 ${messagesPath}: ${err.message}`);
+        }
+      }
+    }
+  }
+  copies.sort((a, b) => a.started - b.started
+    || a.sessionId.localeCompare(b.sessionId) || a.messagesPath.localeCompare(b.messagesPath));
+  const records = new Map();
+  for (const copy of copies) {
+    copy.messages.forEach((message, index) => {
+      // Anonymous messages can be deduplicated only within copies of this
+      // logical session; equal usage in unrelated sessions remains distinct.
+      const identity = message.id || `${copy.artifactId}:${index}`;
+      const key = JSON.stringify([identity, message.role, message.timestamp]);
+      const next = { ...message, sessionId: copy.sessionId, project: copy.project };
+      const old = records.get(key);
+      const count = value => value.inputTokens + value.outputTokens + value.cachedInputTokens;
+      if (!old) records.set(key, next);
+      else if (count(next) > count(old)) {
+        records.set(key, { ...next, sessionId: old.sessionId, project: old.project });
+      }
+    });
+  }
+  const entries = [], events = [];
+  for (const message of records.values()) {
+    const base = { source: 'cline', project: message.project, timestamp: new Date(message.timestamp) };
+    if (message.role === 'assistant'
+      && message.inputTokens + message.outputTokens + message.cachedInputTokens > 0) {
+      entries.push({ ...base, model: message.model, inputTokens: message.inputTokens,
+        outputTokens: message.outputTokens, cachedInputTokens: message.cachedInputTokens,
+        reasoningOutputTokens: 0 });
+    }
+    events.push({ ...base, sessionId: message.sessionId, role: message.role });
+  }
+  return { entries, events };
+}

package/src/parsers/cline.js

@@ -2,11 +2,13 @@ import { statSync } from 'node:fs';
 import { join } from 'node:path';
 import { aggregateToBuckets, extractSessions } from './aggregate.js';
 import { readJsonSafe, projectFromPath } from './fs-utils.js';
-import { findClineDataDirs } from '../cline-roots.js';
+import { findClineStores } from '../cline-roots.js';
+import { readClineSdk } from './cline-sdk.js';
 
 export async function parse() {
-  const extDirs = findClineDataDirs();
-  if (extDirs.length === 0) return { buckets: [], sessions: [] };
+  const warnings = [];
+  const onWarning = message => warnings.push(message);
+  const { legacyRoots: extDirs, sdkSessionDirs } = findClineStores({ onWarning });
 
   const entries = [];
   const events = [];
@@ -88,5 +90,8 @@ export async function parse() {
       }
   }
 
-  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(events) };
+  const sdk = readClineSdk(sdkSessionDirs, onWarning);
+  if (warnings.length) return { buckets: [], sessions: [], skipped: true, warnings };
+  return { buckets: aggregateToBuckets([...entries, ...sdk.entries]),
+    sessions: extractSessions([...events, ...sdk.events]) };
 }

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

@@ -1,6 +1,12 @@
 import { loadConfig } from './config.js';
 import { getJson } from './api.js';
 import { failure } from './output.js';
+import { TOOLS } from './tools.js';
+
+// Server-side source ids are raw slugs ('claude-code'); TOOLS carries the
+// display names. A source the server knows but this CLI doesn't parse falls
+// back to its id rather than disappearing from the table.
+const TOOL_NAMES = new Map(TOOLS.map(t => [t.id, t.name]));
 
 export async function runSummary(args = []) {
   const days = parseDays(args);
@@ -36,7 +42,7 @@ function parseDays(args) {
   return v;
 }
 
-function render(data, days, apiUrl) {
+export function render(data, days, apiUrl) {
   const buckets = Array.isArray(data?.buckets) ? data.buckets : [];
   const sessions = Array.isArray(data?.sessions) ? data.sessions : [];
   const dashboard = `${apiUrl}/usage`;
@@ -47,6 +53,7 @@ function render(data, days, apiUrl) {
 
   let totalCost = 0;
   let totalTokens = 0;
+  const bySource = new Map();
   const byModel = new Map();
   const byProject = new Map();
 
@@ -55,6 +62,7 @@ function render(data, days, apiUrl) {
     const tokens = Number(b.totalTokens ?? 0);
     totalCost += cost;
     totalTokens += tokens;
+    accumulate(bySource, b.source || 'unknown', { cost, tokens });
     accumulate(byModel, b.model, { cost, tokens });
     accumulate(byProject, b.project || 'unknown', { cost, tokens, sessions: 0 });
   }
@@ -74,6 +82,16 @@ function render(data, days, apiUrl) {
   lines.push(`**总览**: $${totalCost.toFixed(2)} · ${formatTokens(totalTokens)} tokens · ${sessionsCount} sessions · ${activeHours.toFixed(1)}h active`);
   lines.push('');
 
+  lines.push('## 按工具');
+  lines.push('');
+  lines.push('| 工具 | 费用 | Tokens | 占比 |');
+  lines.push('|---|---:|---:|---:|');
+  for (const [source, { cost, tokens }] of topN(bySource, 'cost', 8)) {
+    const pct = totalCost > 0 ? ((cost / totalCost) * 100).toFixed(0) : '0';
+    lines.push(`| ${TOOL_NAMES.get(source) || source} | $${cost.toFixed(2)} | ${formatTokens(tokens)} | ${pct}% |`);
+  }
+  lines.push('');
+
   lines.push('## 按模型');
   lines.push('');
   lines.push('| 模型 | 费用 | Tokens | 占比 |');

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';
@@ -258,7 +259,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 +312,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',