@vibe-cafe/vibe-usage 0.10.20 → 0.10.21

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. |
@@ -158,7 +158,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 +179,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.21",
   "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()) : [];
@@ -81,6 +89,194 @@ export function antigravityConversationDirs(value) {
   ];
 }
 
+// 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 +290,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/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

@@ -320,7 +320,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',