@vibe-cafe/vibe-usage 0.10.28 → 0.10.30

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)
@@ -64,6 +64,7 @@ npx @vibe-cafe/vibe-usage help --all   # Full help (plain `help` shows the short
 | 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 |
+| 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` |
 | CraftAgent | `~/.craft-agent/workspaces/*/sessions/*/.pi-sessions/*.jsonl`; honors `$CRAFT_AGENT_DIR` / `$CRAFTAGENT_DIR`; cache writes are included in input usage |
@@ -81,9 +82,9 @@ npx @vibe-cafe/vibe-usage help --all   # Full help (plain `help` shows the short
 | Amp | `~/.local/share/amp/threads/`; cache-creation tokens are included in input usage |
 | Droid | `~/.factory/sessions/` |
 | 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 | `$HERMES_HOME/state.db` (default `~/.hermes/state.db`) + `profiles/<name>/state.db` (SQLite, multi-profile). 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. |
+| 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. |

package/package.json

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

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

@@ -0,0 +1,16 @@
+import { statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+export function getColaSessionsDir() {
+  return join(process.env.COLA_DATA_DIR ?? join(homedir(), '.cola'), 'sessions');
+}
+
+export function findColaDataDirs() {
+  const dir = getColaSessionsDir();
+  try {
+    return statSync(dir).isDirectory() ? [dir] : [];
+  } catch {
+    return [];
+  }
+}

package/src/daemon-service.js

@@ -115,6 +115,11 @@ 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',
   'MIMOCODE_HOME',
   'MIMOCODE_DB',

package/src/hermes-roots.js

@@ -0,0 +1,59 @@
+import { readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+// Match the Hermes CLI/Desktop layout. Windows installers use LOCALAPPDATA;
+// Desktop falls back to an existing ~/.hermes only before that native root exists.
+export function getHermesHome({ onError = () => {} } = {}) {
+  const explicit = process.env.HERMES_HOME?.trim();
+  if (explicit) return explicit;
+
+  const legacy = join(homedir(), '.hermes');
+  if (process.platform !== 'win32') return legacy;
+
+  const localAppData = process.env.LOCALAPPDATA?.trim() || join(homedir(), 'AppData', 'Local');
+  const native = join(localAppData, 'hermes');
+  return !statIfPresent(native, onError)?.isDirectory()
+    && statIfPresent(legacy, onError)?.isDirectory() ? legacy : native;
+}
+
+function statIfPresent(path, onError) {
+  try {
+    return statSync(path);
+  } catch (err) {
+    if (err.code !== 'ENOENT') onError(err);
+    return null;
+  }
+}
+
+// Parsing must fail on unreadable stores: a partial result would allow sync
+// to prune that profile's previous state. Detection alone is best-effort.
+export function discoverHermesDatabases({ onError = err => { throw err; } } = {}) {
+  const home = getHermesHome({ onError });
+  const dbs = [];
+
+  const defaultDb = join(home, 'state.db');
+  if (statIfPresent(defaultDb, onError)) dbs.push({ path: defaultDb, profile: 'default' });
+
+  const profilesDir = join(home, 'profiles');
+  let entries;
+  try {
+    entries = readdirSync(profilesDir, { withFileTypes: true });
+  } catch (err) {
+    if (err.code !== 'ENOENT') onError(err);
+    return dbs;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const profileDb = join(profilesDir, entry.name, 'state.db');
+    if (statIfPresent(profileDb, onError)?.isFile()) {
+      dbs.push({ path: profileDb, profile: entry.name });
+    }
+  }
+
+  return dbs;
+}
+
+export function findHermesDataDirs() {
+  return discoverHermesDatabases({ onError: () => {} }).map(db => db.path);
+}

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)

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

@@ -0,0 +1,17 @@
+import { getColaSessionsDir } from '../cola-roots.js';
+import { parsePiSessionJsonl } from './pi-session-jsonl.js';
+
+/** Cola 1.4.4 writes Pi-compatible transcripts under sessions/<scope>/. */
+export async function parse() {
+  const result = await parsePiSessionJsonl({
+    source: 'cola',
+    sessionsDirs: [getColaSessionsDir()],
+    // Scope slugs may identify channels or people, not projects. The session
+    // header's cwd supplies a project when present; otherwise keep unknown.
+    projectFromPath: () => 'unknown',
+    deduplicateCopiedSessions: true,
+  });
+  // A missing part of the store must not overwrite a complete uploaded bucket
+  // with a partial sum, even when several projects are hidden behind unknown.
+  return result.skipped ? { ...result, buckets: [], sessions: [] } : result;
+}

package/src/parsers/hermes.js

@@ -1,24 +1,22 @@
-import { existsSync, readdirSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
+import { discoverHermesDatabases } from '../hermes-roots.js';
 import { aggregateToBuckets, extractSessions } from './aggregate.js';
 import { toCount } from './fs-utils.js';
 import { queryDbJson, sqliteUnavailableError, isSqliteUnavailableError } from './sqlite.js';
 
-const HERMES_HOME = process.env.HERMES_HOME || join(homedir(), '.hermes');
-
 /**
  * Parse Hermes Agent usage data from its SQLite databases.
  *
  * Hermes supports multiple profiles — the default profile lives at
- * ~/.hermes/state.db, while named profiles live at ~/.hermes/profiles/<name>/state.db.
+ * <home>/state.db, while named profiles live at <home>/profiles/<name>/state.db.
+ * The home is shared by CLI/Desktop: ~/.hermes on macOS/Linux, LOCALAPPDATA/hermes
+ * on Windows, or an explicit HERMES_HOME.
  * Each profile is an independent HERMES_HOME with its own state.db, so we scan all of them.
  *
  * Token buckets come from the sessions table (cumulative per-session totals).
  * Session timing comes from the messages table (per-message role + timestamp).
  */
 export async function parse() {
-  const dbs = discoverDbPaths(HERMES_HOME);
+  const dbs = discoverHermesDatabases();
   if (dbs.length === 0) return { buckets: [], sessions: [] };
 
   const entries = [];
@@ -68,19 +66,15 @@ export async function parse() {
       });
     }
 
-    let messageRows;
-    try {
-      messageRows = queryDb(dbPath, `SELECT
-        session_id as sessionId,
-        role,
-        timestamp
-        FROM messages
-        WHERE role IN ('user', 'assistant')
-        ORDER BY timestamp`);
-    } catch {
-      // Messages query failed for this profile — skip its session events
-      continue;
-    }
+    // A failed query is not an empty session history. Let sync protect this
+    // source's previous state instead of uploading/pruning a partial result.
+    const messageRows = queryDb(dbPath, `SELECT
+      session_id as sessionId,
+      role,
+      timestamp
+      FROM messages
+      WHERE role IN ('user', 'assistant')
+      ORDER BY timestamp`);
 
     for (const row of messageRows) {
       const timestamp = new Date(row.timestamp * 1000);
@@ -99,34 +93,6 @@ export async function parse() {
   return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
 }
 
-function discoverDbPaths(home) {
-  const dbs = [];
-
-  const defaultDb = join(home, 'state.db');
-  if (existsSync(defaultDb)) dbs.push({ path: defaultDb, profile: 'default' });
-
-  const profilesDir = join(home, 'profiles');
-  if (existsSync(profilesDir)) {
-    let entries;
-    try {
-      entries = readdirSync(profilesDir, { withFileTypes: true });
-    } catch {
-      return dbs;
-    }
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const profileDb = join(profilesDir, entry.name, 'state.db');
-      try {
-        if (statSync(profileDb).isFile()) dbs.push({ path: profileDb, profile: entry.name });
-      } catch {
-        // missing or unreadable — skip
-      }
-    }
-  }
-
-  return dbs;
-}
-
 function queryDb(dbPath, sql) {
   return queryDbJson(dbPath, sql);
 }

package/src/parsers/index.js

@@ -23,6 +23,7 @@ import { parse as parseKiro } from './kiro.js';
 import { parse as parseMcode } from './mcode.js';
 import { parse as parseMimocode } from './mimocode.js';
 import { parse as parsePiCodingAgent } from './pi-coding-agent.js';
+import { parse as parseCola } from './cola.js';
 import { parse as parseZcode } from './zcode.js';
 import { parse as parseTraeCli } from './trae-cli.js';
 import { parse as parseWorkbuddy } from './workbuddy.js';
@@ -31,6 +32,7 @@ import { parseQoder, parseQoderCn } from './qoder.js';
 export const parsers = {
   'claude-code': parseClaudeCode,
   'codex': parseCodex,
+  'cola': parseCola,
   'grok': parseGrok,
   'copilot-cli': parseCopilotCli,
   'craft-agent': parseCraftAgent,

package/src/parsers/pi-session-jsonl.js

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync, readFileSync, realpathSync } from 'node:fs';
+import { readdirSync, readFileSync, realpathSync } from 'node:fs';
 import { basename, join, relative } from 'node:path';
 import { aggregateToBuckets, extractSessions } from './aggregate.js';
 import { projectFromCwd, toCount } from './fs-utils.js';
@@ -11,12 +11,13 @@ function warn(ctx, message) {
 }
 
 function findJsonlFiles(dir, includeFile, ctx) {
-  if (!existsSync(dir)) return [];
   let children;
   try {
     children = readdirSync(dir, { withFileTypes: true });
   } catch (err) {
-    warn(ctx, `${ctx.source}: cannot read directory ${dir}: ${err.message}`);
+    if (err.code !== 'ENOENT') {
+      warn(ctx, `${ctx.source}: cannot read directory ${dir}: ${err.message}`);
+    }
     return [];
   }
 
@@ -56,6 +57,7 @@ export async function parsePiSessionJsonl({
   sessionsDirs,
   includeFile = () => true,
   projectFromPath = projectFromFirstDir,
+  deduplicateCopiedSessions = false,
 }) {
   const ctx = { source, warnings: [], incomplete: false };
   const entriesById = new Map();
@@ -63,6 +65,7 @@ export async function parsePiSessionJsonl({
   const eventsById = new Map();
   const anonymousEvents = [];
   const seenFiles = new Set();
+  const recordOwners = new Map();
 
   for (const sessionsDir of sessionsDirs) {
     for (const filePath of findJsonlFiles(sessionsDir, includeFile, ctx)) {
@@ -80,6 +83,8 @@ export async function parsePiSessionJsonl({
 
       let sessionId = basename(filePath, '.jsonl');
       let project = projectFromPath(filePath, sessionsDir) || 'unknown';
+      let sessionStartedAt = Infinity;
+      let seenHeader = false;
 
       for (const line of content.split('\n')) {
         if (!line.trim()) continue;
@@ -89,18 +94,40 @@ export async function parsePiSessionJsonl({
         } catch {
           continue;
         }
+        if (!obj || typeof obj !== 'object') continue;
 
         if (obj.type === 'session') {
+          if (deduplicateCopiedSessions && seenHeader) continue;
+          seenHeader = true;
           if (obj.id) sessionId = String(obj.id);
           if (obj.cwd) project = projectFromCwd(obj.cwd);
+          const startedAt = new Date(obj.timestamp).getTime();
+          sessionStartedAt = Number.isFinite(startedAt) ? startedAt : Infinity;
           continue;
         }
         if (obj.type !== 'message' || !obj.message) continue;
 
         const message = obj.message;
-        const timestamp = new Date(obj.timestamp || message.timestamp || 0);
+        const rawTimestamp = obj.timestamp || message.timestamp;
+        const timestamp = new Date(rawTimestamp || 0);
         if (Number.isNaN(timestamp.getTime())) continue;
-        const recordId = obj.id ? `${sessionId}:${obj.id}` : null;
+        const model = message.model || message.modelId || obj.model || obj.modelId || 'unknown';
+        // Cola copies a transcript with a new session header but unchanged
+        // records. Its short message ids are only unique within a session, so
+        // cross-session dedup also requires time, parent, role, and model.
+        // All existing Pi-family callers retain sessionId:id identities.
+        const recordId = !obj.id ? null : deduplicateCopiedSessions && rawTimestamp
+          ? JSON.stringify([obj.id, timestamp.getTime(), obj.parentId ?? null, message.role, model])
+          : `${sessionId}:${obj.id}`;
+
+        if (deduplicateCopiedSessions && recordId) {
+          const owner = recordOwners.get(recordId);
+          if (!owner || sessionStartedAt < owner.startedAt
+            || (sessionStartedAt === owner.startedAt && sessionId < owner.sessionId)
+            || (sessionStartedAt === owner.startedAt && sessionId === owner.sessionId && canonical < owner.filePath)) {
+            recordOwners.set(recordId, { sessionId, project, startedAt: sessionStartedAt, filePath: canonical });
+          }
+        }
 
         if (message.role === 'user' || message.role === 'assistant' || message.role === 'toolResult') {
           const event = {
@@ -130,7 +157,7 @@ export async function parsePiSessionJsonl({
 
         const entry = {
           source,
-          model: message.model || message.modelId || obj.model || obj.modelId || 'unknown',
+          model,
           project,
           timestamp,
           inputTokens,
@@ -150,9 +177,18 @@ export async function parsePiSessionJsonl({
 
   const entries = [
     ...anonymousEntries,
-    ...[...entriesById.values()].map(({ entry }) => entry),
+    ...[...entriesById].map(([id, { entry }]) => {
+      const owner = recordOwners.get(id);
+      return owner ? { ...entry, project: owner.project } : entry;
+    }),
+  ];
+  const events = [
+    ...anonymousEvents,
+    ...[...eventsById].map(([id, event]) => {
+      const owner = recordOwners.get(id);
+      return owner ? { ...event, sessionId: owner.sessionId, project: owner.project } : event;
+    }),
   ];
-  const events = [...anonymousEvents, ...eventsById.values()];
   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

@@ -11,7 +11,9 @@ import {
   grokSessionsDir,
 } from './extra-roots.js';
 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 { findOmpDataDirs, findPiDataDirs } from './pi-roots.js';
 import { findQoderDataDirs, getQoderProjectsDir } from './qoder-roots.js';
 import { findWorkbuddyDataDirs } from './workbuddy-roots.js';
@@ -266,6 +268,12 @@ export const TOOLS = [
       findCodexDataDirs(codexExtraHome, extraRootList(extraRoots?.codex))
     ),
   },
+  {
+    name: 'Cola',
+    id: 'cola',
+    dataDir: getColaSessionsDir(),
+    detectDataDirs: findColaDataDirs,
+  },
   {
     name: 'Grok',
     id: 'grok',
@@ -396,7 +404,8 @@ export const TOOLS = [
   {
     name: 'Hermes',
     id: 'hermes',
-    dataDir: join(homedir(), '.hermes', 'state.db'),
+    dataDir: join(getHermesHome(), 'state.db'),
+    detectDataDirs: findHermesDataDirs,
   },
   {
     name: 'Kiro',