@vibe-cafe/vibe-usage 0.10.18 → 0.10.20

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-session-jsonl.js

@@ -99,7 +99,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);

package/src/pi-roots.js

@@ -1,5 +1,5 @@
-import { existsSync, readdirSync } from 'node:fs';
-import { delimiter, join } from 'node:path';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { delimiter, isAbsolute, join } from 'node:path';
 import { homedir } from 'node:os';
 
 function expandHome(value) {
@@ -41,18 +41,41 @@ export function looksLikeOmpAgentDir(agentDir) {
     || existsSync(join(agentDir, 'agent.db'));
 }
 
+// Pi resolves a session directory from `--session-dir`, then
+// PI_CODING_AGENT_SESSION_DIR, then `sessionDir` in settings.json. Only the
+// last two are discoverable after the fact, and both name the sessions
+// directory itself (no `sessions` segment is appended).
+function settingsSessionDir(agentDir) {
+  try {
+    const raw = readFileSync(join(agentDir, 'settings.json'), 'utf-8');
+    const value = JSON.parse(raw)?.sessionDir;
+    if (typeof value !== 'string') return null;
+    const trimmed = value.trim();
+    // Pi also accepts project-relative values. Those resolve against a cwd we
+    // do not have here, so only absolute and ~-anchored paths are scanned.
+    if (!trimmed || !(isAbsolute(trimmed) || trimmed.startsWith('~'))) return null;
+    return expandHome(trimmed);
+  } catch {
+    return null;
+  }
+}
+
 export function getPiSessionDirs() {
   const override = process.env.VIBE_USAGE_PI_SESSION_DIRS?.trim();
   if (override) return uniqueExistingDirs(override.split(delimiter));
 
-  const agentDir = process.env.PI_CODING_AGENT_DIR?.trim();
-  if (agentDir) {
-    const expanded = expandHome(agentDir);
-    // OMP inherits PI_CODING_AGENT_DIR from Pi. Do not parse an identifiable
-    // OMP store again as source=pi-coding-agent.
-    return looksLikeOmpAgentDir(expanded) ? [] : uniqueExistingDirs([join(expanded, 'sessions')]);
-  }
-  return uniqueExistingDirs([join(homedir(), '.pi', 'agent', 'sessions')]);
+  const envAgentDir = process.env.PI_CODING_AGENT_DIR?.trim();
+  const agentDir = envAgentDir ? expandHome(envAgentDir) : join(homedir(), '.pi', 'agent');
+  // OMP inherits PI_CODING_AGENT_DIR from Pi. Do not parse an identifiable
+  // OMP store again as source=pi-coding-agent.
+  if (envAgentDir && looksLikeOmpAgentDir(agentDir)) return [];
+
+  const dirs = [join(agentDir, 'sessions')];
+  const envSessionDir = process.env.PI_CODING_AGENT_SESSION_DIR?.trim();
+  if (envSessionDir) dirs.push(expandHome(envSessionDir));
+  const configured = settingsSessionDir(agentDir);
+  if (configured) dirs.push(configured);
+  return uniqueExistingDirs(dirs);
 }
 
 export function getOmpSessionDirs() {

package/src/sync.js

@@ -9,6 +9,7 @@ import { createSyncClient, forBatch } from './client-meta.js';
 import { parsers } from './parsers/index.js';
 import { aggregateToBuckets } from './parsers/aggregate.js';
 import { normalizeParserResult } from './parsers/contract.js';
+import { extraRootList } from './extra-roots.js';
 import { success, failure, warn, arrow, link, dim } from './output.js';
 
 const BATCH_SIZE = 100;
@@ -20,6 +21,12 @@ function formatBytes(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
 }
 
+/** Hide only Cursor's intentional transient fetch soft-skip in quiet (daemon) syncs. */
+export function shouldSuppressParserWarning(source, message, quiet) {
+  if (!quiet) return false;
+  return source === 'cursor' && message.startsWith('cursor: Cursor usage export skipped (');
+}
+
 export function resolveUploadProjectSetting(settings) {
   if (typeof settings?.uploadProject !== 'boolean') {
     const error = new Error('SETTINGS_UNAVAILABLE');
@@ -147,9 +154,12 @@ export async function runSync({
     PARSER_CONCURRENCY,
     async ([source, parse]) => {
       try {
-        const result = source === 'codex'
-          ? await parse({ codexExtraHome: resolveCodexExtraHome(config.codexExtraHome, codexExtraHome) })
-          : await parse();
+        const result = await parse({
+          extraRoots: extraRootList(config.extraRoots?.[source]),
+          ...(source === 'codex' ? {
+            codexExtraHome: resolveCodexExtraHome(config.codexExtraHome, codexExtraHome),
+          } : {}),
+        });
         return { source, result };
       } catch (err) {
         return { source, error: err };
@@ -175,6 +185,7 @@ export async function runSync({
       parserProgress.push({ source, ...indexing });
     }
     for (const message of warnings) {
+      if (shouldSuppressParserWarning(source, message, quiet)) continue;
       process.stderr.write(`${dim(`  ${message}`)}\n`);
     }
     // A parser may deliberately suppress a transient error (Cursor network

package/src/tools.js

@@ -1,9 +1,15 @@
 import { existsSync, readdirSync, statSync } from 'node:fs';
-import { isAbsolute, join, posix, resolve, win32 } from 'node:path';
+import { dirname, isAbsolute, join, posix, resolve, win32 } from 'node:path';
 import { homedir } from 'node:os';
 import { findClaudeCodeDataDirs } from './claude-roots.js';
 import { findCindyDataDirs, getCindyDataRoots } from './cindy-roots.js';
 import { codexSessionDirs, resolveCodexHomes } from './codex-roots.js';
+import {
+  antigravityConversationDirs,
+  discoverCodexHomes,
+  extraRootList,
+  grokSessionsDir,
+} from './extra-roots.js';
 import { findClineDataDirs } from './cline-roots.js';
 import { findCraftDataDirs } from './craft-roots.js';
 import { findOmpDataDirs, findPiDataDirs } from './pi-roots.js';
@@ -106,8 +112,9 @@ function findOpenclawDataDirs() {
 // Codex keeps live sessions in ~/.codex/sessions and moves completed ones to
 // ~/.codex/archived_sessions. Detect Codex if either dir exists, so a user
 // whose sessions have all been archived is still recognized.
-export function findCodexDataDirs(codexExtraHome) {
-  return resolveCodexHomes(codexExtraHome)
+export function findCodexDataDirs(codexExtraHome, extraRoots = []) {
+  const configuredHomes = extraRoots.flatMap(root => discoverCodexHomes(root).homes);
+  return [...new Set([...resolveCodexHomes(codexExtraHome), ...configuredHomes])]
     .flatMap(codexSessionDirs)
     .filter(existsSync);
 }
@@ -143,6 +150,17 @@ export function findDshDataDirs() {
   return [getDshSessionsDir()].filter(existsSync);
 }
 
+/** mcode runtime database: VIBE_USAGE_MCODE_DB wins, then MCODE_HOME, then ~/.minimax. */
+export function getMcodeDbPath(env = process.env, home = homedir()) {
+  const override = env.VIBE_USAGE_MCODE_DB?.trim();
+  if (override) return isAbsolute(override) ? override : resolve(override);
+  if (env.MCODE_HOME && !isAbsolute(env.MCODE_HOME)) {
+    throw new Error(`MCODE_HOME must be an absolute path, got: ${JSON.stringify(env.MCODE_HOME)}`);
+  }
+  const root = env.MCODE_HOME || join(home, '.minimax');
+  return join(root, 'v2', 'sqlite', 'runtime-state.sqlite');
+}
+
 export function getMimocodeDbPath(env = process.env) {
   if (env.MIMOCODE_HOME && !isAbsolute(env.MIMOCODE_HOME)) {
     throw new Error(`MIMOCODE_HOME must be an absolute path, got: ${JSON.stringify(env.MIMOCODE_HOME)}`);
@@ -154,11 +172,12 @@ export function getMimocodeDbPath(env = process.env) {
   return isAbsolute(env.MIMOCODE_DB) ? env.MIMOCODE_DB : join(dataDir, env.MIMOCODE_DB);
 }
 
-function findAntigravityDataDirs() {
-  return [
+export function findAntigravityDataDirs(extraRoots = []) {
+  return [...new Set([
     join(homedir(), '.gemini', 'antigravity'),
     join(homedir(), '.gemini', 'antigravity-cli'),
-  ].filter(existsSync);
+    ...extraRoots.flatMap(root => antigravityConversationDirs(root).map(dirname)),
+  ])].filter(existsSync);
 }
 
 export function findTraeCliDataDirs() {
@@ -193,10 +212,13 @@ export function getGrokSessionsDir() {
 }
 
 // Detect Grok when sessions/ exists under GROK_HOME (or the test override).
-export function findGrokDataDirs() {
+export function findGrokDataDirs(extraRoots = []) {
   const testDir = process.env.VIBE_USAGE_GROK_SESSIONS?.trim();
   if (testDir) return [testDir].filter(existsSync);
-  return [join(getGrokHome(), 'sessions')].filter(existsSync);
+  return [...new Set([
+    join(getGrokHome(), 'sessions'),
+    ...extraRoots.map(grokSessionsDir),
+  ])].filter(existsSync);
 }
 
 export function getDimAgentDbPath() {
@@ -240,13 +262,15 @@ export const TOOLS = [
     name: 'Codex CLI',
     id: 'codex',
     dataDir: join(homedir(), '.codex', 'sessions'),
-    detectDataDirs: ({ codexExtraHome } = {}) => findCodexDataDirs(codexExtraHome),
+    detectDataDirs: ({ codexExtraHome, extraRoots } = {}) => (
+      findCodexDataDirs(codexExtraHome, extraRootList(extraRoots?.codex))
+    ),
   },
   {
     name: 'Grok',
     id: 'grok',
     dataDir: join(homedir(), '.grok', 'sessions'),
-    detectDataDirs: findGrokDataDirs,
+    detectDataDirs: ({ extraRoots } = {}) => findGrokDataDirs(extraRootList(extraRoots?.grok)),
   },
   {
     name: 'GitHub Copilot CLI',
@@ -311,6 +335,12 @@ export const TOOLS = [
     dataDir: join(homedir(), '.kimi-code', 'sessions'),
     detectDataDirs: findKimiCodeDataDirs,
   },
+  {
+    name: 'MiniMax Code',
+    id: 'mcode',
+    dataDir: join(homedir(), '.minimax', 'v2', 'sqlite', 'runtime-state.sqlite'),
+    detectDataDirs: () => [getMcodeDbPath()].filter(existsSync),
+  },
   {
     name: 'MiMoCode',
     id: 'mimocode',
@@ -337,7 +367,9 @@ export const TOOLS = [
     name: 'Antigravity',
     id: 'antigravity',
     dataDir: join(homedir(), '.gemini', 'antigravity'),
-    detectDataDirs: findAntigravityDataDirs,
+    detectDataDirs: ({ extraRoots } = {}) => (
+      findAntigravityDataDirs(extraRootList(extraRoots?.antigravity))
+    ),
   },
   {
     name: 'Trae CLI',