@vibe-cafe/vibe-usage 0.10.19 → 0.10.21

package/src/extra-roots.js

@@ -0,0 +1,312 @@
+import { accessSync, closeSync, constants, openSync, readSync, readdirSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, join, resolve } from 'node:path';
+import { codexSessionDirs } from './codex-roots.js';
+
+export const EXTRA_ROOT_SOURCES = ['antigravity', 'codex', 'grok', 'pi-coding-agent'];
+
+// Probing a candidate Pi store has three outcomes, never two: a confirmed
+// session, a directory proven to hold none, and one that could not be read.
+// Collapsing the last two into a single false is what let an unreadable subtree
+// be treated as an empty one.
+const PI_SESSIONS_FOUND = 'found';
+const PI_SESSIONS_ABSENT = 'absent';
+const PI_SESSIONS_UNREADABLE = 'unreadable';
+
+export function extraRootList(value) {
+  return Array.isArray(value) ? value.filter(root => typeof root === 'string' && root.trim()) : [];
+}
+
+export function normalizeExtraRoot(value) {
+  const trimmed = value.trim();
+  if (trimmed === '~') return homedir();
+  if (trimmed.startsWith('~/') || trimmed.startsWith('~\\')) {
+    return resolve(homedir(), trimmed.slice(2));
+  }
+  return resolve(trimmed);
+}
+
+function isReadableDirectory(path) {
+  try {
+    if (!statSync(path).isDirectory()) return false;
+    accessSync(path, constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isCodexHome(path) {
+  return isReadableDirectory(path) && codexSessionDirs(path).some(isReadableDirectory);
+}
+
+// Multica stores task-local Codex homes below a bounded
+// <container>/<workspace>/<task>/codex-home hierarchy. Do not follow symlinks
+// or descend beyond that shape: configured containers may also contain large
+// workdirs that are unrelated to usage logs.
+export function discoverCodexHomes(value, maxDepth = 3) {
+  const root = normalizeExtraRoot(value);
+  if (isCodexHome(root)) return { root, homes: [root], readable: true };
+  if (!isReadableDirectory(root)) return { root, homes: [], readable: false };
+
+  const homes = [];
+  const queue = [{ path: root, depth: 0 }];
+  let readable = true;
+  while (queue.length > 0) {
+    const current = queue.shift();
+    let children;
+    try {
+      children = readdirSync(current.path, { withFileTypes: true });
+    } catch {
+      readable = false;
+      continue;
+    }
+    for (const child of children) {
+      // Dirent#isDirectory is false for symbolic links, so traversal stays
+      // inside the explicitly selected tree.
+      if (!child.isDirectory()) continue;
+      const childPath = join(current.path, child.name);
+      const depth = current.depth + 1;
+      if (basename(childPath) === 'codex-home' && isCodexHome(childPath)) {
+        homes.push(childPath);
+        continue;
+      }
+      if (depth < maxDepth) queue.push({ path: childPath, depth });
+    }
+  }
+  return { root, homes: [...new Set(homes)], readable };
+}
+
+export function grokSessionsDir(value) {
+  return join(normalizeExtraRoot(value), 'sessions');
+}
+
+export function antigravityConversationDirs(value) {
+  const root = normalizeExtraRoot(value);
+  return [
+    join(root, '.gemini', 'antigravity', 'conversations'),
+    join(root, '.gemini', 'antigravity-cli', 'conversations'),
+  ];
+}
+
+// Pi's own discoverable settings (PI_CODING_AGENT_SESSION_DIR, `sessionDir` in
+// settings.json) name a sessions directory directly, and a harness that calls
+// `pi --session <file>` writes bare session trees with no agent home above
+// them. Accept either shape, but resolve to exactly one directory per root:
+// the parser walks nested directories, so returning both a root and its
+// `sessions/` child would read every file twice. Canonical-path dedup in the
+// parser makes the overlap harmless even for a mixed root that holds sessions
+// directly *and* under `sessions/`.
+//
+// Every candidate is confirmed by content, never by name alone. A readable but
+// unconfirmed `sessions/` child used to win unconditionally, so creating an
+// empty `<root>/sessions` was enough to redirect the scan away from a bare
+// store's own files — a successful sync reporting zero, which then pruned the
+// source's incremental state.
+//
+// The shape is re-resolved on every run rather than remembered from add-root
+// time, and an unresolvable root returns null instead of falling back to the
+// root itself. Falling back would turn an agent home that lost its `sessions/`
+// child into a readable directory holding no sessions, i.e. exactly the silent
+// zero this feature exists to prevent.
+//
+// Probing is tri-state on purpose. A boolean collapsed "holds no sessions" into
+// "could not be read", so making one sibling store unreadable was enough to
+// make a container look like an agent home and narrow the scan to `sessions/`,
+// dropping every readable sibling with no `skipped` flag. Absence has to be
+// proven; where it is only assumed, resolution gives up and the caller skips.
+export function piSessionsDir(value) {
+  const root = normalizeExtraRoot(value);
+  if (!isReadableDirectory(root)) return null;
+  // A bare store is identified by the session files it holds directly, and
+  // outranks any `sessions/` child: those files are what the user configured.
+  const direct = probePiSessions(root, 0);
+  if (direct === PI_SESSIONS_FOUND) return root;
+
+  const outside = probePiSessionsOutsideNested(root);
+  // Both decisions below rest on absence: that the root holds no sessions
+  // directly, and that no sibling of `sessions/` holds any. An unreadable
+  // candidate proves neither, so stop rather than narrow past it.
+  if (direct === PI_SESSIONS_UNREADABLE || outside === PI_SESSIONS_UNREADABLE) return null;
+
+  const nested = join(root, 'sessions');
+  // Agent-home shape: narrowing to the child is only safe when every confirmed
+  // session lives below it. A container whose per-task stores happen to include
+  // one named `sessions` is still a container, and resolving it to that child
+  // would drop all its siblings — the same silent undercount as above.
+  if (
+    outside === PI_SESSIONS_ABSENT
+    && isReadableDirectory(nested)
+    && probePiSessions(nested) === PI_SESSIONS_FOUND
+  ) {
+    return nested;
+  }
+  // A configured container holding per-task stores somewhere below it. Anything
+  // else — no sessions at all, or a subtree that could not be read — resolves
+  // to null, which the parser reports as skipped instead of as an empty sync.
+  return probePiSessions(root) === PI_SESSIONS_FOUND ? root : null;
+}
+
+// Confirmed sessions in some child other than `sessions/`. The per-child depth
+// is one less than the root scan's own so both reach the same files.
+function probePiSessionsOutsideNested(root) {
+  let children;
+  try {
+    children = readdirSync(root, { withFileTypes: true });
+  } catch {
+    return PI_SESSIONS_UNREADABLE;
+  }
+  let unreadable = false;
+  for (const child of children) {
+    if (!child.isDirectory() || child.name === 'sessions') continue;
+    const probe = probePiSessions(join(root, child.name), 1);
+    if (probe === PI_SESSIONS_FOUND) return PI_SESSIONS_FOUND;
+    if (probe === PI_SESSIONS_UNREADABLE) unreadable = true;
+  }
+  return unreadable ? PI_SESSIONS_UNREADABLE : PI_SESSIONS_ABSENT;
+}
+
+const PI_PROBE_BYTES = 16 * 1024;
+const PI_PROBE_LINES = 10;
+// Roles the Pi parser turns into events; anything else contributes nothing.
+const PI_MESSAGE_ROLES = new Set(['user', 'assistant', 'toolResult']);
+
+function isNonEmptyString(value) {
+  return typeof value === 'string' && value.trim() !== '';
+}
+
+// Pi's session format opens a store with a full SessionHeader. `version` is
+// written as both a number and a string across real stores, so only its
+// presence is required.
+function isPiSessionHeader(obj) {
+  return obj.type === 'session'
+    && obj.version !== undefined
+    && obj.version !== null
+    && isNonEmptyString(obj.id)
+    && isNonEmptyString(obj.timestamp)
+    && typeof obj.cwd === 'string';
+}
+
+// A store an external harness appends to may carry no header inside the probed
+// prefix, so a message record alone can confirm the directory — but only a
+// complete one. Matching on `type` and an object-valued `message` accepted
+// `{"type":"message","message":{}}`, which the parser reads to exactly zero.
+function isPiSessionMessage(obj) {
+  return obj.type === 'message'
+    && isNonEmptyString(obj.id)
+    && 'parentId' in obj
+    && isNonEmptyString(obj.timestamp)
+    && Boolean(obj.message)
+    && typeof obj.message === 'object'
+    && PI_MESSAGE_ROLES.has(obj.message.role);
+}
+
+// A `.jsonl` extension proves nothing: an unrelated log would validate an
+// entirely wrong directory, which the parser then ignores without complaining.
+// Neither does a bare `type` name — validation has to require the fields the
+// parser reads, or a malformed lookalike is accepted and still syncs zero.
+// A file that cannot be opened is reported as unreadable, not as "not a
+// session": it may well be the store the user configured.
+function probePiSessionFile(filePath) {
+  let text;
+  let fd;
+  try {
+    fd = openSync(filePath, 'r');
+    const buffer = Buffer.alloc(PI_PROBE_BYTES);
+    const read = readSync(fd, buffer, 0, PI_PROBE_BYTES, 0);
+    text = buffer.subarray(0, read).toString('utf8');
+    // A prefix read can cut the final line in half; drop the partial tail.
+    if (read === PI_PROBE_BYTES) text = text.slice(0, text.lastIndexOf('\n') + 1);
+  } catch {
+    return PI_SESSIONS_UNREADABLE;
+  } finally {
+    if (fd !== undefined) {
+      try {
+        closeSync(fd);
+      } catch { /* already closed */ }
+    }
+  }
+
+  let checked = 0;
+  for (const line of text.split('\n')) {
+    if (!line.trim()) continue;
+    if (++checked > PI_PROBE_LINES) return PI_SESSIONS_ABSENT;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!obj || typeof obj !== 'object') continue;
+    if (isPiSessionHeader(obj) || isPiSessionMessage(obj)) return PI_SESSIONS_FOUND;
+  }
+  return PI_SESSIONS_ABSENT;
+}
+
+// A session store is only recognizable by the Pi session files in it. Stay
+// shallow: a configured root may sit next to large unrelated trees.
+//
+// `found` outranks `unreadable`: one confirmed session is enough to resolve the
+// shape, and the shared parser reports whatever it cannot read on the way in.
+// `unreadable` outranks `absent`, so a caller never mistakes a subtree it could
+// not open for one it proved empty.
+function probePiSessions(dir, depth = 2) {
+  let children;
+  try {
+    children = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return PI_SESSIONS_UNREADABLE;
+  }
+  let unreadable = false;
+  // Dirent#isDirectory is false for symbolic links, matching the parser's own
+  // walk: linked session files are read, linked directories are not entered.
+  for (const child of children) {
+    if (child.isDirectory() || !child.name.endsWith('.jsonl')) continue;
+    const probe = probePiSessionFile(join(dir, child.name));
+    if (probe === PI_SESSIONS_FOUND) return PI_SESSIONS_FOUND;
+    if (probe === PI_SESSIONS_UNREADABLE) unreadable = true;
+  }
+  if (depth > 0) {
+    for (const child of children) {
+      if (!child.isDirectory()) continue;
+      const probe = probePiSessions(join(dir, child.name), depth - 1);
+      if (probe === PI_SESSIONS_FOUND) return PI_SESSIONS_FOUND;
+      if (probe === PI_SESSIONS_UNREADABLE) unreadable = true;
+    }
+  }
+  return unreadable ? PI_SESSIONS_UNREADABLE : PI_SESSIONS_ABSENT;
+}
+
+export function validateExtraRoot(source, value) {
+  if (!EXTRA_ROOT_SOURCES.includes(source)) {
+    return { ok: false, path: value, reason: `不支持的工具: ${source}` };
+  }
+  const path = normalizeExtraRoot(value);
+  if (source === 'codex') {
+    const result = discoverCodexHomes(path);
+    return {
+      ok: result.readable && result.homes.length > 0,
+      path,
+      reason: '需要是 Codex Home，或包含 */*/codex-home 的 Multica 容器',
+    };
+  }
+  if (source === 'pi-coding-agent') {
+    // piSessionsDir only returns a directory it has already confirmed by
+    // content, so there is nothing left to re-check here.
+    return {
+      ok: piSessionsDir(path) !== null,
+      path,
+      reason: '需要是直接包含 Pi 会话 .jsonl 的目录，或包含 sessions/ 的 Pi agent 目录',
+    };
+  }
+  const dirs = source === 'grok'
+    ? [grokSessionsDir(path)]
+    : antigravityConversationDirs(path);
+  return {
+    ok: dirs.some(isReadableDirectory),
+    path,
+    reason: source === 'grok'
+      ? '需要包含 sessions/'
+      : '需要包含 .gemini/antigravity*/conversations/',
+  };
+}

package/src/index.js

@@ -2,6 +2,12 @@ import { loadConfig, saveConfig, getConfigPath } from './config.js';
 import { detectInstalledTools, TOOLS } from './tools.js';
 import { existsSync } from 'node:fs';
 import { validateExtraCodexHome } from './codex-roots.js';
+import {
+  EXTRA_ROOT_SOURCES,
+  extraRootList,
+  normalizeExtraRoot,
+  validateExtraRoot,
+} from './extra-roots.js';
 import { failure, smallHeader } from './output.js';
 
 function printSmallHeader() {
@@ -24,10 +30,18 @@ async function showStatus() {
     if (config.codexExtraHome) {
       console.log(`  Extra Codex Home: ${config.codexExtraHome}`);
     }
+    for (const source of EXTRA_ROOT_SOURCES) {
+      for (const root of extraRootList(config.extraRoots?.[source])) {
+        console.log(`  Extra ${source} Root: ${root}`);
+      }
+    }
   }
 
   console.log('\n  Detected tools:');
-  const toolOptions = { codexExtraHome: config?.codexExtraHome };
+  const toolOptions = {
+    codexExtraHome: config?.codexExtraHome,
+    extraRoots: config?.extraRoots,
+  };
   const detected = detectInstalledTools(toolOptions);
   if (detected.length === 0) {
     console.log('    (none)\n');
@@ -103,9 +117,59 @@ function handleConfig(args) {
       }
       break;
     }
+    case 'add-root': {
+      const source = args[1];
+      const value = args[2];
+      if (!source || value === undefined) {
+        console.error(`Usage: vibe-usage config add-root <${EXTRA_ROOT_SOURCES.join('|')}> <path>`);
+        process.exit(1);
+      }
+      const validation = validateExtraRoot(source, value);
+      if (!validation.ok) {
+        console.error(failure(`额外 ${source} 根目录无效（${validation.reason}）: ${validation.path}`));
+        process.exit(1);
+      }
+      const config = loadConfig() || {};
+      if (!config.extraRoots || typeof config.extraRoots !== 'object' || Array.isArray(config.extraRoots)) {
+        config.extraRoots = {};
+      }
+      const roots = extraRootList(config.extraRoots[source]);
+      config.extraRoots[source] = [...new Set([...roots, validation.path])];
+      saveConfig(config);
+      break;
+    }
+    case 'remove-root': {
+      const source = args[1];
+      const value = args[2];
+      if (!EXTRA_ROOT_SOURCES.includes(source) || value === undefined) {
+        console.error(`Usage: vibe-usage config remove-root <${EXTRA_ROOT_SOURCES.join('|')}> <path>`);
+        process.exit(1);
+      }
+      const config = loadConfig() || {};
+      const path = normalizeExtraRoot(value);
+      const roots = extraRootList(config.extraRoots?.[source])
+        .filter(root => normalizeExtraRoot(root) !== path);
+      if (config.extraRoots && typeof config.extraRoots === 'object' && !Array.isArray(config.extraRoots)) {
+        if (roots.length > 0) config.extraRoots[source] = roots;
+        else delete config.extraRoots[source];
+        if (Object.keys(config.extraRoots).length === 0) delete config.extraRoots;
+      }
+      saveConfig(config);
+      break;
+    }
+    case 'roots': {
+      const config = loadConfig();
+      const roots = config?.extraRoots;
+      console.log(JSON.stringify(
+        roots && typeof roots === 'object' && !Array.isArray(roots) ? roots : {},
+        null,
+        2,
+      ));
+      break;
+    }
     default:
       console.error(`Unknown config subcommand: ${sub || '(none)'}`);
-      console.error('Usage: vibe-usage config <get|set|show>');
+      console.error('Usage: vibe-usage config <get|set|show|add-root|remove-root|roots>');
       process.exit(1);
   }
 }
@@ -219,7 +283,7 @@ export async function run(rawArgs) {
     npx @vibe-cafe/vibe-usage summary       Print last 7 days as markdown (cost/tokens/model/project)
     npx @vibe-cafe/vibe-usage summary --days N   Same, but 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)
+    npx @vibe-cafe/vibe-usage daemon install    Install background service (systemd/launchd/Task Scheduler)
     npx @vibe-cafe/vibe-usage daemon uninstall  Remove background service
     npx @vibe-cafe/vibe-usage daemon status     Show background service status
     npx @vibe-cafe/vibe-usage daemon stop       Stop background service
@@ -233,6 +297,9 @@ export async function run(rawArgs) {
     npx @vibe-cafe/vibe-usage config get <key>   Get a config value
     npx @vibe-cafe/vibe-usage config set <key> <value>  Set a config value
     npx @vibe-cafe/vibe-usage config set codexExtraHome <path>  Persist another Codex Home
+    npx @vibe-cafe/vibe-usage config add-root <tool> <path>  Add a Codex, Grok, Antigravity, or Pi data root
+    npx @vibe-cafe/vibe-usage config remove-root <tool> <path>  Remove an added data root
+    npx @vibe-cafe/vibe-usage config roots  Show added data roots as JSON
     npx @vibe-cafe/vibe-usage help         Show this help
 `);
       break;

package/src/init.js

@@ -27,7 +27,7 @@ function openBrowser(url) {
 }
 
 function isDaemonPlatform() {
-  return process.platform === 'linux' || process.platform === 'darwin';
+  return process.platform === 'linux' || process.platform === 'darwin' || process.platform === 'win32';
 }
 
 export async function runInit(options = {}) {
@@ -81,10 +81,14 @@ export async function runInit(options = {}) {
     apiUrl,
     hostname: host,
     ...(existing?.codexExtraHome ? { codexExtraHome: existing.codexExtraHome } : {}),
+    ...(existing?.extraRoots ? { extraRoots: existing.extraRoots } : {}),
   };
   saveConfig(config);
 
-  const tools = detectInstalledTools({ codexExtraHome: config.codexExtraHome });
+  const tools = detectInstalledTools({
+    codexExtraHome: config.codexExtraHome,
+    extraRoots: config.extraRoots,
+  });
   if (tools.length > 0) {
     console.log(success(`检测到 ${tools.length} 款工具: ${dim(tools.map(t => t.name).join(' · '))}`));
   } else {

package/src/parsers/antigravity-db.js

@@ -200,14 +200,15 @@ function queryCascadeDb(conversationsDir, cascadeId, sql) {
 }
 
 /** List cascade IDs backed by a `.db` file in a conversations directory. */
-export function listDbCascades(conversationsDir) {
+export function listDbCascades(conversationsDir, { strict = false } = {}) {
   try {
     const out = [];
     for (const f of readdirSync(conversationsDir)) {
       if (f.endsWith('.db') && f !== 'db.sqlite') out.push(f.slice(0, -3));
     }
     return out;
-  } catch {
+  } catch (err) {
+    if (strict) throw err;
     return [];
   }
 }
@@ -217,12 +218,12 @@ export function listDbCascades(conversationsDir) {
  * records. blob is fetched as hex text so it round-trips through both the
  * node:sqlite and sqlite3-CLI backends uniformly.
  */
-export function readDbUsageRecords(conversationsDir, cascadeId) {
+export function readDbUsageRecords(conversationsDir, cascadeId, { strict = false } = {}) {
   let rows;
   try {
     rows = queryCascadeDb(conversationsDir, cascadeId, 'SELECT idx, hex(data) AS h FROM gen_metadata ORDER BY idx');
   } catch (err) {
-    if (isSqliteUnavailableError(err)) throw err;
+    if (isSqliteUnavailableError(err) || strict) throw err;
     return [];
   }
   const records = [];
@@ -247,7 +248,7 @@ export function readDbUsageRecords(conversationsDir, cascadeId) {
  * system/tool steps that parseStepMetadata skips. Used to timestamp 3.7
  * gen_metadata rows that no longer embed chatStartMetadata.
  */
-export function readDbStepTimestamps(conversationsDir, cascadeId) {
+export function readDbStepTimestamps(conversationsDir, cascadeId, { strict = false } = {}) {
   let rows;
   try {
     rows = queryCascadeDb(
@@ -256,7 +257,7 @@ export function readDbStepTimestamps(conversationsDir, cascadeId) {
       'SELECT idx, hex(metadata) AS h FROM steps WHERE metadata IS NOT NULL ORDER BY idx',
     );
   } catch (err) {
-    if (isSqliteUnavailableError(err)) throw err;
+    if (isSqliteUnavailableError(err) || strict) throw err;
     return new Map();
   }
   const byIdx = new Map();
@@ -331,7 +332,7 @@ export function parseStepMetadata(buf) {
  * Read session timing events (user/assistant turns) for a cascade from the
  * steps table, chronological by idx.
  */
-export function readDbSessionEvents(conversationsDir, cascadeId) {
+export function readDbSessionEvents(conversationsDir, cascadeId, { strict = false } = {}) {
   let rows;
   try {
     rows = queryCascadeDb(
@@ -340,7 +341,7 @@ export function readDbSessionEvents(conversationsDir, cascadeId) {
       'SELECT hex(metadata) AS h FROM steps WHERE metadata IS NOT NULL ORDER BY idx',
     );
   } catch (err) {
-    if (isSqliteUnavailableError(err)) throw err;
+    if (isSqliteUnavailableError(err) || strict) throw err;
     return [];
   }
   const events = [];

package/src/parsers/antigravity.js

@@ -1,7 +1,8 @@
 import { execSync } from 'node:child_process';
-import { readdirSync } from 'node:fs';
-import { join } from 'node:path';
+import { readdirSync, statSync } from 'node:fs';
+import { delimiter, join } from 'node:path';
 import { homedir } from 'node:os';
+import { antigravityConversationDirs, normalizeExtraRoot } from '../extra-roots.js';
 import { aggregateToBuckets, extractSessions } from './aggregate.js';
 import { listDbCascades, readDbUsageRecords, readDbWorkspaceUri, readDbSessionEvents, readDbStepTimestamps, resolveUsageTimestamp } from './antigravity-db.js';
 
@@ -295,10 +296,10 @@ function projectFromUri(uri) {
  * List cascade IDs backed by a legacy `.pb` file (App history). `.db` cascades
  * are handled separately via offline parsing.
  */
-function listPbCascades() {
+function listPbCascades(conversationsDir = CONVERSATIONS_DIR) {
   try {
     const out = [];
-    for (const f of readdirSync(CONVERSATIONS_DIR)) {
+    for (const f of readdirSync(conversationsDir)) {
       if (f.endsWith('.pb')) out.push(f.slice(0, -3));
     }
     return out;
@@ -316,19 +317,88 @@ function modelFromRecord(rec) {
   return 'unknown';
 }
 
-export async function parse() {
+export async function parse({ extraRoots = [] } = {}) {
   const entries = [];
   const sessionEvents = [];
   const seenResponseIds = new Set();
 
+  const extraDirs = [];
+  for (const root of extraRoots) {
+    const dirs = antigravityConversationDirs(root);
+    let found = false;
+    for (const dir of dirs) {
+      try {
+        readdirSync(dir);
+        extraDirs.push(dir);
+        found = true;
+      } catch (err) {
+        if (err?.code === 'ENOENT') continue;
+        return {
+          buckets: [],
+          sessions: [],
+          skipped: true,
+          warnings: [`antigravity: 额外根目录读取失败，已保留上次同步数据: ${normalizeExtraRoot(root)}`],
+        };
+      }
+    }
+    if (!found) {
+      return {
+        buckets: [],
+        sessions: [],
+        skipped: true,
+        warnings: [`antigravity: 额外根目录不可用，已跳过本次 Antigravity 同步: ${normalizeExtraRoot(root)}`],
+      };
+    }
+  }
+
   // ── Path 1: offline .db parsing (App 2.0 + agy CLI, no process needed) ──
   const dbHandled = new Set();
-  for (const dir of [CONVERSATIONS_DIR, CLI_CONVERSATIONS_DIR]) {
-    for (const cascadeId of listDbCascades(dir)) {
-      const records = readDbUsageRecords(dir, cascadeId);
+  const fixtureDirs = process.env.VIBE_USAGE_ANTIGRAVITY_DIRS?.trim();
+  const defaultDirs = fixtureDirs
+    ? fixtureDirs.split(delimiter).filter(Boolean)
+    : [CONVERSATIONS_DIR, CLI_CONVERSATIONS_DIR];
+  const strictDirs = new Set(extraDirs);
+  const conversationDirs = [...new Set([...defaultDirs, ...extraDirs])];
+  const candidates = [];
+  for (const dir of conversationDirs) {
+    const strict = strictDirs.has(dir);
+    try {
+      for (const cascadeId of listDbCascades(dir, { strict })) {
+        candidates.push({ dir, cascadeId, strict });
+      }
+    } catch {
+      return {
+        buckets: [], sessions: [], skipped: true,
+        warnings: [`antigravity: 额外根目录读取失败，已保留上次同步数据: ${dir}`],
+      };
+    }
+  }
+  const configuredCascadeIds = new Set(
+    candidates.filter(candidate => candidate.strict).map(candidate => candidate.cascadeId),
+  );
+  const selectedConfiguredCopies = new Map();
+  for (const candidate of candidates) {
+    if (!configuredCascadeIds.has(candidate.cascadeId)) continue;
+    let size = 0;
+    try {
+      size = statSync(join(candidate.dir, `${candidate.cascadeId}.db`)).size;
+    } catch {
+      // The DB may move between discovery and stat; the read below will fail
+      // open in the existing offline reader.
+    }
+    const previous = selectedConfiguredCopies.get(candidate.cascadeId);
+    if (!previous || size > previous.size) selectedConfiguredCopies.set(candidate.cascadeId, { ...candidate, size });
+  }
+
+  for (const { dir, cascadeId, strict } of candidates) {
+    const selected = selectedConfiguredCopies.get(cascadeId);
+    if (selected && selected.dir !== dir) continue;
+    try {
+      const options = { strict };
+      const records = readDbUsageRecords(dir, cascadeId, options);
       const project = projectFromUri(readDbWorkspaceUri(dir, cascadeId)) || 'unknown';
       const stepTimestampsByIdx = records.some((rec) => !rec.timestamp || isNaN(rec.timestamp.getTime()))
-        ? readDbStepTimestamps(dir, cascadeId)
+        ? readDbStepTimestamps(dir, cascadeId, options)
         : new Map();
 
       if (records.length > 0) {
@@ -355,7 +425,7 @@ export async function parse() {
       }
 
       // Session timing from steps (independent of token usage presence).
-      for (const ev of readDbSessionEvents(dir, cascadeId)) {
+      for (const ev of readDbSessionEvents(dir, cascadeId, options)) {
         sessionEvents.push({
           sessionId: cascadeId,
           source: SOURCE,
@@ -364,11 +434,18 @@ export async function parse() {
           role: ev.role,
         });
       }
+    } catch (err) {
+      if (!strict) throw err;
+      return {
+        buckets: [], sessions: [], skipped: true,
+        warnings: [`antigravity: 额外根目录读取失败，已保留上次同步数据: ${dir}`],
+      };
     }
   }
 
   // ── Path 2: RPC fallback, only for legacy .pb cascades not already parsed ──
-  const pbCascades = listPbCascades().filter((id) => !dbHandled.has(id));
+  const pbDir = defaultDirs[0] || CONVERSATIONS_DIR;
+  const pbCascades = listPbCascades(pbDir).filter((id) => !dbHandled.has(id));
   if (pbCascades.length > 0) {
     const server = findLanguageServer();
     const ports = server ? findListeningPorts(server.pid) : [];