@vibe-cafe/vibe-usage 0.10.20 → 0.10.22

package/README.md

@@ -64,7 +64,7 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 | OpenCode | `~/.local/share/opencode/opencode.db` (SQLite, `json_extract` query) |
 | OpenClaw | `~/.openclaw/agents/`, `~/.openclaw-<profile>/agents/` (profile deployments); cache-creation/cache-write tokens are included in input usage |
 | Oh My Pi | `~/.omp/agent/sessions/`, `~/.omp/profiles/*/agent/sessions/`, and `$XDG_DATA_HOME/omp/{sessions,profiles/*/sessions}`; recognizes OMP's `$PI_CODING_AGENT_DIR`, current v3 title slots and path/hashed session directories, deduplicates copied records, includes cache writes in input, and splits reasoning from OMP's inclusive output count |
-| pi | `~/.pi/agent/sessions/` or `$PI_CODING_AGENT_DIR/sessions/`, plus the session directory Pi itself was pointed at via `PI_CODING_AGENT_SESSION_DIR` or `sessionDir` in `~/.pi/agent/settings.json` (fixture/relocation override: `VIBE_USAGE_PI_SESSION_DIRS`). Cache writes are included in input usage; reasoning is read from Pi's `usage.reasoning` (legacy `usage.reasoningTokens` still accepted) and split out of the inclusive output total |
+| pi | `~/.pi/agent/sessions/` or `$PI_CODING_AGENT_DIR/sessions/`, plus the session directory Pi itself was pointed at via `PI_CODING_AGENT_SESSION_DIR` or `sessionDir` in `~/.pi/agent/settings.json`, plus explicitly added `pi-coding-agent` roots for stores only reachable through `pi --session <file>` (fixture/relocation override: `VIBE_USAGE_PI_SESSION_DIRS`). Cache writes are included in input usage; reasoning is read from Pi's `usage.reasoning` (legacy `usage.reasoningTokens` still accepted) and split out of the inclusive output total |
 | Qwen Code | `~/.qwen/tmp/` |
 | Kimi Code | Current `~/.kimi-code/sessions/wd_<slug>_<hash>/session_<id>/agents/<agent>/wire.jsonl` (`usage.record` deltas, including retry/compaction scope and cache creation; main/subagent wires form one session), data root resolved via `$KIMI_CODE_HOME` like the CLI itself, with project names from `session_index.jsonl`; legacy `~/.kimi/sessions/` is parsed alongside (`kimi migrate` never carries usage over, so both stores are always merged) |
 | MiniMax Code (mcode) | `$MCODE_HOME/v2/sqlite/runtime-state.sqlite` (default `~/.minimax/v2/sqlite/runtime-state.sqlite`; fixture override: `VIBE_USAGE_MCODE_DB`). Reads only allow-listed token ledger fields and session workspace/project paths, uses basename-only projects, folds cache writes into input, keeps cache reads and reasoning separate, and never selects raw/message JSON payloads. WAL/lock reads use a disposable snapshot; malformed or incompatible databases are skipped to preserve incremental state. |
@@ -72,12 +72,12 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 | 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/state.db` + `~/.hermes/profiles/<name>/state.db` (SQLite, multi-profile) |
+| 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. |
 | 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) |
 | Trae CLI | macOS: `~/Library/Caches/trae-cli/sessions/`; Windows: `%LOCALAPPDATA%/trae-cli/cache/sessions/`; Linux: `~/.cache/trae-cli/sessions/` (CLI telemetry only; Trae IDE/Trae Work chats are not supported). Token usage is summed per unique LLM call (`model.stream.eino`, plus `model.generate` failovers); nested duplicate spans that share a session `traceID` are not max-merged. `traces.jsonl` / `events.jsonl` are streamed line-by-line so a multi-hundred-MB events file cannot hit Node's string-length limit. |
-| Antigravity | App 2.0 `~/.gemini/antigravity/conversations/*.db` and `agy` CLI `~/.gemini/antigravity-cli/conversations/*.db`, plus the same paths below explicitly added alternate Homes, are parsed offline (tokens, real model display name when present, project, sessions). Gemini 3.7 CLI blobs omit `chatStartMetadata.createdAt` and `modelDisplayName`; usage still comes from `gen_metadata`, timestamps fall back to `steps.metadata` at the same idx, and the model name falls back to `responseModel`. Legacy App `.pb` history falls back to Connect RPC only for the primary App store while the language server is running |
+| Antigravity | Scans App 2.0 `~/.gemini/antigravity/conversations/`, `agy` CLI `~/.gemini/antigravity-cli/conversations/`, and standalone IDE `~/.gemini/antigravity-ide/conversations/`. `.db` stores, including the same paths below explicitly added alternate Homes, are parsed offline (tokens, model, project, sessions). When Gemini blobs omit `chatStartMetadata.createdAt` or `modelDisplayName`, timestamps fall back to `steps.metadata` and model names to `responseModel`. `.pb` history in the default stores requires the corresponding App/IDE language server to be running; when several servers are open, the parser tries the others for unreadable conversations. Unavailable legacy history produces a warning and preserves prior sync state. |
 | WorkBuddy | Current releases: `~/.workbuddy-ai/projects/**/*.jsonl`; legacy releases: `~/.workbuddy/projects/**/*.jsonl` (fixture/relocation override: `VIBE_USAGE_WORKBUDDY_DIRS`). Reads usage-bearing completed assistant and `function_call` records, using the routed model identifier exposed as `providerData.requestModelId`. Splits cache reads and reasoning from inclusive input/output totals, deduplicates copied record IDs, and extracts local session timing without uploading message content. |
 | ZCode | `~/.zcode/cli/db/db.sqlite` (SQLite; reads the `message` table for per-message tokens, model, and project `cwd`/`root`, joined to `session.directory`) |
 
@@ -93,6 +93,24 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 - SQLite-backed tools are read via Node's built-in `node:sqlite` on Node ≥ 22.5 — no `sqlite3` binary needed (works on Windows out of the box); on older Node the CLI falls back to the system `sqlite3` executable
 - For continuous syncing, use `npx @vibe-cafe/vibe-usage daemon` or the [Vibe Usage Mac app](https://github.com/vibe-cafe/vibe-usage-app)
 
+## Cursor 网络排查
+
+Cursor 用量需要从 `cursor.com` 下载 CSV。`Cursor usage export skipped (network: …)` 表示这次下载失败；CLI 会保留 Cursor 的历史同步状态，下次同步重新尝试。
+
+- `ENOTFOUND` / `EAI_AGAIN`：检查 DNS 和终端网络。
+- `UND_ERR_CONNECT_TIMEOUT` / `ETIMEDOUT` / `ECONNRESET`：检查到 Cursor 的连接及终端代理。浏览器或 Cursor 应用能联网，不代表 Node.js 使用了相同代理。
+- `CERT_*` / `UNABLE_TO_VERIFY_LEAF_SIGNATURE` 等：检查系统时间和代理或公司网络的 CA 证书配置；自定义 CA 可通过 `NODE_EXTRA_CA_CERTS` 指定。
+- `timeout after …ms`：导出或下载超时，稍后重试；网络较慢时可设置 `VIBE_USAGE_CURSOR_FETCH_TIMEOUT_MS=60000`。
+- `Cursor session rejected`：在 Cursor 的 Account 设置中重新登录，再同步。
+
+需要 HTTP/HTTPS 代理时，Node.js **22.21+ 或 24.5+** 可用 `NODE_USE_ENV_PROXY=1` 启用环境变量代理（[Node.js 官方说明](https://nodejs.org/en/learn/http/enterprise-network-configuration)）。以下为 macOS/Linux 终端示例，代理地址须替换为实际地址：
+
+```bash
+HTTPS_PROXY=http://127.0.0.1:7890 NODE_USE_ENV_PROXY=1 npx @vibe-cafe/vibe-usage sync
+```
+
+这些环境变量只影响当前命令；已经运行的桌面应用和后台服务有各自的进程环境。持续失败时，请提供完整的 Cursor 报错、操作系统、`node -v` 和 CLI 版本，以便区分具体原因。
+
 ## Trust Model
 
 vibe-usage parses **local tool logs and local application state** on a machine the user fully controls. The reported data is self-reported telemetry — local logs, parsers, and upload requests can all be modified by the user.
@@ -158,7 +176,7 @@ Config stored at `~/.vibe-usage/config.json` (dev: `config.dev.json`).
 | `apiUrl` | Server URL (default: `https://vibecafe.ai`) |
 | `hostname` | Stable device name for usage tracking (set at init, reused across syncs) |
 | `codexExtraHome` | Optional additional Codex Home scanned together with `$CODEX_HOME` / `~/.codex` |
-| `extraRoots` | Tool-specific additional roots managed by the commands below; currently supports `codex`, `grok`, and `antigravity` |
+| `extraRoots` | Tool-specific additional roots managed by the commands below; currently supports `codex`, `grok`, `antigravity`, and `pi-coding-agent` |
 
 The `hostname` is captured once during `init` and reused for all future syncs. This prevents macOS mDNS hostname changes (e.g., `MacBook-Pro` → `MacBook-Pro-2`) from creating duplicate device entries. To change it manually:
 
@@ -179,6 +197,12 @@ npx @vibe-cafe/vibe-usage config add-root grok /path/to/grok-home
 # Antigravity expects an alternate HOME containing .gemini/antigravity*/conversations/.
 npx @vibe-cafe/vibe-usage config add-root antigravity /path/to/alternate-home
 
+# Pi accepts a directory that holds session .jsonl files directly, or a Pi
+# agent directory containing sessions/. Use this when a harness starts Pi with
+# `pi --session <file>`: that path is recorded nowhere Pi's own settings can
+# report, so it is invisible to discovery.
+npx @vibe-cafe/vibe-usage config add-root pi-coding-agent /path/to/pi-sessions
+
 npx @vibe-cafe/vibe-usage config roots
 npx @vibe-cafe/vibe-usage config remove-root grok /path/to/grok-home
 ```

package/package.json

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

package/src/extra-roots.js

@@ -1,9 +1,17 @@
-import { accessSync, constants, readdirSync, statSync } from 'node:fs';
+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'];
+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()) : [];
@@ -78,9 +86,198 @@ export function antigravityConversationDirs(value) {
   return [
     join(root, '.gemini', 'antigravity', 'conversations'),
     join(root, '.gemini', 'antigravity-cli', 'conversations'),
+    join(root, '.gemini', 'antigravity-ide', '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}` };
@@ -94,6 +291,15 @@ export function validateExtraRoot(source, value) {
       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);

package/src/index.js

@@ -121,7 +121,7 @@ function handleConfig(args) {
       const source = args[1];
       const value = args[2];
       if (!source || value === undefined) {
-        console.error('Usage: vibe-usage config add-root <codex|grok|antigravity> <path>');
+        console.error(`Usage: vibe-usage config add-root <${EXTRA_ROOT_SOURCES.join('|')}> <path>`);
         process.exit(1);
       }
       const validation = validateExtraRoot(source, value);
@@ -142,7 +142,7 @@ function handleConfig(args) {
       const source = args[1];
       const value = args[2];
       if (!EXTRA_ROOT_SOURCES.includes(source) || value === undefined) {
-        console.error('Usage: vibe-usage config remove-root <codex|grok|antigravity> <path>');
+        console.error(`Usage: vibe-usage config remove-root <${EXTRA_ROOT_SOURCES.join('|')}> <path>`);
         process.exit(1);
       }
       const config = loadConfig() || {};
@@ -297,7 +297,7 @@ 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, or Antigravity data root
+    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

package/src/parsers/antigravity.js

@@ -20,9 +20,8 @@ import { listDbCascades, readDbUsageRecords, readDbWorkspaceUri, readDbSessionEv
  */
 
 const SOURCE = 'antigravity';
-const CONVERSATIONS_DIR = join(homedir(), '.gemini', 'antigravity', 'conversations');
-// `agy` CLI stores conversations in a separate, App-independent directory.
-const CLI_CONVERSATIONS_DIR = join(homedir(), '.gemini', 'antigravity-cli', 'conversations');
+// App, CLI, and the standalone IDE each have their own conversation store.
+const CONVERSATIONS_DIRS = antigravityConversationDirs(homedir());
 
 // User sources → role 'user'; Model source → role 'assistant'; System sources → skip
 const USER_SOURCES = new Set([
@@ -33,24 +32,25 @@ const ASSISTANT_SOURCES = new Set([
   'CORTEX_STEP_SOURCE_MODEL',
 ]);
 
-// ── Process discovery (single instance) ──────────────────────────────
+// ── Process discovery ───────────────────────────────────────────────
 
 const IS_WIN = process.platform === 'win32';
 
 /**
- * Find ONE running language server process with a CSRF token.
- * Returns { pid, csrfToken } or null.
+ * Find running language servers with CSRF tokens. The App and standalone IDE
+ * can run together, and one server cannot read the other's legacy cascades.
  */
-function findLanguageServer() {
+function findLanguageServers() {
   try {
-    return IS_WIN ? findLanguageServerWin() : findLanguageServerUnix();
+    return IS_WIN ? findLanguageServersWin() : findLanguageServersUnix();
   } catch {
-    return null;
+    return [];
   }
 }
 
-function findLanguageServerUnix() {
+function findLanguageServersUnix() {
   const out = execSync("ps aux | grep -i 'antigravity.*language_server'", { encoding: 'utf-8', timeout: 5000 });
+  const servers = [];
   for (const line of out.split('\n')) {
     if (!line.trim()) continue;
     if (line.includes('grep')) continue;
@@ -59,19 +59,19 @@ function findLanguageServerUnix() {
     const pid = parts[1];
     const csrfMatch = line.match(/--csrf_token\s+([0-9a-f-]+)/);
     const csrfToken = csrfMatch ? csrfMatch[1] : '';
-    if (csrfToken) return { pid, csrfToken };
+    if (csrfToken) servers.push({ pid, csrfToken });
   }
-  return null;
+  return servers;
 }
 
-function findLanguageServerWin() {
+function findLanguageServersWin() {
   // Prefer PowerShell/CIM: wmic is disabled by default on Windows 11 23H2+
   // and removed entirely from 25H2 onward. Fall back to wmic for old/stripped
   // environments without PowerShell. Each probe is independently time-boxed and
   // failures are swallowed, so a missing/hung tool never blocks the next one or
   // the parsers that run after antigravity.
   const out = queryProcessesWinPowerShell() ?? queryProcessesWinWmic();
-  if (!out) return null;
+  if (!out) return [];
   return parseWinProcessList(out);
 }
 
@@ -117,20 +117,20 @@ function queryProcessesWinWmic() {
 
 /**
  * Parse "ProcessId=..." / "CommandLine=..." records (from either PowerShell or
- * wmic /format:list) and return the first language_server that carries a
- * --csrf_token, or null. PowerShell emits an explicit "---" separator per
+ * wmic /format:list) and return each language_server that carries a
+ * --csrf_token. PowerShell emits an explicit "---" separator per
  * process; wmic does not and may emit the two fields in either order, so a
  * record also ends whenever a field we've already captured reappears.
  */
-function parseWinProcessList(out) {
+export function parseWinProcessList(out) {
+  const servers = [];
   let pid = '';
   let cmdLine = '';
   const finish = () => {
     if (pid && cmdLine && !/WMIC\.exe|powershell\.exe|pwsh\.exe/i.test(cmdLine)) {
       const csrfMatch = cmdLine.match(/--csrf_token\s+([0-9a-f-]+)/);
-      if (csrfMatch) return { pid, csrfToken: csrfMatch[1] };
+      if (csrfMatch) servers.push({ pid, csrfToken: csrfMatch[1] });
     }
-    return null;
   };
   const reset = () => { pid = ''; cmdLine = ''; };
   for (const line of out.split('\n')) {
@@ -140,14 +140,14 @@ function parseWinProcessList(out) {
     // Record boundary: explicit "---", or a field that would overwrite one we
     // already hold (next process began without a separator, e.g. wmic output).
     if (trimmed === '---' || (isPid && pid) || (isCmd && cmdLine)) {
-      const found = finish();
-      if (found) return found;
+      finish();
       reset();
     }
     if (isPid) pid = trimmed.slice('ProcessId='.length);
     else if (isCmd) cmdLine = trimmed.slice('CommandLine='.length);
   }
-  return finish();
+  finish();
+  return servers;
 }
 
 function findListeningPorts(pid) {
@@ -296,7 +296,7 @@ function projectFromUri(uri) {
  * List cascade IDs backed by a legacy `.pb` file (App history). `.db` cascades
  * are handled separately via offline parsing.
  */
-function listPbCascades(conversationsDir = CONVERSATIONS_DIR) {
+function listPbCascades(conversationsDir) {
   try {
     const out = [];
     for (const f of readdirSync(conversationsDir)) {
@@ -320,6 +320,7 @@ function modelFromRecord(rec) {
 export async function parse({ extraRoots = [] } = {}) {
   const entries = [];
   const sessionEvents = [];
+  const warnings = [];
   const seenResponseIds = new Set();
 
   const extraDirs = [];
@@ -356,7 +357,7 @@ export async function parse({ extraRoots = [] } = {}) {
   const fixtureDirs = process.env.VIBE_USAGE_ANTIGRAVITY_DIRS?.trim();
   const defaultDirs = fixtureDirs
     ? fixtureDirs.split(delimiter).filter(Boolean)
-    : [CONVERSATIONS_DIR, CLI_CONVERSATIONS_DIR];
+    : CONVERSATIONS_DIRS;
   const strictDirs = new Set(extraDirs);
   const conversationDirs = [...new Set([...defaultDirs, ...extraDirs])];
   const candidates = [];
@@ -444,13 +445,14 @@ export async function parse({ extraRoots = [] } = {}) {
   }
 
   // ── Path 2: RPC fallback, only for legacy .pb cascades not already parsed ──
-  const pbDir = defaultDirs[0] || CONVERSATIONS_DIR;
-  const pbCascades = listPbCascades(pbDir).filter((id) => !dbHandled.has(id));
+  const pbCascades = [...new Set(defaultDirs.flatMap(listPbCascades))]
+    .filter((id) => !dbHandled.has(id));
   if (pbCascades.length > 0) {
-    const server = findLanguageServer();
-    const ports = server ? findListeningPorts(server.pid) : [];
-    const baseUrl = ports.length > 0 ? await probeHttpPort(ports, server.csrfToken) : null;
-    if (baseUrl) {
+    const pending = new Set(pbCascades);
+    for (const server of findLanguageServers()) {
+      const ports = findListeningPorts(server.pid);
+      const baseUrl = ports.length > 0 ? await probeHttpPort(ports, server.csrfToken) : null;
+      if (!baseUrl) continue;
       const rpc = (method, body) =>
         rpcPost(
           baseUrl,
@@ -459,7 +461,7 @@ export async function parse({ extraRoots = [] } = {}) {
           server.csrfToken,
         );
 
-      for (const cascadeId of pbCascades) {
+      for (const cascadeId of pending) {
         let resp;
         try {
           resp = await rpc('GetCascadeTrajectory', { cascadeId });
@@ -468,6 +470,7 @@ export async function parse({ extraRoots = [] } = {}) {
         }
         const trajectory = resp?.trajectory;
         if (!trajectory) continue;
+        pending.delete(cascadeId);
 
         const steps = trajectory.steps || [];
         const metadataList = trajectory.generatorMetadata || [];
@@ -519,11 +522,16 @@ export async function parse({ extraRoots = [] } = {}) {
           sessionEvents.push({ sessionId: cascadeId, source: SOURCE, project, timestamp: ts, role });
         }
       }
+      if (pending.size === 0) break;
+    }
+    if (pending.size > 0) {
+      warnings.push(`antigravity: ${pending.size} 个旧格式会话未能读取，请打开对应的 Antigravity IDE/App 后重新同步；已保留上次同步状态。`);
     }
   }
 
   return {
     buckets: aggregateToBuckets(entries),
     sessions: extractSessions(sessionEvents),
+    ...(warnings.length > 0 ? { skipped: true, warnings } : {}),
   };
 }

package/src/parsers/cursor.js

@@ -82,6 +82,41 @@ export function resolveCursorFetchTimeout(value) {
 
 const FETCH_TIMEOUT_MS = resolveCursorFetchTimeout(process.env.VIBE_USAGE_CURSOR_FETCH_TIMEOUT_MS);
 
+function usageNetworkError(error, signal) {
+  // Node fetch usually exposes only "fetch failed" at the top level. DNS,
+  // TLS and connection codes live in cause (or AggregateError.errors when
+  // both IPv4 and IPv6 fail). Report codes, not raw messages that may contain
+  // URLs with proxy credentials or authentication headers.
+  const codes = new Set();
+  const seen = new Set();
+  function visit(err) {
+    if (!err || typeof err !== 'object' || seen.has(err)) return;
+    seen.add(err);
+    if (typeof err.code === 'string' && /^[A-Z][A-Z0-9_]{1,63}$/.test(err.code)) {
+      codes.add(err.code);
+    }
+    visit(err.cause);
+    if (Array.isArray(err.errors)) err.errors.forEach(visit);
+  }
+  visit(error);
+
+  const timedOut = error?.name === 'TimeoutError' || signal.reason?.name === 'TimeoutError';
+  const reason = timedOut
+    ? `timeout after ${FETCH_TIMEOUT_MS}ms`
+    : `network: ${[...codes].join(', ') || 'fetch failed'}`;
+  let hint = '请检查终端网络和代理配置；浏览器能访问 Cursor 不代表 Node.js 使用了相同代理。';
+  if (timedOut) {
+    hint = 'Cursor 用量导出超时，请稍后重试；可通过 VIBE_USAGE_CURSOR_FETCH_TIMEOUT_MS 增大导出等待时间。';
+  } else if (codes.has('ENOTFOUND') || codes.has('EAI_AGAIN')) {
+    hint = '域名解析失败，请检查 DNS 和终端代理配置。';
+  } else if ([...codes].some(code => /CERT|SELF_SIGNED|UNABLE_TO_VERIFY|ERR_TLS_/.test(code))) {
+    hint = 'TLS 证书校验失败，请检查系统时间及代理或公司网络的 CA 证书配置。';
+  }
+  const err = new Error(`Cursor usage export skipped (${reason}). ${hint}`);
+  err.skip = true;
+  return err;
+}
+
 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`;
   const sub = decodeJwtSub(token);
@@ -110,20 +145,19 @@ async function fetchUsageCsv(token) {
   const failures = [];
   for (const headers of attempts) {
     let resp;
+    const signal = AbortSignal.timeout(FETCH_TIMEOUT_MS);
     try {
       resp = await fetch(url, {
         headers: { ...baseHeaders, ...headers },
-        signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+        signal,
       });
+      // The export may time out or disconnect after headers have arrived.
+      // Keep body consumption under the same deadline and soft-skip handling.
+      if (resp.ok) return await resp.text();
     } catch (e) {
-      // Hard-fail on network/timeout: stop trying further headers (won't fix
-      // a downed host) and signal a soft skip to the caller.
-      const reason = e.name === 'TimeoutError' ? 'timeout' : `network: ${e.message}`;
-      const err = new Error(`Cursor usage export skipped (${reason})`);
-      err.skip = true;
-      throw err;
+      // Changing credentials cannot repair a network failure.
+      throw usageNetworkError(e, signal);
     }
-    if (resp.ok) return await resp.text();
     failures.push(`${resp.status} ${resp.statusText}`);
     // Only auth rejections are worth retrying with different credentials.
     // 429/5xx are transient server-side states — soft-skip like network errors
@@ -198,7 +232,7 @@ export async function parse() {
   try {
     csv = await fetchUsageCsv(token);
   } catch (err) {
-    // Network/timeout → silent skip (avoid noisy daemon logs every 5 min).
+    // Network/timeout → skip with diagnostics (quiet sync suppresses these).
     // 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.

package/src/parsers/hermes.js

@@ -2,6 +2,7 @@ import { existsSync, readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 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');
@@ -26,6 +27,8 @@ export async function parse() {
   for (const { path: dbPath, profile } of dbs) {
     let sessionRows;
     try {
+      const columns = new Set(queryDb(dbPath, 'PRAGMA table_info(sessions)').map(row => row.name));
+      const cacheWriteColumn = columns.has('cache_write_tokens') ? 'cache_write_tokens' : '0';
       sessionRows = queryDb(dbPath, `SELECT
         id,
         model,
@@ -33,9 +36,11 @@ export async function parse() {
         input_tokens as inputTokens,
         output_tokens as outputTokens,
         cache_read_tokens as cacheReadTokens,
+        ${cacheWriteColumn} as cacheWriteTokens,
         reasoning_tokens as reasoningTokens
         FROM sessions
-        WHERE input_tokens > 0 OR output_tokens > 0`);
+        WHERE input_tokens > 0 OR output_tokens > 0
+          OR cache_read_tokens > 0 OR ${cacheWriteColumn} > 0 OR reasoning_tokens > 0`);
     } catch (err) {
       if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('Hermes');
       throw err;
@@ -47,15 +52,19 @@ export async function parse() {
       if (isNaN(timestamp.getTime())) continue;
 
       // Hermes stores input_tokens exclusive of cache (Anthropic-style semantics)
+      // and output_tokens inclusive of reasoning (CanonicalUsage.total_tokens
+      // adds prompt + output only). Split reasoning instead of counting it twice.
+      const output = toCount(row.outputTokens);
+      const reasoning = Math.min(output, toCount(row.reasoningTokens));
       entries.push({
         source: 'hermes',
         model: row.model || 'unknown',
         project: profile,
         timestamp,
-        inputTokens: row.inputTokens || 0,
-        outputTokens: row.outputTokens || 0,
-        cachedInputTokens: row.cacheReadTokens || 0,
-        reasoningOutputTokens: row.reasoningTokens || 0,
+        inputTokens: toCount(row.inputTokens) + toCount(row.cacheWriteTokens),
+        outputTokens: output - reasoning,
+        cachedInputTokens: toCount(row.cacheReadTokens),
+        reasoningOutputTokens: reasoning,
       });
     }
 

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');

package/src/pi-roots.js

@@ -1,6 +1,7 @@
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { delimiter, isAbsolute, join } from 'node:path';
 import { homedir } from 'node:os';
+import { piSessionsDir } from './extra-roots.js';
 
 function expandHome(value) {
   const trimmed = value.trim();
@@ -60,22 +61,30 @@ function settingsSessionDir(agentDir) {
   }
 }
 
-export function getPiSessionDirs() {
+export function getPiSessionDirs(extraRoots = []) {
+  // Explicitly configured roots are user intent, not a fixture: they are always
+  // scanned, and they never replace the default store. A root whose shape no
+  // longer resolves drops out here; the parser reports that as skipped.
+  const extraDirs = extraRoots.map(piSessionsDir).filter(dir => dir !== null);
+
   const override = process.env.VIBE_USAGE_PI_SESSION_DIRS?.trim();
-  if (override) return uniqueExistingDirs(override.split(delimiter));
+  if (override) return uniqueExistingDirs([...override.split(delimiter), ...extraDirs]);
 
   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 isOmpStore = Boolean(envAgentDir) && looksLikeOmpAgentDir(agentDir);
 
-  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);
+  const dirs = [];
+  if (!isOmpStore) {
+    dirs.push(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, ...extraDirs]);
 }
 
 export function getOmpSessionDirs() {

package/src/tools.js

@@ -174,8 +174,7 @@ export function getMimocodeDbPath(env = process.env) {
 
 export function findAntigravityDataDirs(extraRoots = []) {
   return [...new Set([
-    join(homedir(), '.gemini', 'antigravity'),
-    join(homedir(), '.gemini', 'antigravity-cli'),
+    ...antigravityConversationDirs(homedir()).map(dirname),
     ...extraRoots.flatMap(root => antigravityConversationDirs(root).map(dirname)),
   ])].filter(existsSync);
 }
@@ -320,7 +319,9 @@ export const TOOLS = [
     name: 'pi',
     id: 'pi-coding-agent',
     dataDir: join(homedir(), '.pi', 'agent', 'sessions'),
-    detectDataDirs: findPiDataDirs,
+    detectDataDirs: ({ extraRoots } = {}) => (
+      findPiDataDirs(extraRootList(extraRoots?.['pi-coding-agent']))
+    ),
   },
   {
     name: 'Qwen Code',