@vibe-cafe/vibe-usage 0.10.19 → 0.10.21

package/src/parsers/codex.js

@@ -17,6 +17,7 @@ import {
   resolveCodexHomes,
   validateExtraCodexHome,
 } from '../codex-roots.js';
+import { discoverCodexHomes } from '../extra-roots.js';
 import {
   codexCacheEnabled,
   fileSignature,
@@ -62,20 +63,22 @@ function decorateCodexModel(model, serviceTier, timestampMs) {
  * Recursively find all .jsonl files under a directory.
  * Codex CLI stores sessions as: ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl
  */
-function findJsonlFiles(dir) {
+function findJsonlFiles(dir, strict = false) {
   const results = [];
   if (!existsSync(dir)) return results;
   try {
     for (const entry of readdirSync(dir, { withFileTypes: true })) {
       const fullPath = join(dir, entry.name);
       if (entry.isDirectory()) {
-        for (const nested of findJsonlFiles(fullPath)) results.push(nested);
+        for (const nested of findJsonlFiles(fullPath, strict)) results.push(nested);
       } else if (entry.name.endsWith('.jsonl')) {
         results.push(fullPath);
       }
     }
-  } catch {
-    // ignore unreadable directories
+  } catch (err) {
+    if (strict && err?.code !== 'ENOENT') throw err;
+    // Default roots are best-effort; configured roots must never look empty
+    // merely because a directory became unreadable between syncs.
   }
   return results;
 }
@@ -837,7 +840,8 @@ function mergeFileResults(results) {
   return { buckets: aggregateToBuckets(entries), sessions };
 }
 
-async function parseNativeCodex({ codexExtraHome } = {}) {
+async function parseNativeCodex({ codexExtraHome, extraRoots = [] } = {}) {
+  let extraCodexHomePath = null;
   if (codexExtraHome?.trim()) {
     const validation = validateExtraCodexHome(codexExtraHome);
     if (!validation.ok) {
@@ -848,11 +852,31 @@ async function parseNativeCodex({ codexExtraHome } = {}) {
         warnings: [`codex: 额外 Codex Home 不可用，已跳过本次 Codex 同步: ${validation.path}`],
       };
     }
+    extraCodexHomePath = validation.path;
   }
 
-  const codexHomes = resolveCodexHomes(codexExtraHome);
+  const configuredHomes = [];
+  for (const root of extraRoots) {
+    const discovered = discoverCodexHomes(root);
+    if (!discovered.readable || discovered.homes.length === 0) {
+      return {
+        buckets: [],
+        sessions: [],
+        skipped: true,
+        warnings: [`codex: 额外根目录不可用，已跳过本次 Codex 同步: ${discovered.root}`],
+      };
+    }
+    configuredHomes.push(...discovered.homes);
+  }
+
+  const strictHomes = new Set(configuredHomes);
+  if (extraCodexHomePath) strictHomes.add(extraCodexHomePath);
+  const codexHomes = [...new Set([
+    ...resolveCodexHomes(codexExtraHome),
+    ...configuredHomes,
+  ])];
   const dirs = codexHomes.flatMap(codexHome => (
-    codexSessionDirs(codexHome).map(dir => ({ codexHome, dir }))
+    codexSessionDirs(codexHome).map(dir => ({ codexHome, dir, strict: strictHomes.has(codexHome) }))
   ));
   if (!dirs.some(({ dir }) => existsSync(dir))) return { buckets: [], sessions: [] };
 
@@ -868,8 +892,17 @@ async function parseNativeCodex({ codexExtraHome } = {}) {
     audited: 0,
   };
   const files = [];
-  for (const { codexHome, dir } of dirs) {
-    for (const filePath of findJsonlFiles(dir)) {
+  for (const { codexHome, dir, strict } of dirs) {
+    let filePaths;
+    try {
+      filePaths = findJsonlFiles(dir, strict);
+    } catch {
+      return {
+        buckets: [], sessions: [], skipped: true,
+        warnings: [`codex: 额外根目录读取失败，已保留上次同步数据: ${codexHome}`],
+      };
+    }
+    for (const filePath of filePaths) {
       try {
         const stat = statSync(filePath);
         if (stat.size <= 0) continue;
@@ -880,6 +913,7 @@ async function parseNativeCodex({ codexExtraHome } = {}) {
         const file = {
           codexHome,
           filePath,
+          strict,
           snapshotSize: stat.size,
           signature,
           cache,
@@ -890,9 +924,14 @@ async function parseNativeCodex({ codexExtraHome } = {}) {
         };
         if (!cache && priorCache) file.appendTail = tailStateFor(file);
         files.push(file);
-      } catch {
+      } catch (err) {
         // The file may move to archived_sessions between discovery and stat.
-        // Its archived copy will be picked up on the next sync.
+        if (strict && err?.code !== 'ENOENT') {
+          return {
+            buckets: [], sessions: [], skipped: true,
+            warnings: [`codex: 额外根目录读取失败，已保留上次同步数据: ${codexHome}`],
+          };
+        }
       }
     }
   }
@@ -928,6 +967,12 @@ async function parseNativeCodex({ codexExtraHome } = {}) {
         cacheStats.filesRead++;
         updateFileCache(file, { header: file.header });
       } catch {
+        if (file.strict) {
+          return {
+            buckets: [], sessions: [], skipped: true,
+            warnings: [`codex: 额外根目录读取失败，已保留上次同步数据: ${file.codexHome}`],
+          };
+        }
         continue;
       }
     }
@@ -981,6 +1026,12 @@ async function parseNativeCodex({ codexExtraHome } = {}) {
         cacheStats.filesRead++;
         updateFileCache(file, { index: meta });
       } catch {
+        if (file.strict) {
+          return {
+            buckets: [], sessions: [], skipped: true,
+            warnings: [`codex: 额外根目录读取失败，已保留上次同步数据: ${file.codexHome}`],
+          };
+        }
         continue;
       }
     }

package/src/parsers/cursor.js

@@ -68,7 +68,19 @@ function decodeJwtSub(token) {
   }
 }
 
-const FETCH_TIMEOUT_MS = 10_000;
+// Under full sync many parsers hammer disk concurrently; cursor.com's CSV
+// export can still succeed but take >10s. A short timeout caused silent skips.
+const DEFAULT_FETCH_TIMEOUT_MS = 30_000;
+const MAX_FETCH_TIMEOUT_MS = 2_147_483_647;
+
+export function resolveCursorFetchTimeout(value) {
+  const timeout = Number(value);
+  return Number.isInteger(timeout) && timeout > 0 && timeout <= MAX_FETCH_TIMEOUT_MS
+    ? timeout
+    : DEFAULT_FETCH_TIMEOUT_MS;
+}
+
+const FETCH_TIMEOUT_MS = resolveCursorFetchTimeout(process.env.VIBE_USAGE_CURSOR_FETCH_TIMEOUT_MS);
 
 async function fetchUsageCsv(token) {
   const url = `${(process.env.CURSOR_WEB_BASE_URL?.trim() || 'https://cursor.com').replace(/\/+$/, '')}/api/dashboard/export-usage-events-csv?strategy=tokens`;
@@ -190,7 +202,14 @@ export async function parse() {
     // Auth failure → bubble up so user sees they need to re-login in Cursor.
     // Tell sync.js this was not a successful empty snapshot so it preserves
     // Cursor's incremental state instead of pruning it as dead history.
-    if (err && err.skip) return { buckets: [], sessions: [], skipped: true };
+    if (err && err.skip) {
+      return {
+        buckets: [],
+        sessions: [],
+        skipped: true,
+        warnings: [`cursor: ${err.message}`],
+      };
+    }
     throw err;
   }
   const rows = parseCsv(csv);

package/src/parsers/grok.js

@@ -1,7 +1,8 @@
-import { createReadStream, existsSync, readdirSync, readFileSync } from 'node:fs';
+import { createReadStream, existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { createInterface } from 'node:readline';
 import { join } from 'node:path';
 import { findGrokDataDirs, getGrokSessionsDir } from '../tools.js';
+import { grokSessionsDir, normalizeExtraRoot } from '../extra-roots.js';
 import { aggregateToBuckets, extractSessions } from './aggregate.js';
 import { readJsonSafe, projectFromPath } from './fs-utils.js';
 
@@ -25,14 +26,14 @@ const SOURCE = 'grok';
  */
 
 /** Decode a sessions group dirname; fall back to basename after decode. */
-function projectFromGroupDir(groupName, groupPath) {
+function projectFromGroupDir(groupName, groupPath, strict = false) {
   const cwdFile = join(groupPath, '.cwd');
   if (existsSync(cwdFile)) {
     try {
       const raw = readFileSync(cwdFile, 'utf-8').trim();
       if (raw) return projectFromPath(raw);
-    } catch {
-      // ignore
+    } catch (err) {
+      if (strict) throw err;
     }
   }
   try {
@@ -115,12 +116,13 @@ function emitTurnUsage(entries, { usage, project, timestamp, fallbackModel }) {
   });
 }
 
-async function forEachJsonlLine(filePath, onLine) {
+async function forEachJsonlLine(filePath, onLine, strict = false) {
   if (!existsSync(filePath)) return;
   let stream;
   try {
     stream = createReadStream(filePath, { encoding: 'utf-8' });
-  } catch {
+  } catch (err) {
+    if (strict) throw err;
     return;
   }
 
@@ -137,7 +139,8 @@ async function forEachJsonlLine(filePath, onLine) {
       }
       onLine(obj);
     }
-  } catch {
+  } catch (err) {
+    if (strict) throw err;
     // unreadable / truncated mid-write — keep what we have
   } finally {
     rl.close();
@@ -145,14 +148,18 @@ async function forEachJsonlLine(filePath, onLine) {
   }
 }
 
-function listSessionDirs(sessionsDir) {
+function listSessionDirs(sessionsDir, strict = false) {
   const results = [];
-  if (!existsSync(sessionsDir)) return results;
+  if (!existsSync(sessionsDir)) {
+    if (strict) throw new Error(`missing sessions directory: ${sessionsDir}`);
+    return results;
+  }
 
   let groups;
   try {
     groups = readdirSync(sessionsDir, { withFileTypes: true });
-  } catch {
+  } catch (err) {
+    if (strict) throw err;
     return results;
   }
 
@@ -163,11 +170,12 @@ function listSessionDirs(sessionsDir) {
     let children;
     try {
       children = readdirSync(groupPath, { withFileTypes: true });
-    } catch {
+    } catch (err) {
+      if (strict) throw err;
       continue;
     }
 
-    const projectFallback = projectFromGroupDir(group.name, groupPath);
+    const projectFallback = projectFromGroupDir(group.name, groupPath, strict);
 
     for (const child of children) {
       if (!child.isDirectory()) continue;
@@ -194,8 +202,29 @@ function listSessionDirs(sessionsDir) {
  * Parse all Grok sessions under the configured sessions root(s).
  * @returns {Promise<{ buckets: object[], sessions: object[] }>}
  */
-export async function parse() {
-  const sessionRoots = findGrokDataDirs();
+export async function parse({ extraRoots = [] } = {}) {
+  if (!process.env.VIBE_USAGE_GROK_SESSIONS?.trim()) {
+    for (const root of extraRoots) {
+      const sessionsDir = grokSessionsDir(root);
+      try {
+        if (!statSync(sessionsDir).isDirectory()) throw new Error('not a directory');
+      } catch {
+        return {
+          buckets: [],
+          sessions: [],
+          skipped: true,
+          warnings: [`grok: 额外根目录不可用，已跳过本次 Grok 同步: ${normalizeExtraRoot(root)}`],
+        };
+      }
+    }
+  }
+  const strictRoots = process.env.VIBE_USAGE_GROK_SESSIONS?.trim()
+    ? new Set()
+    : new Set(extraRoots.map(grokSessionsDir));
+  const sessionRoots = findGrokDataDirs(extraRoots);
+  for (const configuredRoot of strictRoots) {
+    if (!sessionRoots.includes(configuredRoot)) sessionRoots.push(configuredRoot);
+  }
   // findGrokDataDirs returns sessions dirs; also allow empty → try default once
   const roots = sessionRoots.length > 0 ? sessionRoots : [getGrokSessionsDir()].filter(existsSync);
   if (roots.length === 0) return { buckets: [], sessions: [] };
@@ -203,9 +232,58 @@ export async function parse() {
   const entries = [];
   const sessionEvents = [];
 
+  const candidates = [];
   for (const sessionsDir of roots) {
-    for (const { sessionId, sessionPath, projectFallback } of listSessionDirs(sessionsDir)) {
-      const summary = readJsonSafe(join(sessionPath, 'summary.json')) || {};
+    const strict = strictRoots.has(sessionsDir);
+    try {
+      for (const session of listSessionDirs(sessionsDir, strict)) {
+        candidates.push({ ...session, strict, configuredRoot: sessionsDir });
+      }
+    } catch {
+      return {
+        buckets: [], sessions: [], skipped: true,
+        warnings: [`grok: 额外根目录读取失败，已保留上次同步数据: ${sessionsDir}`],
+      };
+    }
+  }
+
+  let sessionsToParse = candidates;
+  if (roots.length > 1) {
+    const selectedSessions = new Map();
+    for (const session of candidates) {
+      const fileSize = (name) => {
+        try {
+          return statSync(join(session.sessionPath, name)).size;
+        } catch {
+          return 0;
+        }
+      };
+      const score = [fileSize('updates.jsonl'), fileSize('events.jsonl'), fileSize('summary.json')];
+      const previous = selectedSessions.get(session.sessionId);
+      const moreComplete = !previous || score.some((value, index) => (
+        value !== previous.score[index] && value > previous.score[index]
+        && score.slice(0, index).every((prior, priorIndex) => prior === previous.score[priorIndex])
+      ));
+      if (moreComplete) selectedSessions.set(session.sessionId, { ...session, score });
+    }
+    sessionsToParse = [...selectedSessions.values()];
+  }
+
+  for (const {
+    sessionId,
+    sessionPath,
+    projectFallback,
+    strict,
+    configuredRoot,
+  } of sessionsToParse) {
+    try {
+      const summaryPath = join(sessionPath, 'summary.json');
+      let summary;
+      if (strict && existsSync(summaryPath)) {
+        summary = JSON.parse(readFileSync(summaryPath, 'utf-8'));
+      } else {
+        summary = readJsonSafe(summaryPath) || {};
+      }
       const cwd = summary.info?.cwd || summary.git_root_dir || null;
       const project = cwd ? projectFromPath(cwd) : projectFallback;
       const fallbackModel = summary.current_model_id || 'unknown';
@@ -249,7 +327,7 @@ export async function parse() {
             role: 'assistant',
           });
         }
-      });
+      }, strict);
 
       // Fallback timing from events.jsonl when updates lack message chunks
       // (short/aborted sessions, older builds).
@@ -274,7 +352,7 @@ export async function parse() {
               role: 'assistant',
             });
           }
-        });
+        }, strict);
       }
 
       // Last-resort session envelope from summary timestamps so a session with
@@ -301,6 +379,12 @@ export async function parse() {
           });
         }
       }
+    } catch (err) {
+      if (!strict) throw err;
+      return {
+        buckets: [], sessions: [], skipped: true,
+        warnings: [`grok: 额外根目录读取失败，已保留上次同步数据: ${configuredRoot}`],
+      };
     }
   }
 

package/src/parsers/index.js

@@ -20,6 +20,7 @@ import { parse as parseDsh } from './dsh.js';
 import { parse as parseAntigravity } from './antigravity.js';
 import { parse as parseHermes } from './hermes.js';
 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 parseZcode } from './zcode.js';
@@ -49,6 +50,7 @@ export const parsers = {
   'trae-cli': parseTraeCli,
   'hermes': parseHermes,
   'kiro': parseKiro,
+  'mcode': parseMcode,
   'mimocode': parseMimocode,
   'cline': parseCline,
   'roo-code': parseRooCode,

package/src/parsers/mcode.js

@@ -0,0 +1,182 @@
+import { existsSync } from 'node:fs';
+import { projectFromPath } from './fs-utils.js';
+import { aggregateToBuckets } from './aggregate.js';
+import {
+  queryDbJsonSnapshotOnLock,
+  isSqliteUnavailableError,
+  sqliteUnavailableError,
+} from './sqlite.js';
+import { getMcodeDbPath } from '../tools.js';
+
+const SOURCE = 'mcode';
+
+// Strict column allow-list. The mcode token table also stores a `raw` JSON
+// payload (and the sessions table stores `record_json` / `extra_data_json`)
+// that contains message bodies — we never select those, neither in this
+// parser nor in any test fixture.
+const TOKEN_COLUMNS = [
+  'session_id',
+  'model',
+  'ts',
+  'input_tokens',
+  'output_tokens',
+  'reasoning_tokens',
+  'cache_read_tokens',
+  'cache_write_tokens',
+];
+
+// `local_runtime_sessions` carries both `workspace_dir` (per-session scratch
+// dir, always present) and `project_workspace_dir` (the project root when one
+// is known). We pick the project column first, then the workspace, then
+// fall back to "unknown". Never read `record_json` / `extra_data_json`.
+const SESSION_COLUMNS = ['session_id', 'workspace_dir', 'project_workspace_dir'];
+
+// Keep token rows and their project metadata in one SQLite statement. Separate
+// reads can observe different WAL snapshots while mcode is writing, causing a
+// token row to be uploaded once as "unknown" and again under its real project.
+const USAGE_SQL = `
+  SELECT
+    ${TOKEN_COLUMNS.map(column => `token.${column}`).join(', ')},
+    session.workspace_dir,
+    session.project_workspace_dir
+  FROM local_runtime_token_usage AS token
+  LEFT JOIN local_runtime_sessions AS session
+    ON session.session_id = token.session_id
+`;
+
+/**
+ * Resolve the mcode runtime-state SQLite database. Mirrors the precedence used
+ * by sibling tools (MiMoCode, DimAgent): explicit env var wins, then a
+ * tool-specific HOME, then the default layout.
+ *
+ * Defaults to `<homedir()>/.minimax/v2/sqlite/runtime-state.sqlite`, which is
+ * where the mcode CLI keeps its WAL database on macOS / Linux.
+ */
+export function resolveMcodeDbPath(env = process.env) {
+  return getMcodeDbPath(env);
+}
+
+/**
+ * Token count (ms vs seconds). The mcode runtime writes ts as integer
+ * milliseconds — confirmed against the live schema (`typeof(ts)=integer`,
+ * values ≈ 1.787e12 for 2026-08-29). Stay defensive: anything < 1e12 is
+ * treated as seconds and scaled up.
+ */
+function tsToDate(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return null;
+  const ms = n < 1e12 ? n * 1000 : n;
+  const d = new Date(ms);
+  return Number.isNaN(d.getTime()) ? null : d;
+}
+
+
+
+function toNonNegative(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n < 0) return 0;
+  return n;
+}
+
+function dbHasColumns(dbPath, table, columns) {
+  const info = queryDbJsonSnapshotOnLock(
+    dbPath,
+    `PRAGMA table_info(${table})`,
+    { tempPrefix: 'vibe-usage-mcode' },
+  );
+  const present = new Set(info.map(row => String(row.name)));
+  return columns.every(col => present.has(col));
+}
+
+export async function parse() {
+  const dbPath = resolveMcodeDbPath();
+  if (!existsSync(dbPath)) return { buckets: [], sessions: [] };
+
+  // Schema guard: every allow-listed column must exist. If the mcode
+  // runtime ever renames / drops a column, fail soft (skipped) so the
+  // incremental sync keeps the last good upload state for this source.
+  let schemaOk;
+  try {
+    schemaOk =
+      dbHasColumns(dbPath, 'local_runtime_token_usage', TOKEN_COLUMNS) &&
+      dbHasColumns(dbPath, 'local_runtime_sessions', SESSION_COLUMNS);
+  } catch (err) {
+    if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('mcode');
+    return { buckets: [], sessions: [], skipped: true };
+  }
+  if (!schemaOk) {
+    return { buckets: [], sessions: [], skipped: true };
+  }
+
+  // Read tokens and session project metadata from one statement/snapshot.
+  let usageRows;
+  try {
+    usageRows = queryDbJsonSnapshotOnLock(dbPath, USAGE_SQL, {
+      tempPrefix: 'vibe-usage-mcode',
+    });
+  } catch (err) {
+    if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('mcode');
+    return { buckets: [], sessions: [], skipped: true };
+  }
+
+  const entries = [];
+
+  for (const row of usageRows) {
+    const sessionId = row.session_id != null ? String(row.session_id) : '';
+    if (!sessionId) continue;
+    const ts = tsToDate(row.ts);
+    if (!ts) continue;
+
+    // MCode stores output and reasoning as separate counters. Its own
+    // summary code computes total = input + output + reasoning, so do not
+    // subtract reasoning from output here.
+    const inputRaw = toNonNegative(row.input_tokens);
+    const cacheWrite = toNonNegative(row.cache_write_tokens);
+    const outputRaw = toNonNegative(row.output_tokens);
+    const reasoningRaw = toNonNegative(row.reasoning_tokens);
+    const cacheRead = toNonNegative(row.cache_read_tokens);
+
+    const inputTokens = inputRaw + cacheWrite;
+    const reasoningOutputTokens = reasoningRaw;
+    const outputTokens = outputRaw;
+    const cachedInputTokens = cacheRead;
+
+    if (
+      inputTokens +
+        outputTokens +
+        cachedInputTokens +
+        reasoningOutputTokens ===
+      0
+    ) {
+      continue;
+    }
+
+    const projectPath = row.project_workspace_dir || row.workspace_dir;
+    const project = projectPath ? projectFromPath(String(projectPath)) : 'unknown';
+    const model = row.model != null && String(row.model).trim()
+      ? String(row.model).trim()
+      : 'unknown';
+
+    entries.push({
+      source: SOURCE,
+      model,
+      project,
+      timestamp: ts,
+      inputTokens,
+      outputTokens,
+      cachedInputTokens,
+      reasoningOutputTokens,
+    });
+  }
+
+  return {
+    buckets: aggregateToBuckets(entries),
+    // The token ledger contains assistant usage rows only. Reconstructing
+    // user prompts would require reading message payloads, which this parser
+    // deliberately never selects, so mcode emits buckets only like Alma.
+    sessions: [],
+  };
+}
+
+// Re-export for tests / external consumers.
+export { SOURCE as MCODE_SOURCE };

package/src/parsers/pi-coding-agent.js

@@ -1,12 +1,27 @@
+import { normalizeExtraRoot, piSessionsDir } from '../extra-roots.js';
 import { getPiSessionDirs } from '../pi-roots.js';
 import { mergeCindyHarnessUsage, readCindyHarnessUsage } from './cindy-ledger.js';
 import { parsePiSessionJsonl } from './pi-session-jsonl.js';
 
 /** Parse the official Pi agent's Pi-compatible JSONL sessions. */
-export async function parse() {
+export async function parse({ extraRoots = [] } = {}) {
+  for (const root of extraRoots) {
+    // piSessionsDir re-resolves the root's shape, so an agent home that lost
+    // its `sessions/` child is caught here too, not just a root that vanished.
+    if (piSessionsDir(root) !== null) continue;
+    // An explicitly configured root that is momentarily unreadable is not
+    // proof that its usage disappeared, so skip instead of reporting empty.
+    return {
+      buckets: [],
+      sessions: [],
+      skipped: true,
+      warnings: [`pi-coding-agent: 额外根目录不可用，已跳过本次 Pi 同步: ${normalizeExtraRoot(root)}`],
+    };
+  }
+
   const nativeResult = await parsePiSessionJsonl({
     source: 'pi-coding-agent',
-    sessionsDirs: getPiSessionDirs(),
+    sessionsDirs: getPiSessionDirs(extraRoots),
   });
   return mergeCindyHarnessUsage(nativeResult, readCindyHarnessUsage('pi'));
 }

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

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { existsSync, 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';
@@ -38,6 +38,19 @@ export function projectFromFirstDir(filePath, sessionsDir) {
   return first.split('-').filter(Boolean).at(-1) || 'unknown';
 }
 
+// Configured stores can overlap: an ancestor and its descendant, or two paths
+// that resolve to the same place through a symlink. Record-level dedup only
+// covers entries carrying an `id`, so the same anonymous record would be
+// counted once per path that reaches it. Collapse on the canonical file path
+// instead, which also folds symlinked duplicates of a single file.
+function canonicalFilePath(filePath) {
+  try {
+    return realpathSync.native(filePath);
+  } catch {
+    return filePath;
+  }
+}
+
 export async function parsePiSessionJsonl({
   source,
   sessionsDirs,
@@ -49,9 +62,14 @@ export async function parsePiSessionJsonl({
   const anonymousEntries = [];
   const eventsById = new Map();
   const anonymousEvents = [];
+  const seenFiles = new Set();
 
   for (const sessionsDir of sessionsDirs) {
     for (const filePath of findJsonlFiles(sessionsDir, includeFile, ctx)) {
+      const canonical = canonicalFilePath(filePath);
+      if (seenFiles.has(canonical)) continue;
+      seenFiles.add(canonical);
+
       let content;
       try {
         content = readFileSync(filePath, 'utf8');
@@ -99,7 +117,10 @@ export async function parsePiSessionJsonl({
         if (message.role !== 'assistant' || !message.usage) continue;
         const usage = message.usage;
         const inputTokens = toCount(usage.input) + toCount(usage.cacheWrite);
-        const reasoningOutputTokens = toCount(usage.reasoningTokens);
+        // Pi's Usage type names this field `reasoning` (a documented subset of
+        // `output`); older/adjacent stores wrote `reasoningTokens`. Reading only
+        // the latter left every Pi reasoning token inside outputTokens.
+        const reasoningOutputTokens = toCount(usage.reasoning ?? usage.reasoningTokens);
         // OMP/Pi usage.output includes reasoning; the shared bucket contract
         // stores non-reasoning output and reasoning separately.
         const outputTokens = Math.max(0, toCount(usage.output) - reasoningOutputTokens);