@vibe-cafe/vibe-usage 0.10.27 → 0.10.29

package/README.md

@@ -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 |
@@ -80,8 +81,8 @@ npx @vibe-cafe/vibe-usage help --all   # Full help (plain `help` shows the short
 | MiMoCode | `$MIMOCODE_HOME/data/mimocode.db`, `$XDG_DATA_HOME/mimocode/mimocode.db`, or `~/.local/share/mimocode/mimocode.db` (SQLite; exact input, output, reasoning, and cache-read tokens from assistant messages; honors `MIMOCODE_DB`; cache-write tokens are included in input usage) |
 | Amp | `~/.local/share/amp/threads/`; cache-creation tokens are included in input usage |
 | Droid | `~/.factory/sessions/` |
-| DeepSeek Harness | `$DSH_HOME/sessions/` (default `~/.dsh`, fixture/relocation override: `VIBE_USAGE_DSH_SESSIONS`). Reads multi-frame Zstandard `session.jsonl.zstd` logs (built-in `node:zlib` zstd on Node ≥ 22.15, `zstd` CLI fallback) and plain `session.jsonl` logs. Usage comes from `assistant/message`: cache writes join uncached input, cache reads remain separate, and reasoning is split out of inclusive output. Fork/subagent history is de-duplicated from the immutable header: `parentSession` identifies the source and `seedLength` gives the exact leading event boundary. Inherited messages are skipped only when matching source seqs remain in the parent file; missing parents fail open. `session/end-seed` positions are not used because resumes can append the marker after real history. |
-| 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. |
+| 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 |
 | Roo Code | `<host>/User/globalStorage/rooveterinaryinc.roo-cline/{tasks/_index.json,tasks/<id>/{history_item,ui_messages}.json}` (walks all VSCode-fork hosts) |

package/package.json

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

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,8 @@ 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 = [
+  '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/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/dsh.js

@@ -7,13 +7,14 @@ import { aggregateToBuckets, extractSessions } from './aggregate.js';
 
 const SOURCE = 'dsh';
 
-// DeepSeek Harness session-log format version this parser understands. DeepSeek
-// Harness is currently in developer preview and is iterating rapidly — THERE
-// WILL BE COMPATIBILITY-BREAKING CHANGES. When the CLI bumps the header
-// `version` field, bump this constant (and the record-shape mapping below)
-// after re-checking the on-disk format instead of guessing against stale
-// assumptions.
-const SESSION_FORMAT_VERSION = 0;
+// Verified against deepseek-ai/deepseek-harness tag dsh-v0.1.5-alpha.2:
+// packages/session/session-format/src/filename.ts, session-format-v0-to-v1,
+// session-format-v1-to-v2, session-format-v2-to-v3, and core/session/src/types.ts.
+// V0/V1 use header.seedLength; V2/V3 use a tagged inherited end-seed marker.
+// Re-check the format before accepting another version; never silently read a
+// frozen predecessor when a newer generation is present.
+const MAX_SESSION_FORMAT_VERSION = 3;
+const SESSION_FILENAME = /^session(?:\.v([1-9][0-9]*))?\.jsonl(\.zstd)?$/;
 
 // Safety cap for a single session log. DSH stores many small zstd frames per
 // file; anything beyond this is either a runaway log or not a session file.
@@ -198,18 +199,10 @@ function isUserMessageRecord(rec) {
  *   ... possibly a resumed/forked seed replay, then ...
  *   {"type":"user/message"|"assistant/message","time":...,"data":{...}}
  *
- * DSH (developer preview) writes session/end-seed records in three situations:
- * right after session creation (empty seed), at each resume boundary, and
- * appended at the END of a file when that session becomes the seed for a
- * further resume. The marker's position is therefore NOT a replay boundary —
- * a trailing marker would make "skip everything before the last marker"
- * discard the session's entire real history.
- *
- * Fork/subagent lineage is encoded separately in the immutable header.
- * `parentSession` identifies the source and `seedLength` is the exact number
- * of leading event seqs inherited from it. Only those seqs are skipped, and
- * only while the parent file is also present, so a missing/corrupt source
- * fails open instead of dropping the sole local copy of its usage.
+ * V0/V1 use header.seedLength. Their untagged end-seed markers can appear
+ * after real history and must never be treated as a replay boundary. V2/V3
+ * instead require isSeeded and use the LAST end-seed with data.inherited=true.
+ * Only a proven inherited prefix also present in the parent is skipped.
  *
  * Only user/message (source.kind === 'user') and assistant/message records
  * are kept in the model — they are the only records that produce usage
@@ -220,7 +213,7 @@ function isUserMessageRecord(rec) {
  * session_projcache totals DSH itself maintains), so reasoning is split out of
  * output before aggregation, like the Pi-family parsers.
  */
-function buildSessionModel(text) {
+function buildSessionModel(text, fileVersion) {
   const lines = text.split('\n');
 
   let header = null;
@@ -240,16 +233,23 @@ function buildSessionModel(text) {
   if (!header || typeof header.id !== 'string' || header.id.length === 0) {
     throw new Error('missing session header record');
   }
-  if (header.version !== SESSION_FORMAT_VERSION) {
+  if (!Number.isInteger(header.version) || header.version < 0 || header.version > MAX_SESSION_FORMAT_VERSION) {
     const error = new Error(
       'session ' + header.id + ' uses format version ' + header.version +
-      ' (parser supports ' + SESSION_FORMAT_VERSION + ')',
+      ' (parser supports 0–' + MAX_SESSION_FORMAT_VERSION + ')',
     );
     error.code = 'UNSUPPORTED_FORMAT_VERSION';
     throw error;
   }
+  if (header.version !== fileVersion) {
+    throw new Error('session header format version ' + header.version + ' disagrees with filename version ' + fileVersion);
+  }
+  if (header.version >= 2 && typeof header.isSeeded !== 'boolean') {
+    throw new Error('format v' + header.version + ' session header lacks isSeeded');
+  }
 
   const messages = [];
+  let inheritedSeq = null;
   for (let i = 0; i < lines.length; i++) {
     if (lines[i].length === 0) continue;
     let rec;
@@ -263,8 +263,13 @@ function buildSessionModel(text) {
     if (timeMs == null) continue;
     const seq = Number.isSafeInteger(rec.seq) && rec.seq >= 0 ? rec.seq : null;
 
+    if (header.version >= 2 && rec.type === 'session/end-seed' && rec.data?.inherited === true) {
+      if (seq == null) throw new Error('inherited end-seed marker lacks a valid seq');
+      inheritedSeq = seq;
+    }
+
     if (isUserMessageRecord(rec)) {
-      messages.push({ seq, role: 'user', timeMs, usage: null, model: null });
+      messages.push({ seq, messageId: messageId(rec.data.id), role: 'user', timeMs, usage: null, model: null });
       continue;
     }
     if (!isUsageRecord(rec)) continue;
@@ -273,6 +278,7 @@ function buildSessionModel(text) {
     // usage block is missing; the model keeps it so timing survives.
     messages.push({
       seq,
+      messageId: messageId(rec.data.message?.id),
       role: 'assistant',
       timeMs,
       usage: parseUsage(rec.data.usage),
@@ -283,13 +289,18 @@ function buildSessionModel(text) {
     });
   }
 
+  if (header.version >= 2 && header.isSeeded !== (inheritedSeq !== null)) {
+    throw new Error('isSeeded disagrees with the inherited end-seed marker');
+  }
+
   return {
+    formatVersion: header.version,
     sessionId: header.id,
     parentSessionId:
       typeof header.parentSession === 'string' && header.parentSession
         ? header.parentSession
         : null,
-    seedLength:
+    seedLength: header.version >= 2 ? (inheritedSeq ?? 0) :
       Number.isSafeInteger(header.seedLength) && header.seedLength > 0
         ? header.seedLength
         : 0,
@@ -298,6 +309,10 @@ function buildSessionModel(text) {
   };
 }
 
+function messageId(value) {
+  return typeof value === 'string' && value.length > 0 ? value : null;
+}
+
 /** Record wall-clock time in epoch ms; null when absent/invalid. */
 function recordTimeMs(rec) {
   const t = rec.time;
@@ -337,9 +352,10 @@ function sameUsage(left, right) {
 /**
  * Number of leading child messages inherited from a parent seed.
  *
- * `header.seedLength` is DSH's durable fork-lineage boundary: event seqs below
- * it came from the parent, while later seqs belong to the child. Each skipped
- * message must still exist at the same seq in the selected parent copy.
+ * seedLength is normalized from the version's durable inheritance boundary.
+ * Each skipped message must still exist in the selected parent copy. Format
+ * migrations renumber events, but preserve existing message ids; mixed-format
+ * parents therefore need matching ids in order, never a token-count heuristic.
  * Missing, invalid, or divergent records fail open so usage is not lost.
  */
 function replaySkipCount(child, parent) {
@@ -347,21 +363,30 @@ function replaySkipCount(child, parent) {
   let parentIndex = 0;
   let previousSeq = -1;
   let count = 0;
+  const mixedVersions = child.formatVersion !== parent.formatVersion;
   for (const message of child.messages) {
     if (message.seq == null || message.seq <= previousSeq) return 0;
     previousSeq = message.seq;
     if (message.seq >= child.seedLength) break;
 
-    while (
-      parentIndex < parent.messages.length &&
-      parent.messages[parentIndex].seq != null &&
-      parent.messages[parentIndex].seq < message.seq
-    ) {
-      parentIndex++;
+    if (mixedVersions) {
+      if (!message.messageId) return 0;
+      while (parentIndex < parent.messages.length && parent.messages[parentIndex].messageId !== message.messageId) {
+        parentIndex++;
+      }
+    } else {
+      while (
+        parentIndex < parent.messages.length &&
+        parent.messages[parentIndex].seq != null &&
+        parent.messages[parentIndex].seq < message.seq
+      ) {
+        parentIndex++;
+      }
     }
     const source = parent.messages[parentIndex];
     if (
-      source?.seq !== message.seq ||
+      !source ||
+      (!mixedVersions && source.seq !== message.seq) ||
       source.role !== message.role ||
       source.model !== message.model ||
       !sameUsage(source.usage, message.usage)
@@ -397,7 +422,27 @@ function modelToResult(model, skipCount) {
   return { entries, events };
 }
 
-/** List session log files under a DSH sessions root (session.jsonl[.zstd]). */
+/** Pick the highest canonical generation per session, like DSH persistence. */
+function selectSessionFile(sessionPath) {
+  let selected = null;
+  for (const entry of readdirSync(sessionPath, { withFileTypes: true })) {
+    if (!entry.isFile() && !entry.isSymbolicLink()) continue;
+    const match = SESSION_FILENAME.exec(entry.name);
+    if (!match) continue;
+    const version = Number(match[1] || 0);
+    if (!Number.isSafeInteger(version)) throw new Error('invalid format version in ' + entry.name);
+    const compressed = Boolean(match[2]);
+    if (!selected || version > selected.version || (version === selected.version && compressed)) {
+      selected = { file: join(sessionPath, entry.name), version, compressed };
+    }
+  }
+  if (selected && selected.version > MAX_SESSION_FORMAT_VERSION) {
+    throw new Error('format version ' + selected.version + ' is not supported; update Vibe Usage');
+  }
+  return selected;
+}
+
+/** List session.jsonl[.zstd] (V0) and session.vN.jsonl[.zstd] (V1+). */
 function listSessionFiles(sessionsDir, onFailure) {
   const files = [];
   const projectKeys = readdirSync(sessionsDir, { withFileTypes: true })
@@ -419,22 +464,14 @@ function listSessionFiles(sessionsDir, onFailure) {
     for (const sessionDir of sessionDirs) {
       if (!sessionDir.isDirectory()) continue;
       const sessionPath = join(projectDir, sessionDir.name);
-      for (const name of ['session.jsonl.zstd', 'session.jsonl']) {
-        const file = join(sessionPath, name);
-        try {
-          if (statSync(file).isFile()) {
-            files.push({ file, compressed: name.endsWith('.zstd') });
-            break;
-          }
-        } catch (error) {
-          if (error?.code !== 'ENOENT') {
-            onFailure(
-              'dsh: cannot inspect ' + relative(sessionsDir, file) +
-              ' (' + (error?.code || error?.message || 'stat failed') + ')',
-            );
-            break;
-          }
-        }
+      try {
+        const selected = selectSessionFile(sessionPath);
+        if (selected) files.push(selected);
+      } catch (error) {
+        onFailure(
+          'dsh: cannot read session directory ' + relative(sessionsDir, sessionPath) +
+          ' (' + (error?.message || error?.code || 'read failed') + ')',
+        );
       }
     }
   }
@@ -444,17 +481,15 @@ function listSessionFiles(sessionsDir, onFailure) {
 /**
  * DeepSeek Harness (dsh) parser.
  *
- * Reads $DSH_HOME/sessions/<project-key>/session-<id>/session.jsonl.zstd
+ * Reads $DSH_HOME/sessions/<project-key>/<id>/session[.vN].jsonl[.zstd]
  * (default ~/.dsh, fixture/relocation override VIBE_USAGE_DSH_SESSIONS).
  * Zstandard session logs are multi-frame; node:zlib zstd (Node >= 22.15)
  * decodes one frame per call, so the buffer is walked frame-by-frame, with a
  * `zstd` CLI fallback for older Node.
  *
  * Replay handling: `header.parentSession` identifies a fork/subagent source,
- * and `header.seedLength` is the exact count of leading event seqs inherited
- * from it. Those records are skipped only when the parent file is also
- * present. Files without either field, and children whose parent is missing,
- * are counted in full. `session/end-seed` positions are never used.
+ * with a version-specific inheritance boundary (see buildSessionModel).
+ * Children whose parent is missing are counted in full.
  */
 export async function parse() {
   const sessionsDir = getDshSessionsDir();
@@ -485,10 +520,10 @@ export async function parse() {
     return result;
   }
 
-  // sessionId -> most complete model (largest decompressed log wins, so a
-  // session copied between project dirs is counted once).
+  // sessionId -> newest generation, then largest copy within that generation.
+  // Migrations can shrink a log by embedding chunks, so size alone is unsafe.
   const perSession = new Map();
-  for (const { file, compressed } of files) {
+  for (const { file, compressed, version } of files) {
     let text;
     try {
       const stat = statSync(file);
@@ -510,7 +545,7 @@ export async function parse() {
 
     let model;
     try {
-      model = buildSessionModel(text);
+      model = buildSessionModel(text, version);
     } catch (error) {
       recordFailure(
         'dsh: skipping ' + relative(process.cwd(), file) + ' (' + error.message + ')',
@@ -520,7 +555,8 @@ export async function parse() {
 
     const weight = text.length;
     const previous = perSession.get(model.sessionId);
-    if (!previous || weight > previous.weight) {
+    if (!previous || model.formatVersion > previous.model.formatVersion ||
+      (model.formatVersion === previous.model.formatVersion && weight > previous.weight)) {
       perSession.set(model.sessionId, { model, weight });
     }
   }

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