@vibe-cafe/vibe-usage 0.9.16 → 0.10.1

package/README.md

@@ -50,8 +50,8 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 
 | Tool | Data Location |
 |------|---------------|
-| Claude Code | `~/.claude/projects/` (tokens + sessions), `~/.claude/transcripts/` (sessions only); also scans `$CLAUDE_CONFIG_DIR` when set (deduped), so relocated configs and GUI/CLI env mismatches are both covered |
-| Codex CLI | `$CODEX_HOME/sessions/` and `$CODEX_HOME/archived_sessions/` (default `~/.codex`); forked and sub-agent rollouts replay parent metadata, tasks, and `token_count` records at spawn time — full or last-N-turn replay blocks are matched as a fingerprinted parent suffix plus the child's own task boundary, duplicate cumulative emissions count once, and live/archive copies of the same session are deduplicated |
+| Claude Code | `~/.claude/projects/` (tokens + sessions), `~/.claude/transcripts/` (sessions only); also scans `$CLAUDE_CONFIG_DIR` and data-bearing `~/.claude-*` profiles, selects the most complete duplicate session, and streams logs so large active sessions are not silently omitted. Cache creation tokens are included in input usage. |
+| Codex CLI | `$CODEX_HOME/sessions/` and `$CODEX_HOME/archived_sessions/` (default `~/.codex`); a versioned local index avoids re-reading unchanged rollouts and reads only safe append tails for ordinary sessions, while fork/sub-agent replay matching, duplicate suppression, and live/archive deduplication retain their existing semantics |
 | Grok | `$GROK_HOME/sessions/<encoded-cwd>/<session-id>/` (default `~/.grok`); token usage from `updates.jsonl` `turn_completed.usage` (per-model `modelUsage`, cache reads, reasoning); project from `summary.json` cwd; honors `GROK_HOME` |
 | GitHub Copilot CLI | `~/.copilot/session-state/*/events.jsonl` |
 | Cursor | `state.vscdb` (SQLite, reads `cursorAuth/accessToken`, fetches CSV from `cursor.com`); cloud data is stamped with a fixed `cursor-cloud` hostname so multi-machine setups don't double-count |
@@ -77,7 +77,9 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 - Aggregates token usage into 30-minute buckets
 - Extracts session metadata from all parsers: active time (AI generation time, excluding queue/TTFT wait), total duration, message counts
 - Uploads buckets + sessions to your vibecafe.ai dashboard (always gzip-compressed, ~94% smaller)
-- Incremental: parsers still compute full totals from local logs each sync (idempotent), but only buckets/sessions that are new or changed since the last successful upload are sent — a quiet machine uploads nothing. Sync state is kept in `~/.vibe-usage/state.json`; failed parsers retain their prior state, while deleted local logs are pruned. Deleting the state file triggers a one-time full re-upload, and `reset` clears it automatically after deleting cloud data
+- Incremental upload: every parser emits a complete local snapshot, then only buckets/sessions that are new or changed since the last successful upload are sent — a quiet machine uploads nothing. Upload state remains in `~/.vibe-usage/state.json`; failed or still-indexing parsers retain their prior state, while deleted local logs are pruned. Deleting the state file triggers a one-time full re-upload, and `reset` clears it automatically after deleting cloud data
+- Incremental Codex parsing: a versioned, disposable cache under `~/.vibe-usage/cache/codex/` stores per-rollout aggregate results and parser continuation state. Unchanged rollouts require no raw-log reads; an ordinary append reads only the new tail; forks, sub-agents, replacements, truncations, and failed safety checks fall back to the full correctness path. A bounded rolling audit occasionally re-reads one historical file. Very large first-time indexes checkpoint before the Mac app timeout and resume on the next sync instead of restarting
+- The Codex parser cache contains derived aggregates and replay metadata, not raw prompt or response text. It is independent of upload state and can be deleted safely (the next sync rebuilds it). `reset` intentionally keeps it so the required full re-upload does not also require a full disk rescan. Set `VIBE_USAGE_CODEX_CACHE=0` to disable the optimization for diagnosis
 - SQLite-backed tools (Cursor, OpenCode, Kiro, Hermes) 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 it falls back to the system `sqlite3` CLI
 - For continuous syncing, use `npx @vibe-cafe/vibe-usage daemon` or the [Vibe Usage Mac app](https://github.com/vibe-cafe/vibe-usage-app)
 

package/package.json

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

package/src/claude-roots.js

@@ -0,0 +1,81 @@
+import { existsSync, readdirSync, realpathSync, statSync } from 'node:fs';
+import { delimiter, join } from 'node:path';
+import { homedir } from 'node:os';
+
+function expandHome(value) {
+  const trimmed = value.trim().replace(/[/\\]+$/, '');
+  if (trimmed === '~') return homedir();
+  if (trimmed.startsWith('~/') || trimmed.startsWith('~\\')) {
+    return join(homedir(), trimmed.slice(2));
+  }
+  return trimmed;
+}
+
+function hasClaudeData(root) {
+  return existsSync(join(root, 'projects')) || existsSync(join(root, 'transcripts'));
+}
+
+/**
+ * Return every Claude Code state root visible from this process.
+ *
+ * In addition to the default and CLAUDE_CONFIG_DIR, discover the documented
+ * multi-profile convention (~/.claude-work, ~/.claude-personal, ...). This is
+ * important for launchd/systemd and GUI processes, which commonly do not
+ * inherit the shell environment used to launch Claude Code.
+ *
+ * VIBE_USAGE_CLAUDE_DIRS is a test/diagnostic override. It replaces discovery
+ * with a path.delimiter-separated root list.
+ */
+export function getClaudeRoots() {
+  const override = process.env.VIBE_USAGE_CLAUDE_DIRS?.trim();
+  const roots = override
+    ? override.split(delimiter).map(expandHome).filter(Boolean)
+    : [join(homedir(), '.claude')];
+
+  if (!override) {
+    const configured = process.env.CLAUDE_CONFIG_DIR?.trim();
+    if (configured) roots.push(expandHome(configured));
+
+    try {
+      for (const entry of readdirSync(homedir(), { withFileTypes: true })) {
+        // Profiles are sometimes symlinked, so let hasClaudeData() follow the
+        // entry instead of requiring Dirent.isDirectory() here.
+        if (!/^\.claude-.+/.test(entry.name)) continue;
+        const candidate = join(homedir(), entry.name);
+        if (hasClaudeData(candidate)) roots.push(candidate);
+      }
+    } catch {
+      // The default/configured roots remain usable if home discovery fails.
+    }
+  }
+
+  const seen = new Set();
+  const unique = [];
+  for (const root of roots) {
+    let canonical = root;
+    try {
+      canonical = realpathSync(root);
+    } catch {
+      // Keep a missing explicit/default root so callers can report it normally.
+    }
+    if (seen.has(canonical)) continue;
+    seen.add(canonical);
+    unique.push(root);
+  }
+  return unique;
+}
+
+export function findClaudeCodeDataDirs() {
+  const dirs = [];
+  for (const root of getClaudeRoots()) {
+    for (const name of ['projects', 'transcripts']) {
+      const candidate = join(root, name);
+      try {
+        if (statSync(candidate).isDirectory()) dirs.push(candidate);
+      } catch {
+        // Missing or unreadable roots are handled by the parser.
+      }
+    }
+  }
+  return dirs;
+}

package/src/daemon-service.js

@@ -43,7 +43,23 @@ function getServicePaths(plat) {
   return null;
 }
 
-function generateSystemdUnit(nodePath, binPath) {
+function escapeSystemdEnvironment(value) {
+  return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
+function escapeXml(value) {
+  return value
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}
+
+export function generateSystemdUnit(nodePath, binPath, claudeConfigDir = process.env.CLAUDE_CONFIG_DIR?.trim()) {
+  const claudeEnvironment = claudeConfigDir
+    ? `Environment="CLAUDE_CONFIG_DIR=${escapeSystemdEnvironment(claudeConfigDir)}"\n`
+    : '';
   return `[Unit]
 Description=VibeCafe Usage Tracker
 After=network.target
@@ -54,15 +70,18 @@ ExecStart=${nodePath} ${binPath} daemon
 Restart=on-failure
 RestartSec=10
 Environment=NODE_ENV=production
-WorkingDirectory=${homedir()}
+${claudeEnvironment}WorkingDirectory=${homedir()}
 
 [Install]
 WantedBy=default.target
 `;
 }
 
-function generateLaunchdPlist(nodePath, binPath) {
+export function generateLaunchdPlist(nodePath, binPath, claudeConfigDir = process.env.CLAUDE_CONFIG_DIR?.trim()) {
   const logDir = join(homedir(), '.vibe-usage');
+  const claudeEnvironment = claudeConfigDir
+    ? `        <key>CLAUDE_CONFIG_DIR</key>\n        <string>${escapeXml(claudeConfigDir)}</string>\n`
+    : '';
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -89,7 +108,7 @@ function generateLaunchdPlist(nodePath, binPath) {
     <dict>
         <key>NODE_ENV</key>
         <string>production</string>
-    </dict>
+${claudeEnvironment}    </dict>
 </dict>
 </plist>
 `;

package/src/parsers/claude-code.js

@@ -1,243 +1,305 @@
-import { readdirSync, readFileSync, existsSync, realpathSync } from 'node:fs';
+import { createReadStream, readdirSync, statSync } from 'node:fs';
+import { createInterface } from 'node:readline';
 import { join, basename, sep } from 'node:path';
-import { homedir } from 'node:os';
 import { aggregateToBuckets, extractSessions } from './index.js';
+import { getClaudeRoots } from '../claude-roots.js';
 
-/**
- * Stateless Claude Code parser.
- * Reads ALL *.jsonl files under <root>/projects/ and extracts per-message
- * token usage from assistant messages. No state file needed — every sync
- * computes the full bucket totals from raw data, making server-side
- * ON CONFLICT ... DO UPDATE SET idempotent.
- *
- * Roots: always ~/.claude, plus $CLAUDE_CONFIG_DIR when set to a different
- * path. Claude Code itself relocates its whole tree (incl. projects/) to
- * $CLAUDE_CONFIG_DIR and uses only that dir — but a GUI launched from the
- * Dock may not inherit the shell's env, so usage can be split across both
- * roots. We scan both and dedup so neither source is missed or double-counted.
- */
+const MAX_WARNINGS = 20;
 
-/**
- * Resolve the set of Claude config roots to scan.
- * Always includes ~/.claude; adds $CLAUDE_CONFIG_DIR when set and it resolves
- * to a different real path. Deduped by canonical path.
- */
-function getClaudeRoots() {
-  const roots = [join(homedir(), '.claude')];
-
-  const cfg = process.env.CLAUDE_CONFIG_DIR?.trim();
-  if (cfg) {
-    let custom = cfg;
-    if (custom.startsWith('~')) custom = join(homedir(), custom.slice(1));
-    custom = custom.replace(/[/\\]+$/, '') || custom;
-    roots.push(custom);
-  }
+function addWarning(ctx, message) {
+  ctx.incomplete = true;
+  if (ctx.warnings.length < MAX_WARNINGS) ctx.warnings.push(message);
+}
 
-  // Dedup by canonical path (realpath when the dir exists, else the raw string).
-  const seen = new Set();
-  const unique = [];
-  for (const r of roots) {
-    let key = r;
-    try {
-      key = realpathSync(r);
-    } catch {
-      // dir may not exist yet — fall back to the literal path
+/** Recursively collect JSONL files without making one unreadable branch fatal. */
+function findJsonlFiles(dir, ctx) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch (err) {
+    if (err?.code !== 'ENOENT') {
+      addWarning(ctx, `Claude Code: cannot read directory ${dir}: ${err.message}`);
     }
-    if (seen.has(key)) continue;
-    seen.add(key);
-    unique.push(r);
+    return [];
   }
-  return unique;
-}
 
-/**
- * Recursively find all .jsonl files under a directory.
- * Claude Code stores sessions in two layouts:
- *   2-layer: projects/{projectPath}/{sessionId}.jsonl
- *   3-layer: projects/{projectPath}/{sessionId}/subagents/agent-*.jsonl
- */
-function findJsonlFiles(dir) {
   const results = [];
-  if (!existsSync(dir)) return results;
-  try {
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-      const fullPath = join(dir, entry.name);
-      if (entry.isDirectory()) {
-        results.push(...findJsonlFiles(fullPath));
-      } else if (entry.name.endsWith('.jsonl')) {
-        results.push(fullPath);
-      }
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...findJsonlFiles(fullPath, ctx));
+    } else if (entry.name.endsWith('.jsonl')) {
+      results.push(fullPath);
     }
-  } catch {
-    // ignore unreadable directories
   }
   return results;
 }
 
-/**
- * Path of a project file relative to its root's projects/ dir, e.g.
- * "<root>/projects/-Users-foo-app/abc.jsonl" → "-Users-foo-app/abc.jsonl".
- * Used both for project-name extraction and cross-root dedup.
- */
 function projectRelativePath(filePath, projectsDir) {
   const prefix = projectsDir + sep;
   return filePath.startsWith(prefix) ? filePath.slice(prefix.length) : null;
 }
 
-/**
- * Extract project name from a projects-relative path.
- * The first segment is the dash-encoded project path (e.g. -Users-foo-myproject);
- * we take its last component as the project name.
- */
-function extractProject(relative) {
+/** Best-effort fallback for old records without cwd. */
+function projectFromRelative(relative) {
   if (!relative) return 'unknown';
-  const firstSeg = relative.split(sep)[0];
-  if (!firstSeg) return 'unknown';
-  const parts = firstSeg.split('-').filter(Boolean);
-  return parts.length > 0 ? parts[parts.length - 1] : 'unknown';
+  const firstSegment = relative.split(sep)[0];
+  if (!firstSegment) return 'unknown';
+  const parts = firstSegment.split('-').filter(Boolean);
+  return parts.at(-1) || 'unknown';
+}
+
+/** Works for Unix and Windows cwd values regardless of the current OS. */
+function projectFromCwd(cwd, fallback) {
+  if (typeof cwd !== 'string') return fallback;
+  const trimmed = cwd.trim().replace(/[\\/]+$/, '');
+  if (!trimmed) return fallback;
+  return trimmed.split(/[\\/]/).filter(Boolean).at(-1) || fallback;
+}
+
+function toCount(value) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? n : 0;
+}
+
+function cacheCreationTokens(usage) {
+  const direct = toCount(usage.cache_creation_input_tokens);
+  const breakdown = usage.cache_creation || {};
+  const split =
+    toCount(breakdown.ephemeral_5m_input_tokens) +
+    toCount(breakdown.ephemeral_1h_input_tokens);
+  // Current Claude logs carry both the total and its TTL breakdown. max()
+  // avoids double-counting while remaining tolerant of partially populated logs.
+  return Math.max(direct, split);
 }
 
-function extractSessionId(filePath) {
-  return basename(filePath, '.jsonl');
+function candidateIsBetter(next, current) {
+  if (!current) return true;
+  if (next.size !== current.size) return next.size > current.size;
+  if (next.mtimeMs !== current.mtimeMs) return next.mtimeMs > current.mtimeMs;
+  return next.filePath.localeCompare(current.filePath) < 0;
 }
 
 /**
- * Scan one root's projects/ dir → token entries + session events (mutates ctx).
+ * Group physical files by logical session id and keep candidates ordered by
+ * completeness. A session copied between ~/.claude and CLAUDE_CONFIG_DIR must
+ * use its largest/newest copy, not whichever root happened to be scanned first.
  */
-function scanProjectsRoot(root, ctx) {
-  const projectsDir = join(root, 'projects');
-
-  for (const filePath of findJsonlFiles(projectsDir)) {
-    const relative = projectRelativePath(filePath, projectsDir);
-    // Same session present under two roots (e.g. data copied between them):
-    // process it once so session message counts aren't inflated.
-    if (relative !== null) {
-      if (ctx.seenProjectFiles.has(relative)) continue;
-      ctx.seenProjectFiles.add(relative);
-    }
-
-    let content;
-    try {
-      content = readFileSync(filePath, 'utf-8');
-    } catch {
-      continue;
+function collectCandidates(roots, directoryName, ctx) {
+  const groups = new Map();
+  for (const root of roots) {
+    const baseDir = join(root, directoryName);
+    for (const filePath of findJsonlFiles(baseDir, ctx)) {
+      let stat;
+      try {
+        stat = statSync(filePath);
+      } catch (err) {
+        addWarning(ctx, `Claude Code: cannot stat ${filePath}: ${err.message}`);
+        continue;
+      }
+      const sessionId = basename(filePath, '.jsonl');
+      const relative = projectRelativePath(filePath, baseDir);
+      const candidate = {
+        filePath,
+        sessionId,
+        size: stat.size,
+        mtimeMs: stat.mtimeMs,
+        fallbackProject: directoryName === 'projects'
+          ? projectFromRelative(relative)
+          : 'unknown',
+      };
+      const group = groups.get(sessionId) || [];
+      group.push(candidate);
+      groups.set(sessionId, group);
     }
+  }
+  for (const group of groups.values()) {
+    group.sort((a, b) => candidateIsBetter(a, b) ? -1 : candidateIsBetter(b, a) ? 1 : 0);
+  }
+  return groups;
+}
 
-    const project = extractProject(relative);
-    const sessionId = extractSessionId(filePath);
-    ctx.seenSessionIds.add(sessionId);
+/** Read only the file size captured during discovery, so live appends wait. */
+async function readJsonl(candidate, onObject) {
+  if (candidate.size === 0) return;
+  const stream = createReadStream(candidate.filePath, {
+    encoding: 'utf8',
+    start: 0,
+    end: candidate.size - 1,
+  });
+  let streamError = null;
+  stream.on('error', (err) => { streamError = err; });
+  const lines = createInterface({ input: stream, crlfDelay: Infinity });
 
-    for (const line of content.split('\n')) {
+  try {
+    for await (const line of lines) {
       if (!line.trim()) continue;
       try {
-        const obj = JSON.parse(line);
-
-        const timestamp = obj.timestamp;
-        if (!timestamp) continue;
-        const ts = new Date(timestamp);
-        if (isNaN(ts.getTime())) continue;
-
-        if (obj.type === 'user' || obj.type === 'assistant' || obj.type === 'tool_use' || obj.type === 'tool_result') {
-          ctx.sessionEvents.push({
-            sessionId,
-            source: 'claude-code',
-            project,
-            timestamp: ts,
-            role: obj.type === 'user' ? 'user' : 'assistant',
-          });
-        }
-
-        if (obj.type !== 'assistant') continue;
-        const msg = obj.message;
-        if (!msg || !msg.usage) continue;
-
-        const usage = msg.usage;
-        if (usage.input_tokens == null && usage.output_tokens == null) continue;
-
-        const uuid = obj.uuid;
-        if (uuid) {
-          if (ctx.seenUuids.has(uuid)) continue;
-          ctx.seenUuids.add(uuid);
-        }
-
-        ctx.entries.push({
-          source: 'claude-code',
-          model: msg.model || 'unknown',
-          project,
-          timestamp: ts,
-          inputTokens: usage.input_tokens || 0,
-          outputTokens: usage.output_tokens || 0,
-          cachedInputTokens: usage.cache_read_input_tokens || 0,
-          reasoningOutputTokens: 0,
-        });
+        onObject(JSON.parse(line));
       } catch {
-        continue;
+        // Claude may be appending the final JSONL record while we snapshot it.
+        // A later sync will see the complete line; malformed historical lines
+        // are isolated instead of taking the whole parser down.
       }
     }
+    if (streamError) throw streamError;
+  } finally {
+    lines.close();
+    stream.destroy();
   }
 }
 
-/**
- * Scan one root's transcripts/ dir → session events only (no token data).
- * Skips sessions already covered by a projects/ or transcripts/ scan.
- */
-function scanTranscriptsRoot(root, ctx) {
-  for (const filePath of findJsonlFiles(join(root, 'transcripts'))) {
-    const sessionId = extractSessionId(filePath);
-    if (ctx.seenSessionIds.has(sessionId)) continue;
-    ctx.seenSessionIds.add(sessionId);
+function timingEvent(obj, sessionId, project) {
+  if (
+    obj.type !== 'user' &&
+    obj.type !== 'assistant' &&
+    obj.type !== 'tool_use' &&
+    obj.type !== 'tool_result'
+  ) return null;
+  if (!obj.timestamp) return null;
+  const timestamp = new Date(obj.timestamp);
+  if (Number.isNaN(timestamp.getTime())) return null;
+  return {
+    sessionId,
+    source: 'claude-code',
+    project,
+    timestamp,
+    role: obj.type === 'user' ? 'user' : 'assistant',
+  };
+}
 
-    let content;
-    try {
-      content = readFileSync(filePath, 'utf-8');
-    } catch {
-      continue;
+async function scanProjectCandidate(candidate) {
+  const entries = [];
+  const events = [];
+  let lastModel = null;
+  let sessionProject = candidate.fallbackProject;
+  let foundSessionCwd = false;
+
+  await readJsonl(candidate, (obj) => {
+    // cwd can change after Claude runs `cd`; project attribution should remain
+    // the directory where this session started, not fragment into subfolders.
+    if (!foundSessionCwd && typeof obj.cwd === 'string' && obj.cwd.trim()) {
+      sessionProject = projectFromCwd(obj.cwd, candidate.fallbackProject);
+      foundSessionCwd = true;
     }
+    const event = timingEvent(obj, candidate.sessionId, sessionProject);
+    if (event) events.push(event);
 
-    for (const line of content.split('\n')) {
-      if (!line.trim()) continue;
-      try {
-        const obj = JSON.parse(line);
-
-        const timestamp = obj.timestamp;
-        if (!timestamp) continue;
-        const ts = new Date(timestamp);
-        if (isNaN(ts.getTime())) continue;
-
-        if (obj.type === 'user' || obj.type === 'assistant' || obj.type === 'tool_use' || obj.type === 'tool_result') {
-          ctx.sessionEvents.push({
-            sessionId,
-            source: 'claude-code',
-            project: 'unknown',
-            timestamp: ts,
-            role: obj.type === 'user' ? 'user' : 'assistant',
-          });
-        }
-      } catch {
-        continue;
-      }
+    if (obj.type !== 'assistant' || !obj.message?.usage || !obj.timestamp) return;
+    const timestamp = new Date(obj.timestamp);
+    if (Number.isNaN(timestamp.getTime())) return;
+
+    const usage = obj.message.usage;
+    const rawModel = typeof obj.message.model === 'string'
+      ? obj.message.model.trim()
+      : '';
+    if (rawModel && rawModel !== '<synthetic>') lastModel = rawModel;
+    const model = rawModel && rawModel !== '<synthetic>'
+      ? rawModel
+      : lastModel || 'claude-unknown';
+    const inputTokens = toCount(usage.input_tokens) + cacheCreationTokens(usage);
+    const outputTokens = toCount(usage.output_tokens);
+    const cachedInputTokens = toCount(usage.cache_read_input_tokens);
+    const usageScore = inputTokens + outputTokens + cachedInputTokens;
+
+    // Synthetic bookkeeping messages are common and carry zero usage. Do not
+    // inflate the CLI's bucket count with rows the server will discard anyway.
+    if (usageScore === 0) return;
+
+    entries.push({
+      uuid: typeof obj.uuid === 'string' && obj.uuid ? obj.uuid : null,
+      usageScore,
+      source: 'claude-code',
+      model,
+      project: sessionProject,
+      timestamp,
+      inputTokens,
+      outputTokens,
+      cachedInputTokens,
+      reasoningOutputTokens: 0,
+    });
+  });
+
+  // A cwd can appear after initial metadata/messages. Normalize the completed
+  // session in one place so early records receive the same project label.
+  for (const entry of entries) entry.project = sessionProject;
+  for (const event of events) event.project = sessionProject;
+  return { entries, events };
+}
+
+async function scanTranscriptCandidate(candidate) {
+  const events = [];
+  await readJsonl(candidate, (obj) => {
+    const event = timingEvent(
+      obj,
+      candidate.sessionId,
+      projectFromCwd(obj.cwd, 'unknown'),
+    );
+    if (event) events.push(event);
+  });
+  return { entries: [], events };
+}
+
+async function scanBestCandidate(candidates, scanner, ctx) {
+  for (const candidate of candidates) {
+    try {
+      return await scanner(candidate);
+    } catch (err) {
+      addWarning(ctx, `Claude Code: cannot read ${candidate.filePath}: ${err.message}`);
     }
   }
+  return null;
+}
+
+function mergeUsageEntry(ctx, entry) {
+  if (!entry.uuid) {
+    ctx.anonymousEntries.push(entry);
+    return;
+  }
+  const current = ctx.entriesByUuid.get(entry.uuid);
+  // Claude sometimes copies the same UUID into another session with zeroed
+  // usage. Keep the most complete payload, independent of directory order.
+  if (!current || entry.usageScore > current.usageScore) {
+    ctx.entriesByUuid.set(entry.uuid, entry);
+  }
 }
 
 export async function parse() {
   const ctx = {
-    entries: [],
+    entriesByUuid: new Map(),
+    anonymousEntries: [],
     sessionEvents: [],
-    seenUuids: new Set(),
-    seenSessionIds: new Set(),
-    seenProjectFiles: new Set(), // projects-relative path → dedup same session across roots
+    warnings: [],
+    incomplete: false,
   };
-
   const roots = getClaudeRoots();
+  const projectGroups = collectCandidates(roots, 'projects', ctx);
+  const projectSessionIds = new Set();
+
+  for (const [sessionId, candidates] of projectGroups) {
+    const parsed = await scanBestCandidate(candidates, scanProjectCandidate, ctx);
+    if (!parsed) continue;
+    projectSessionIds.add(sessionId);
+    ctx.sessionEvents.push(...parsed.events);
+    for (const entry of parsed.entries) mergeUsageEntry(ctx, entry);
+  }
+
+  const transcriptGroups = collectCandidates(roots, 'transcripts', ctx);
+  for (const [sessionId, candidates] of transcriptGroups) {
+    if (projectSessionIds.has(sessionId)) continue;
+    const parsed = await scanBestCandidate(candidates, scanTranscriptCandidate, ctx);
+    if (parsed) ctx.sessionEvents.push(...parsed.events);
+  }
 
-  // projects/ yields BOTH token buckets and session events.
-  for (const root of roots) scanProjectsRoot(root, ctx);
-  // transcripts/ yields session events only, for sessions not already covered.
-  for (const root of roots) scanTranscriptsRoot(root, ctx);
+  const entries = [
+    ...ctx.anonymousEntries,
+    ...ctx.entriesByUuid.values(),
+  ].map(({ uuid: _uuid, usageScore: _usageScore, ...entry }) => entry);
 
   return {
-    buckets: aggregateToBuckets(ctx.entries),
+    buckets: aggregateToBuckets(entries),
     sessions: extractSessions(ctx.sessionEvents),
+    ...(ctx.incomplete ? { skipped: true } : {}),
+    ...(ctx.warnings.length > 0 ? { warnings: ctx.warnings } : {}),
   };
 }