vibestats 1.3.13 → 1.3.14

package/dist/index.js

@@ -902,9 +902,9 @@ function buildActivityHeatmapLines(graph, options) {
 
 // src/anthropic-sources.ts
 import { execFile } from "child_process";
-import { promises as fs } from "fs";
-import { homedir } from "os";
-import { basename, join } from "path";
+import { promises as fs2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { basename, join as join2 } from "path";
 import { promisify } from "util";
 
 // src/shared/async.ts
@@ -934,12 +934,168 @@ async function mapWithConcurrency(items, concurrency, worker) {
   return results;
 }
 
+// src/usage/cache.ts
+import { promises as fs } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var USAGE_CACHE_SCHEMA_VERSION = 1;
+var USAGE_CACHE_FILENAME = "usage-entries-v1.json";
+var CACHE_LOCK_TIMEOUT_MS = 2e3;
+var CACHE_LOCK_RETRY_MS = 25;
+var CACHE_LOCK_STALE_MS = 3e4;
+var cacheWriteQueue = Promise.resolve();
+function getUsageCacheDir() {
+  return process.env.VIBESTATS_CACHE_DIR || join(homedir(), ".vibestats", "cache");
+}
+function getUsageCachePath() {
+  return join(getUsageCacheDir(), USAGE_CACHE_FILENAME);
+}
+function shouldUsePersistentUsageCache(options = {}) {
+  return options.useCache !== false;
+}
+function createMissingFingerprint(path) {
+  return {
+    path,
+    size: -1,
+    mtimeMs: -1
+  };
+}
+async function getSourceFingerprint(path) {
+  try {
+    const stats = await fs.stat(path);
+    if (!stats.isFile()) return null;
+    return {
+      path,
+      size: stats.size,
+      mtimeMs: Math.trunc(stats.mtimeMs)
+    };
+  } catch {
+    return null;
+  }
+}
+function fingerprintMatches(left, right) {
+  return Boolean(left && left.path === right.path && left.size === right.size && left.mtimeMs === right.mtimeMs);
+}
+function dependencyFingerprintsMatch(cached, current) {
+  if ((cached?.length || 0) !== current.length) return false;
+  for (let index = 0; index < current.length; index++) {
+    if (!fingerprintMatches(cached?.[index], current[index])) return false;
+  }
+  return true;
+}
+function getCachedUsageValue(cache, key, fingerprint, dependencyFingerprints = []) {
+  const record = cache.entries[key];
+  if (!record) return null;
+  if (!fingerprintMatches(record.fingerprint, fingerprint)) return null;
+  if (!dependencyFingerprintsMatch(record.dependencyFingerprints, dependencyFingerprints)) return null;
+  return record.value;
+}
+function setCachedUsageValue(cache, key, kind, fingerprint, value, dependencyFingerprints = []) {
+  cache.entries[key] = {
+    kind,
+    fingerprint,
+    dependencyFingerprints,
+    value,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createEmptyUsageCache() {
+  return {
+    schemaVersion: USAGE_CACHE_SCHEMA_VERSION,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    entries: {}
+  };
+}
+function isUsageCache(value) {
+  const candidate = value;
+  return candidate?.schemaVersion === USAGE_CACHE_SCHEMA_VERSION && candidate.entries !== null && typeof candidate.entries === "object";
+}
+async function readUsageCacheFile() {
+  try {
+    const content = await fs.readFile(getUsageCachePath(), "utf-8");
+    const parsed = JSON.parse(content);
+    if (!isUsageCache(parsed)) return createEmptyUsageCache();
+    return parsed;
+  } catch {
+    return createEmptyUsageCache();
+  }
+}
+async function readUsageCacheForLookup(options = {}) {
+  if (!shouldUsePersistentUsageCache(options) || options.refreshCache) {
+    return createEmptyUsageCache();
+  }
+  return readUsageCacheFile();
+}
+async function writeUsageCacheFile(cache) {
+  const cachePath = getUsageCachePath();
+  await fs.mkdir(dirname(cachePath), { recursive: true });
+  const tmpPath = `${cachePath}.${process.pid}.${Date.now()}.tmp`;
+  cache.generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await fs.writeFile(tmpPath, `${JSON.stringify(cache, null, 2)}
+`, "utf-8");
+  await fs.rename(tmpPath, cachePath);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withUsageCacheLock(task) {
+  const lockPath = `${getUsageCachePath()}.lock`;
+  await fs.mkdir(dirname(lockPath), { recursive: true });
+  const start = Date.now();
+  let lockHandle = null;
+  while (!lockHandle) {
+    try {
+      lockHandle = await fs.open(lockPath, "wx");
+    } catch (error) {
+      const code = error.code;
+      if (code !== "EEXIST" || Date.now() - start >= CACHE_LOCK_TIMEOUT_MS) {
+        return;
+      }
+      try {
+        const lockStats = await fs.stat(lockPath);
+        if (Date.now() - lockStats.mtimeMs > CACHE_LOCK_STALE_MS) {
+          await fs.unlink(lockPath);
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      await sleep(CACHE_LOCK_RETRY_MS);
+    }
+  }
+  try {
+    await task();
+  } finally {
+    try {
+      await lockHandle.close();
+    } catch {
+    }
+    try {
+      await fs.unlink(lockPath);
+    } catch {
+    }
+  }
+}
+async function updateUsageCache(options, mutator) {
+  if (!shouldUsePersistentUsageCache(options)) return;
+  cacheWriteQueue = cacheWriteQueue.then(() => withUsageCacheLock(async () => {
+    const cache = await readUsageCacheFile();
+    mutator(cache);
+    await writeUsageCacheFile(cache);
+  })).catch(() => {
+  });
+  await cacheWriteQueue;
+}
+
 // src/anthropic-sources.ts
 var execFileAsync = promisify(execFile);
 var SQLITE_SEPARATOR = "";
 var SQLITE_MAX_BUFFER = 64 * 1024 * 1024;
 var FILE_PARSE_CONCURRENCY = getRecommendedConcurrency();
 var anthropicEntryCache = /* @__PURE__ */ new Map();
+var CLAUDE_JSONL_CACHE_KIND = "claude-jsonl";
+var FACTORY_SETTINGS_CACHE_KIND = "factory-settings";
+var OPENCODE_DB_CACHE_KIND = "opencode-db";
 function toLocalDateString(isoTimestamp) {
   const date = new Date(isoTimestamp);
   const year = date.getFullYear();
@@ -949,7 +1105,7 @@ function toLocalDateString(isoTimestamp) {
 }
 async function pathExists(path) {
   try {
-    await fs.access(path);
+    await fs2.access(path);
     return true;
   } catch {
     return false;
@@ -957,7 +1113,7 @@ async function pathExists(path) {
 }
 async function safeRealpath(path) {
   try {
-    return await fs.realpath(path);
+    return await fs2.realpath(path);
   } catch {
     return path;
   }
@@ -967,17 +1123,17 @@ async function findFiles(dir, matcher, visited = /* @__PURE__ */ new Set(), resu
   const realPath = await safeRealpath(dir);
   if (visited.has(realPath)) return result;
   visited.add(realPath);
-  let entries2;
+  let entries;
   try {
-    entries2 = await fs.readdir(dir);
+    entries = await fs2.readdir(dir);
   } catch {
     return result;
   }
-  for (const entry of entries2) {
-    const fullPath = join(dir, entry);
+  for (const entry of entries) {
+    const fullPath = join2(dir, entry);
     let stat;
     try {
-      stat = await fs.stat(fullPath);
+      stat = await fs2.stat(fullPath);
     } catch {
       continue;
     }
@@ -1019,36 +1175,99 @@ function calculateKnownCost(modelName, inputTokens, outputTokens, cacheWriteToke
 function entryTotalTokens(entry) {
   return entry.inputTokens + entry.outputTokens + entry.cacheWriteTokens + entry.cacheReadTokens;
 }
+function getPersistentCacheKey(kind, filePath) {
+  return `${kind}:${filePath}`;
+}
+function isPathWithin(path, root) {
+  const normalizedRoot = root.endsWith("/") ? root : `${root}/`;
+  return path === root || path.startsWith(normalizedRoot);
+}
+function toCachedAnthropicEntry(entry) {
+  return {
+    timestamp: entry.timestamp,
+    rawModel: entry.rawModel,
+    inputTokens: entry.inputTokens,
+    outputTokens: entry.outputTokens,
+    cacheWriteTokens: entry.cacheWriteTokens,
+    cacheReadTokens: entry.cacheReadTokens,
+    explicitCost: entry.explicitCost,
+    messageCount: entry.messageCount,
+    sourceKey: entry.sourceKey,
+    sessionId: entry.sessionId,
+    sessionKind: entry.sessionKind,
+    subagentId: entry.subagentId
+  };
+}
+function rehydrateAnthropicEntry(entry) {
+  return {
+    date: toLocalDateString(entry.timestamp),
+    timestamp: entry.timestamp,
+    rawModel: entry.rawModel,
+    model: getModelDisplayName(entry.rawModel),
+    inputTokens: entry.inputTokens,
+    outputTokens: entry.outputTokens,
+    cacheWriteTokens: entry.cacheWriteTokens,
+    cacheReadTokens: entry.cacheReadTokens,
+    cost: calculateKnownCost(
+      entry.rawModel,
+      entry.inputTokens,
+      entry.outputTokens,
+      entry.cacheWriteTokens,
+      entry.cacheReadTokens,
+      entry.explicitCost
+    ),
+    messageCount: entry.messageCount,
+    source: "claude",
+    sourceKey: entry.sourceKey,
+    sessionId: entry.sessionId,
+    sessionKind: entry.sessionKind,
+    subagentId: entry.subagentId
+  };
+}
+function rehydrateAnthropicEntries(entries) {
+  return entries.map(rehydrateAnthropicEntry);
+}
+function cacheAnthropicEntries(entries) {
+  return entries.map((entry) => toCachedAnthropicEntry(entry));
+}
+async function getOpenCodeDependencyFingerprints(dbPath) {
+  const walPath = `${dbPath}-wal`;
+  const shmPath = `${dbPath}-shm`;
+  return [
+    await getSourceFingerprint(walPath) || createMissingFingerprint(walPath),
+    await getSourceFingerprint(shmPath) || createMissingFingerprint(shmPath)
+  ];
+}
 async function resolveProjectDir(projectsDir, cwd) {
   let current = cwd;
   while (current && current !== "/") {
     const encoded = current.replace(/\//g, "-");
-    const candidate = join(projectsDir, encoded);
+    const candidate = join2(projectsDir, encoded);
     if (await pathExists(candidate)) return candidate;
-    const parent = join(current, "..");
+    const parent = join2(current, "..");
     if (parent === current) break;
     current = parent;
   }
   return null;
 }
 function getClaudeDir() {
-  return process.env.CLAUDE_HOME || join(homedir(), ".claude");
+  return process.env.CLAUDE_HOME || join2(homedir2(), ".claude");
 }
 function getOpenCodeDbPath() {
   if (process.env.OPENCODE_DB_PATH) {
     return process.env.OPENCODE_DB_PATH;
   }
-  return join(homedir(), ".local", "share", "opencode", "opencode.db");
+  return join2(homedir2(), ".local", "share", "opencode", "opencode.db");
 }
 function getFactorySessionsDir() {
   if (process.env.FACTORY_SESSIONS_DIR) {
     return process.env.FACTORY_SESSIONS_DIR;
   }
-  return join(homedir(), ".factory", "sessions");
+  return join2(homedir2(), ".factory", "sessions");
 }
 async function claudeCompatibleDataExists() {
   const [claudeProjects, opencodeDb, factorySessions] = await Promise.all([
-    pathExists(join(getClaudeDir(), "projects")),
+    pathExists(join2(getClaudeDir(), "projects")),
     pathExists(getOpenCodeDbPath()),
     pathExists(getFactorySessionsDir())
   ]);
@@ -1060,12 +1279,14 @@ function getAnthropicEntryCacheKey(options) {
     opencodeDbPath: getOpenCodeDbPath(),
     factorySessionsDir: getFactorySessionsDir(),
     projectFilter: options.projectFilter || "",
-    families: options.families || []
+    families: options.families || [],
+    useCache: options.useCache !== false,
+    refreshCache: options.refreshCache === true
   });
 }
 async function parseClaudeProjectFile(filePath) {
   try {
-    const content = await fs.readFile(filePath, "utf-8");
+    const content = await fs2.readFile(filePath, "utf-8");
     const lines = content.split("\n");
     const fallbackSessionId = basename(filePath, ".jsonl");
     const isSubagentFile = filePath.includes("/subagents/");
@@ -1116,27 +1337,70 @@ async function parseClaudeProjectFile(filePath) {
     return [];
   }
 }
-async function parseClaudeProjectEntries(projectFilter) {
+async function parseClaudeProjectEntries(projectFilter, cacheOptions = {}) {
   const claudeDir = getClaudeDir();
-  const projectsDir = join(claudeDir, "projects");
+  const projectsDir = join2(claudeDir, "projects");
   if (!await pathExists(projectsDir)) return [];
   let searchDir = projectsDir;
   if (projectFilter) {
     const resolved = await resolveProjectDir(projectsDir, projectFilter);
-    if (!resolved) return entries;
+    if (!resolved) return [];
     searchDir = resolved;
   }
   const jsonlFiles = await findFiles(searchDir, (entry) => entry.endsWith(".jsonl"));
+  const persistentCache = await readUsageCacheForLookup(cacheOptions);
+  const retainedKeys = /* @__PURE__ */ new Set();
+  const updates = [];
   const parsedFiles = await mapWithConcurrency(
     jsonlFiles,
     FILE_PARSE_CONCURRENCY,
-    (filePath) => parseClaudeProjectFile(filePath)
+    async (filePath) => {
+      const fingerprint = await getSourceFingerprint(filePath);
+      if (!fingerprint) return [];
+      const key = getPersistentCacheKey(CLAUDE_JSONL_CACHE_KIND, filePath);
+      retainedKeys.add(key);
+      const cached = getCachedUsageValue(persistentCache, key, fingerprint);
+      if (cached) {
+        return rehydrateAnthropicEntries(cached);
+      }
+      const entries = await parseClaudeProjectFile(filePath);
+      updates.push({ key, fingerprint, value: cacheAnthropicEntries(entries) });
+      return entries;
+    }
   );
+  await updateUsageCache(cacheOptions, (cache) => {
+    for (const [key, record] of Object.entries(cache.entries)) {
+      if (record.kind === CLAUDE_JSONL_CACHE_KIND && isPathWithin(record.fingerprint.path, searchDir) && !retainedKeys.has(key)) {
+        delete cache.entries[key];
+      }
+    }
+    for (const update of updates) {
+      setCachedUsageValue(cache, update.key, CLAUDE_JSONL_CACHE_KIND, update.fingerprint, update.value);
+    }
+  });
   return parsedFiles.flat();
 }
-async function parseOpenCodeEntries() {
+async function parseOpenCodeEntries(cacheOptions = {}) {
   const dbPath = getOpenCodeDbPath();
-  if (!await pathExists(dbPath)) return [];
+  const key = getPersistentCacheKey(OPENCODE_DB_CACHE_KIND, dbPath);
+  const fingerprint = await getSourceFingerprint(dbPath);
+  if (!fingerprint) {
+    await updateUsageCache(cacheOptions, (cache) => {
+      delete cache.entries[key];
+    });
+    return [];
+  }
+  const dependencyFingerprints = await getOpenCodeDependencyFingerprints(dbPath);
+  const persistentCache = await readUsageCacheForLookup(cacheOptions);
+  const cached = getCachedUsageValue(
+    persistentCache,
+    key,
+    fingerprint,
+    dependencyFingerprints
+  );
+  if (cached) {
+    return rehydrateAnthropicEntries(cached);
+  }
   const sql = `
     SELECT
       COALESCE(m.id, ''),
@@ -1165,7 +1429,7 @@ async function parseOpenCodeEntries() {
   } catch {
     return [];
   }
-  const entries2 = [];
+  const entries = [];
   for (const line of stdout.split("\n")) {
     if (!line.trim()) continue;
     const [
@@ -1190,7 +1454,7 @@ async function parseOpenCodeEntries() {
     const cacheReadTokens = Number(cacheReadText) || 0;
     const explicitCost = Number(costText) || 0;
     const sessionKind = parentId ? "subagent" : "main";
-    entries2.push({
+    entries.push({
       date: toLocalDateString(timestamp),
       timestamp,
       rawModel,
@@ -1200,6 +1464,7 @@ async function parseOpenCodeEntries() {
       cacheWriteTokens,
       cacheReadTokens,
       cost: calculateKnownCost(rawModel, inputTokens, outputTokens, cacheWriteTokens, cacheReadTokens, explicitCost),
+      explicitCost,
       messageCount: 1,
       source: "claude",
       sourceKey: "opencode",
@@ -1208,7 +1473,17 @@ async function parseOpenCodeEntries() {
       subagentId: sessionKind === "subagent" ? messageId || sessionId : void 0
     });
   }
-  return entries2;
+  await updateUsageCache(cacheOptions, (cache) => {
+    setCachedUsageValue(
+      cache,
+      key,
+      OPENCODE_DB_CACHE_KIND,
+      fingerprint,
+      cacheAnthropicEntries(entries),
+      dependencyFingerprints
+    );
+  });
+  return entries;
 }
 async function readFactorySessionMeta(sessionFilePath) {
   let messageCount = 0;
@@ -1216,7 +1491,7 @@ async function readFactorySessionMeta(sessionFilePath) {
   let sessionKind = "main";
   let subagentId;
   try {
-    const content = await fs.readFile(sessionFilePath, "utf-8");
+    const content = await fs2.readFile(sessionFilePath, "utf-8");
     for (const line of content.split("\n")) {
       if (!line.trim()) continue;
       try {
@@ -1242,13 +1517,33 @@ async function readFactorySessionMeta(sessionFilePath) {
   }
   return { messageCount: Math.max(messageCount, 1), timestamp, sessionKind, subagentId };
 }
-async function parseFactoryEntries() {
+async function parseFactoryEntries(cacheOptions = {}) {
   const sessionsDir = getFactorySessionsDir();
   if (!await pathExists(sessionsDir)) return [];
   const settingsFiles = await findFiles(sessionsDir, (entry) => entry.endsWith(".settings.json"));
+  const persistentCache = await readUsageCacheForLookup(cacheOptions);
+  const retainedKeys = /* @__PURE__ */ new Set();
+  const updates = [];
   const parsedFiles = await mapWithConcurrency(settingsFiles, FILE_PARSE_CONCURRENCY, async (settingsPath) => {
+    const fingerprint = await getSourceFingerprint(settingsPath);
+    if (!fingerprint) return null;
+    const sessionFilePath = settingsPath.replace(/\.settings\.json$/, ".jsonl");
+    const dependencyFingerprints = [
+      await getSourceFingerprint(sessionFilePath) || createMissingFingerprint(sessionFilePath)
+    ];
+    const key = getPersistentCacheKey(FACTORY_SETTINGS_CACHE_KIND, settingsPath);
+    retainedKeys.add(key);
+    const cached = getCachedUsageValue(
+      persistentCache,
+      key,
+      fingerprint,
+      dependencyFingerprints
+    );
+    if (cached) {
+      return rehydrateAnthropicEntries(cached);
+    }
     try {
-      const settings = JSON.parse(await fs.readFile(settingsPath, "utf-8"));
+      const settings = JSON.parse(await fs2.readFile(settingsPath, "utf-8"));
       const usage = settings.tokenUsage;
       const configuredModel = settings.model;
       if (!usage || !configuredModel) return null;
@@ -1259,12 +1554,11 @@ async function parseFactoryEntries() {
       const outputTokens = (usage.outputTokens || 0) + (usage.thinkingTokens || 0);
       const totalTokens = inputTokens + outputTokens + cacheWriteTokens + cacheReadTokens;
       if (totalTokens === 0) return null;
-      const sessionFilePath = settingsPath.replace(/\.settings\.json$/, ".jsonl");
       const sessionId = basename(settingsPath, ".settings.json");
       const meta = await readFactorySessionMeta(sessionFilePath);
       const timestamp = settings.providerLockTimestamp || meta.timestamp;
       if (!timestamp) return null;
-      return {
+      const entry = {
         date: toLocalDateString(timestamp),
         timestamp,
         rawModel,
@@ -1281,11 +1575,35 @@ async function parseFactoryEntries() {
         sessionKind: meta.sessionKind,
         subagentId: meta.subagentId
       };
+      updates.push({
+        key,
+        fingerprint,
+        dependencyFingerprints,
+        value: cacheAnthropicEntries([entry])
+      });
+      return entry;
     } catch {
       return null;
     }
   });
-  return parsedFiles.filter((entry) => entry !== null);
+  await updateUsageCache(cacheOptions, (cache) => {
+    for (const [key, record] of Object.entries(cache.entries)) {
+      if (record.kind === FACTORY_SETTINGS_CACHE_KIND && isPathWithin(record.fingerprint.path, sessionsDir) && !retainedKeys.has(key)) {
+        delete cache.entries[key];
+      }
+    }
+    for (const update of updates) {
+      setCachedUsageValue(
+        cache,
+        update.key,
+        FACTORY_SETTINGS_CACHE_KIND,
+        update.fingerprint,
+        update.value,
+        update.dependencyFingerprints
+      );
+    }
+  });
+  return parsedFiles.flat().filter((entry) => entry !== null);
 }
 async function collectAnthropicUsageEntries(options = {}) {
   const cacheKey = getAnthropicEntryCacheKey(options);
@@ -1295,22 +1613,22 @@ async function collectAnthropicUsageEntries(options = {}) {
   }
   const loadPromise = (async () => {
     const [claudeEntries, opencodeEntries, factoryEntries] = await Promise.all([
-      parseClaudeProjectEntries(options.projectFilter),
-      parseOpenCodeEntries(),
-      parseFactoryEntries()
+      parseClaudeProjectEntries(options.projectFilter, options),
+      parseOpenCodeEntries(options),
+      parseFactoryEntries(options)
     ]);
-    const entries2 = [...claudeEntries, ...opencodeEntries, ...factoryEntries];
+    const entries = [...claudeEntries, ...opencodeEntries, ...factoryEntries];
     if (!options.families || options.families.length === 0) {
-      return entries2;
+      return entries;
     }
-    return entries2.filter((entry) => matchesModelFamilies(entry.rawModel, options.families));
+    return entries.filter((entry) => matchesModelFamilies(entry.rawModel, options.families));
   })();
   anthropicEntryCache.set(cacheKey, loadPromise);
   return loadPromise;
 }
 async function loadClaudeStatsFromJsonl(options = {}) {
-  const entries2 = await collectAnthropicUsageEntries(options);
-  if (entries2.length === 0) {
+  const entries = await collectAnthropicUsageEntries(options);
+  if (entries.length === 0) {
     return null;
   }
   const modelUsage = /* @__PURE__ */ new Map();
@@ -1321,7 +1639,7 @@ async function loadClaudeStatsFromJsonl(options = {}) {
   const hourCounts = {};
   let firstTimestamp = null;
   let totalMessages = 0;
-  for (const entry of entries2) {
+  for (const entry of entries) {
     const existing = modelUsage.get(entry.rawModel) ?? {
       inputTokens: 0,
       outputTokens: 0,
@@ -1386,13 +1704,14 @@ async function loadClaudeStatsFromJsonl(options = {}) {
 }
 
 // src/codex-loader.ts
-import { promises as fs2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
+import { promises as fs3 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
 var FILE_PARSE_CONCURRENCY2 = getRecommendedConcurrency();
 var codexParseCache = /* @__PURE__ */ new Map();
+var CODEX_JSONL_CACHE_KIND = "codex-jsonl";
 function getCodexDir() {
-  return process.env.CODEX_HOME || join2(homedir2(), ".codex");
+  return process.env.CODEX_HOME || join3(homedir3(), ".codex");
 }
 function toLocalDateString2(isoTimestamp) {
   const date = new Date(isoTimestamp);
@@ -1403,7 +1722,7 @@ function toLocalDateString2(isoTimestamp) {
 }
 async function pathExists2(path) {
   try {
-    await fs2.access(path);
+    await fs3.access(path);
     return true;
   } catch {
     return false;
@@ -1412,24 +1731,24 @@ async function pathExists2(path) {
 async function codexDataExists() {
   const codexDir = getCodexDir();
   if (!await pathExists2(codexDir)) return false;
-  const sessionsDir = join2(codexDir, "sessions");
-  const archivedDir = join2(codexDir, "archived_sessions");
+  const sessionsDir = join3(codexDir, "sessions");
+  const archivedDir = join3(codexDir, "archived_sessions");
   return await pathExists2(sessionsDir) || await pathExists2(archivedDir);
 }
 async function findJsonlFiles(dir) {
   const files = [];
   if (!await pathExists2(dir)) return files;
-  let entries2;
+  let entries;
   try {
-    entries2 = await fs2.readdir(dir);
+    entries = await fs3.readdir(dir);
   } catch {
     return files;
   }
-  for (const entry of entries2) {
-    const fullPath = join2(dir, entry);
+  for (const entry of entries) {
+    const fullPath = join3(dir, entry);
     let stat;
     try {
-      stat = await fs2.stat(fullPath);
+      stat = await fs3.stat(fullPath);
     } catch {
       continue;
     }
@@ -1441,15 +1760,110 @@ async function findJsonlFiles(dir) {
   }
   return files;
 }
-function getCodexParseCacheKey(families) {
+function getPersistentCacheKey2(kind, filePath) {
+  return `${kind}:${filePath}`;
+}
+function isPathWithin2(path, root) {
+  const normalizedRoot = root.endsWith("/") ? root : `${root}/`;
+  return path === root || path.startsWith(normalizedRoot);
+}
+function toCachedCodexUsageEntry(entry) {
+  return {
+    timestamp: entry.timestamp,
+    rawModel: entry.rawModel,
+    inputTokens: entry.inputTokens,
+    outputTokens: entry.outputTokens,
+    cacheReadTokens: entry.cacheReadTokens,
+    reasoningTokens: entry.reasoningTokens,
+    messageCount: entry.messageCount,
+    sessionId: entry.sessionId,
+    sessionKind: entry.sessionKind,
+    subagentId: entry.subagentId
+  };
+}
+function rehydrateCodexUsageEntry(entry) {
+  const pricing = getCodexModelPricing(entry.rawModel);
+  return {
+    date: toLocalDateString2(entry.timestamp),
+    timestamp: entry.timestamp,
+    model: getCodexModelDisplayName(entry.rawModel),
+    rawModel: entry.rawModel,
+    inputTokens: entry.inputTokens,
+    outputTokens: entry.outputTokens,
+    cacheReadTokens: entry.cacheReadTokens,
+    reasoningTokens: entry.reasoningTokens,
+    cost: entry.inputTokens * pricing.input / 1e6 + entry.outputTokens * pricing.output / 1e6 + entry.cacheReadTokens * pricing.cachedInput / 1e6,
+    messageCount: entry.messageCount,
+    sessionId: entry.sessionId,
+    sessionKind: entry.sessionKind,
+    subagentId: entry.subagentId,
+    source: "codex",
+    sourceKey: "codex"
+  };
+}
+function toCachedParsedCodexFile(parsed) {
+  return {
+    session: parsed.session,
+    rawEntries: parsed.rawEntries.map(toCachedCodexUsageEntry)
+  };
+}
+function rehydrateParsedCodexFile(cached) {
+  return {
+    session: cached.session,
+    rawEntries: cached.rawEntries.map(rehydrateCodexUsageEntry)
+  };
+}
+function filterParsedCodexFileByFamilies(parsed, families) {
+  if (!families || families.length === 0) {
+    return parsed;
+  }
+  const filteredPerModelUsage = {};
+  const summedUsage = {
+    input_tokens: 0,
+    cached_input_tokens: 0,
+    output_tokens: 0,
+    reasoning_output_tokens: 0,
+    total_tokens: 0
+  };
+  let primaryModel = parsed.session.model;
+  let maxTokens = 0;
+  for (const [model, usage] of Object.entries(parsed.session.perModelUsage || {})) {
+    if (!matchesModelFamilies(model, families)) continue;
+    filteredPerModelUsage[model] = usage;
+    summedUsage.input_tokens += usage.input_tokens;
+    summedUsage.cached_input_tokens += usage.cached_input_tokens;
+    summedUsage.output_tokens += usage.output_tokens;
+    summedUsage.reasoning_output_tokens += usage.reasoning_output_tokens;
+    summedUsage.total_tokens += usage.total_tokens;
+    if (usage.total_tokens > maxTokens) {
+      maxTokens = usage.total_tokens;
+      primaryModel = model;
+    }
+  }
+  if (Object.keys(filteredPerModelUsage).length === 0) {
+    return null;
+  }
+  return {
+    session: {
+      ...parsed.session,
+      model: primaryModel,
+      tokenUsage: summedUsage,
+      perModelUsage: filteredPerModelUsage
+    },
+    rawEntries: parsed.rawEntries.filter((entry) => matchesModelFamilies(entry.rawModel, families))
+  };
+}
+function getCodexParseCacheKey(options) {
   return JSON.stringify({
     codexDir: getCodexDir(),
-    families: families || []
+    families: options.families || [],
+    useCache: options.useCache !== false,
+    refreshCache: options.refreshCache === true
   });
 }
 async function parseSessionFile(filePath, families) {
   try {
-    const content = await fs2.readFile(filePath, "utf-8");
+    const content = await fs3.readFile(filePath, "utf-8");
     const lines = content.trim().split("\n");
     let sessionMeta = null;
     let currentModel = "gpt-5";
@@ -1568,28 +1982,66 @@ async function parseSessionFile(filePath, families) {
   }
 }
 async function collectParsedCodexFiles(options = {}) {
-  const cacheKey = getCodexParseCacheKey(options.families);
+  const cacheKey = getCodexParseCacheKey(options);
   const cached = codexParseCache.get(cacheKey);
   if (cached) {
     return cached;
   }
   const loadPromise = (async () => {
     const codexDir = getCodexDir();
-    const sessionsDir = join2(codexDir, "sessions");
-    const archivedDir = join2(codexDir, "archived_sessions");
+    const sessionsDir = join3(codexDir, "sessions");
+    const archivedDir = join3(codexDir, "archived_sessions");
     const [sessionFiles, archivedFiles] = await Promise.all([
       findJsonlFiles(sessionsDir),
       findJsonlFiles(archivedDir)
     ]);
     const jsonlFiles = [...sessionFiles, ...archivedFiles];
     if (jsonlFiles.length === 0) {
+      await updateUsageCache(options, (cache) => {
+        for (const [key, record] of Object.entries(cache.entries)) {
+          if (record.kind === CODEX_JSONL_CACHE_KIND && (isPathWithin2(record.fingerprint.path, sessionsDir) || isPathWithin2(record.fingerprint.path, archivedDir))) {
+            delete cache.entries[key];
+          }
+        }
+      });
       return [];
     }
+    const persistentCache = await readUsageCacheForLookup(options);
+    const retainedKeys = /* @__PURE__ */ new Set();
+    const updates = [];
     const parsedFiles = await mapWithConcurrency(
       jsonlFiles,
       FILE_PARSE_CONCURRENCY2,
-      (file) => parseSessionFile(file, options.families)
+      async (file) => {
+        const fingerprint = await getSourceFingerprint(file);
+        if (!fingerprint) return null;
+        const key = getPersistentCacheKey2(CODEX_JSONL_CACHE_KIND, file);
+        retainedKeys.add(key);
+        const cached2 = getCachedUsageValue(persistentCache, key, fingerprint);
+        if (cached2) {
+          const parsed2 = rehydrateParsedCodexFile(cached2);
+          return filterParsedCodexFileByFamilies(parsed2, options.families);
+        }
+        const parsed = await parseSessionFile(file, options.families);
+        if (parsed) {
+          const fullParsed = options.families && options.families.length > 0 ? await parseSessionFile(file) : parsed;
+          if (fullParsed) {
+            updates.push({ key, fingerprint, value: toCachedParsedCodexFile(fullParsed) });
+          }
+        }
+        return parsed;
+      }
     );
+    await updateUsageCache(options, (cache) => {
+      for (const [key, record] of Object.entries(cache.entries)) {
+        if (record.kind === CODEX_JSONL_CACHE_KIND && (isPathWithin2(record.fingerprint.path, sessionsDir) || isPathWithin2(record.fingerprint.path, archivedDir)) && !retainedKeys.has(key)) {
+          delete cache.entries[key];
+        }
+      }
+      for (const update of updates) {
+        setCachedUsageValue(cache, update.key, CODEX_JSONL_CACHE_KIND, update.fingerprint, update.value);
+      }
+    });
     return parsedFiles.filter((entry) => entry !== null);
   })();
   codexParseCache.set(cacheKey, loadPromise);
@@ -1690,8 +2142,8 @@ async function loadCodexStats(options = {}) {
 function normalizePresentableModelName(modelName) {
   return getModelDisplayName(modelName).trim();
 }
-function normalizeEntryModels(entries2) {
-  return entries2.map((entry) => ({
+function normalizeEntryModels(entries) {
+  return entries.map((entry) => ({
     ...entry,
     model: normalizePresentableModelName(entry.model)
   }));
@@ -1703,9 +2155,9 @@ function toLocalDateString3(isoTimestamp) {
   const day = String(date.getDate()).padStart(2, "0");
   return `${year}-${month}-${day}`;
 }
-async function parseClaudeJsonl(projectFilter, families) {
-  const entries2 = await collectAnthropicUsageEntries({ projectFilter, families });
-  return entries2.map((entry) => ({
+async function parseClaudeJsonl(projectFilter, families, cacheOptions = {}) {
+  const entries = await collectAnthropicUsageEntries({ projectFilter, families, ...cacheOptions });
+  return entries.map((entry) => ({
     date: entry.date,
     model: entry.model,
     rawModel: entry.rawModel,
@@ -1723,9 +2175,9 @@ async function parseClaudeJsonl(projectFilter, families) {
     timestamp: entry.timestamp
   }));
 }
-async function parseCodexJsonl(families) {
-  const entries2 = await collectCodexUsageEntries({ families });
-  return entries2.map((entry) => ({
+async function parseCodexJsonl(families, cacheOptions = {}) {
+  const entries = await collectCodexUsageEntries({ families, ...cacheOptions });
+  return entries.map((entry) => ({
     date: entry.date,
     model: entry.model,
     rawModel: entry.rawModel,
@@ -1751,10 +2203,10 @@ function getSourceLabel(sourceKey, source) {
   if (key === "codex") return "Codex CLI";
   return key;
 }
-function computeSessionCounts(entries2) {
+function computeSessionCounts(entries) {
   const mainSessions = /* @__PURE__ */ new Set();
   const subagentSessions = /* @__PURE__ */ new Set();
-  for (const entry of entries2) {
+  for (const entry of entries) {
     const sourceKey = entry.sourceKey || entry.source;
     if (entry.sessionId) {
       mainSessions.add(`${sourceKey}:${entry.sessionId}`);
@@ -1769,8 +2221,8 @@ function computeSessionCounts(entries2) {
     total: mainSessions.size + subagentSessions.size
   };
 }
-function filterByDateRange(entries2, since, until) {
-  return entries2.filter((e) => {
+function filterByDateRange(entries, since, until) {
+  return entries.filter((e) => {
     if (since && e.date < since) return false;
     if (until && e.date > until) return false;
     return true;
@@ -1797,9 +2249,9 @@ function sortModelsByTier(models) {
     return priorityB - priorityA;
   });
 }
-function aggregateByDay(entries2) {
+function aggregateByDay(entries) {
   const dayMap = /* @__PURE__ */ new Map();
-  for (const e of entries2) {
+  for (const e of entries) {
     const entryTotal = e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens;
     const existing = dayMap.get(e.date);
     if (existing) {
@@ -1828,9 +2280,9 @@ function aggregateByDay(entries2) {
     models: sortModelsByTier(Array.from(modelsSet))
   })).sort((a, b) => a.key.localeCompare(b.key));
 }
-function aggregateByMonth(entries2) {
+function aggregateByMonth(entries) {
   const monthMap = /* @__PURE__ */ new Map();
-  for (const e of entries2) {
+  for (const e of entries) {
     const month = e.date.slice(0, 7);
     const entryTotal = e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens;
     const existing = monthMap.get(month);
@@ -1860,9 +2312,9 @@ function aggregateByMonth(entries2) {
     models: sortModelsByTier(Array.from(modelsSet))
   })).sort((a, b) => a.key.localeCompare(b.key));
 }
-function aggregateByModel(entries2) {
+function aggregateByModel(entries) {
   const modelMap = /* @__PURE__ */ new Map();
-  for (const e of entries2) {
+  for (const e of entries) {
     const entryTotal = e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens;
     if (entryTotal <= 0) continue;
     const existing = modelMap.get(e.model);
@@ -1887,9 +2339,9 @@ function aggregateByModel(entries2) {
   }
   return Array.from(modelMap.values()).sort((a, b) => b.totalTokens - a.totalTokens);
 }
-function aggregateBySession(entries2) {
+function aggregateBySession(entries) {
   const sessionMap = /* @__PURE__ */ new Map();
-  for (const e of entries2) {
+  for (const e of entries) {
     const sourceKey = e.sourceKey || e.source;
     const sid = e.sessionId ? `${sourceKey}:${e.sessionId}` : "unknown";
     const entryTotal = e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens;
@@ -1947,9 +2399,9 @@ function computeTotals(rows) {
     { inputTokens: 0, outputTokens: 0, cacheWriteTokens: 0, cacheReadTokens: 0, totalTokens: 0, cost: 0 }
   );
 }
-function computeModelBreakdown(entries2) {
+function computeModelBreakdown(entries) {
   const modelMap = /* @__PURE__ */ new Map();
-  for (const e of entries2) {
+  for (const e of entries) {
     const total = e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens;
     if (total <= 0) continue;
     const existing = modelMap.get(e.model);
@@ -1968,10 +2420,10 @@ function computeModelBreakdown(entries2) {
     percentage: totalTokens > 0 ? Math.round(data.tokens / totalTokens * 100) : 0
   })).sort((a, b) => b.tokens - a.tokens);
 }
-function computeSourceBreakdown(entries2) {
+function computeSourceBreakdown(entries) {
   const sourceMap = /* @__PURE__ */ new Map();
   const sessionsBySource = /* @__PURE__ */ new Map();
-  for (const entry of entries2) {
+  for (const entry of entries) {
     const sourceKey = entry.sourceKey || entry.source;
     const label = getSourceLabel(entry.sourceKey, entry.source);
     const total = entry.inputTokens + entry.outputTokens + entry.cacheWriteTokens + entry.cacheReadTokens;
@@ -2001,9 +2453,9 @@ function computeSourceBreakdown(entries2) {
     percentage: totalTokens > 0 ? Math.round(source.tokens / totalTokens * 100) : 0
   })).sort((a, b) => b.tokens - a.tokens);
 }
-function computeActivityStats(entries2, source) {
+function computeActivityStats(entries, source) {
   const dayMap = /* @__PURE__ */ new Map();
-  for (const entry of entries2) {
+  for (const entry of entries) {
     const existing = dayMap.get(entry.date);
     if (existing) {
       existing.inputTokens += entry.inputTokens;
@@ -2026,7 +2478,7 @@ function computeActivityStats(entries2, source) {
     }
   }
   const sessionMap = /* @__PURE__ */ new Map();
-  for (const entry of entries2) {
+  for (const entry of entries) {
     if (!entry.sessionId) continue;
     const sessions = sessionMap.get(entry.date) || /* @__PURE__ */ new Set();
     sessions.add(`${entry.source}:${entry.sessionId}`);
@@ -2065,33 +2517,34 @@ function computeActivityStats(entries2, source) {
     },
     days,
     totals,
-    modelBreakdown: computeModelBreakdown(entries2),
-    sessionCounts: computeSessionCounts(entries2),
-    sourceBreakdown: computeSourceBreakdown(entries2)
+    modelBreakdown: computeModelBreakdown(entries),
+    sessionCounts: computeSessionCounts(entries),
+    sourceBreakdown: computeSourceBreakdown(entries)
   };
 }
 async function loadUsageStats(options) {
   const { aggregation, since, until, codexOnly, combined, projectFilter, families } = options;
-  let entries2 = [];
+  const cacheOptions = { useCache: options.useCache, refreshCache: options.refreshCache };
+  let entries = [];
   if (!codexOnly) {
-    entries2 = entries2.concat(await parseClaudeJsonl(projectFilter, families));
+    entries = entries.concat(await parseClaudeJsonl(projectFilter, families, cacheOptions));
   }
   if (codexOnly || combined) {
-    entries2 = entries2.concat(await parseCodexJsonl(families));
+    entries = entries.concat(await parseCodexJsonl(families, cacheOptions));
   }
-  if (entries2.length === 0) {
+  if (entries.length === 0) {
     return null;
   }
-  entries2 = normalizeEntryModels(entries2);
+  entries = normalizeEntryModels(entries);
   if (families && families.length > 0) {
-    entries2 = entries2.filter((entry) => matchesModelFamilies(entry.rawModel || entry.model, families));
+    entries = entries.filter((entry) => matchesModelFamilies(entry.rawModel || entry.model, families));
   }
-  entries2 = filterByDateRange(entries2, since, until);
-  entries2 = entries2.filter((e) => !e.model.toLowerCase().includes("synthetic"));
-  if (entries2.length === 0) {
+  entries = filterByDateRange(entries, since, until);
+  entries = entries.filter((e) => !e.model.toLowerCase().includes("synthetic"));
+  if (entries.length === 0) {
     return null;
   }
-  const dates = entries2.map((e) => e.date).sort();
+  const dates = entries.map((e) => e.date).sort();
   const dateRange = {
     start: dates[0],
     end: dates[dates.length - 1]
@@ -2099,26 +2552,26 @@ async function loadUsageStats(options) {
   let rows;
   switch (aggregation) {
     case "monthly":
-      rows = aggregateByMonth(entries2);
+      rows = aggregateByMonth(entries);
       break;
     case "model":
-      rows = aggregateByModel(entries2);
+      rows = aggregateByModel(entries);
       break;
     case "session":
-      rows = aggregateBySession(entries2);
+      rows = aggregateBySession(entries);
       break;
     case "total":
       rows = [];
       break;
     case "daily":
     default:
-      rows = aggregateByDay(entries2);
+      rows = aggregateByDay(entries);
       break;
   }
-  const totals = aggregation === "total" ? computeTotals(aggregateByDay(entries2)) : computeTotals(rows);
-  const modelBreakdown = computeModelBreakdown(entries2);
-  const sessionCounts = computeSessionCounts(entries2);
-  const sourceBreakdown = computeSourceBreakdown(entries2);
+  const totals = aggregation === "total" ? computeTotals(aggregateByDay(entries)) : computeTotals(rows);
+  const modelBreakdown = computeModelBreakdown(entries);
+  const sessionCounts = computeSessionCounts(entries);
+  const sourceBreakdown = computeSourceBreakdown(entries);
   let source = "claude";
   if (codexOnly) source = "codex";
   else if (combined) source = "combined";
@@ -2136,29 +2589,30 @@ async function loadUsageStats(options) {
 }
 async function loadActivityStats(options) {
   const { since, until, codexOnly, combined, projectFilter, families } = options;
-  let entries2 = [];
+  const cacheOptions = { useCache: options.useCache, refreshCache: options.refreshCache };
+  let entries = [];
   if (!codexOnly) {
-    entries2 = entries2.concat(await parseClaudeJsonl(projectFilter, families));
+    entries = entries.concat(await parseClaudeJsonl(projectFilter, families, cacheOptions));
   }
   if (codexOnly || combined) {
-    entries2 = entries2.concat(await parseCodexJsonl(families));
+    entries = entries.concat(await parseCodexJsonl(families, cacheOptions));
   }
-  if (entries2.length === 0) {
+  if (entries.length === 0) {
     return null;
   }
-  entries2 = normalizeEntryModels(entries2);
+  entries = normalizeEntryModels(entries);
   if (families && families.length > 0) {
-    entries2 = entries2.filter((entry) => matchesModelFamilies(entry.rawModel || entry.model, families));
+    entries = entries.filter((entry) => matchesModelFamilies(entry.rawModel || entry.model, families));
   }
-  entries2 = filterByDateRange(entries2, since, until);
-  entries2 = entries2.filter((entry) => !entry.model.toLowerCase().includes("synthetic"));
-  if (entries2.length === 0) {
+  entries = filterByDateRange(entries, since, until);
+  entries = entries.filter((entry) => !entry.model.toLowerCase().includes("synthetic"));
+  if (entries.length === 0) {
     return null;
   }
   let source = "claude";
   if (codexOnly) source = "codex";
   else if (combined) source = "combined";
-  const stats = computeActivityStats(entries2, source);
+  const stats = computeActivityStats(entries, source);
   stats.scopeLabel = formatModelFamilyLabel(families);
   return stats;
 }
@@ -2428,12 +2882,20 @@ async function loadData(options) {
   let codex = null;
   if (!codexOnly) {
     if (await claudeCompatibleDataExists()) {
-      claude = await loadClaudeStatsFromJsonl({ families });
+      claude = await loadClaudeStatsFromJsonl({
+        families,
+        useCache: options.useCache,
+        refreshCache: options.refreshCache
+      });
     }
   }
   if (codexOnly || combined) {
     if (await codexDataExists()) {
-      codex = await loadCodexStats({ families });
+      codex = await loadCodexStats({
+        families,
+        useCache: options.useCache,
+        refreshCache: options.refreshCache
+      });
     }
   }
   let source = "claude";
@@ -3052,15 +3514,15 @@ async function publishArtifact(artifact, baseUrl, legacyUrl) {
 }
 
 // src/claude-inspector.ts
-import { promises as fs3 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join3 } from "path";
+import { promises as fs4 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
 function getClaudeDir2() {
-  return process.env.CLAUDE_HOME || join3(homedir3(), ".claude");
+  return process.env.CLAUDE_HOME || join4(homedir4(), ".claude");
 }
 async function pathExists3(path) {
   try {
-    await fs3.access(path);
+    await fs4.access(path);
     return true;
   } catch {
     return false;
@@ -3068,7 +3530,7 @@ async function pathExists3(path) {
 }
 async function readJsonFile(path) {
   try {
-    const content = await fs3.readFile(path, "utf-8");
+    const content = await fs4.readFile(path, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -3076,17 +3538,17 @@ async function readJsonFile(path) {
 }
 async function walkFiles(dir, visitor) {
   if (!await pathExists3(dir)) return;
-  let entries2;
+  let entries;
   try {
-    entries2 = await fs3.readdir(dir);
+    entries = await fs4.readdir(dir);
   } catch {
     return;
   }
-  for (const entry of entries2) {
-    const fullPath = join3(dir, entry);
+  for (const entry of entries) {
+    const fullPath = join4(dir, entry);
     let stat;
     try {
-      stat = await fs3.stat(fullPath);
+      stat = await fs4.stat(fullPath);
     } catch {
       continue;
     }
@@ -3104,8 +3566,8 @@ function daysSince(dateStr) {
   const diffMs = Date.now() - parsed.getTime();
   return Math.max(0, Math.floor(diffMs / (24 * 60 * 60 * 1e3)));
 }
-async function inspectClaudeSystem(home = homedir3()) {
-  const path = join3(home, ".claude.json");
+async function inspectClaudeSystem(home = homedir4()) {
+  const path = join4(home, ".claude.json");
   const json = await readJsonFile(path);
   return {
     path,
@@ -3120,18 +3582,18 @@ async function inspectClaudeSystem(home = homedir3()) {
   };
 }
 async function inspectClaudeUsage(claudeDir = getClaudeDir2()) {
-  const statsCachePath = join3(claudeDir, "stats-cache.json");
+  const statsCachePath = join4(claudeDir, "stats-cache.json");
   const statsCache = await readJsonFile(statsCachePath);
-  const facetsDir = join3(claudeDir, "usage-data", "facets");
-  const sessionMetaDir = join3(claudeDir, "usage-data", "session-meta");
-  const projectsDir = join3(claudeDir, "projects");
-  const facetFiles = await pathExists3(facetsDir) ? (await fs3.readdir(facetsDir)).filter((file) => file.endsWith(".json")) : [];
-  const sessionMetaFiles = await pathExists3(sessionMetaDir) ? (await fs3.readdir(sessionMetaDir)).filter((file) => file.endsWith(".json")) : [];
+  const facetsDir = join4(claudeDir, "usage-data", "facets");
+  const sessionMetaDir = join4(claudeDir, "usage-data", "session-meta");
+  const projectsDir = join4(claudeDir, "projects");
+  const facetFiles = await pathExists3(facetsDir) ? (await fs4.readdir(facetsDir)).filter((file) => file.endsWith(".json")) : [];
+  const sessionMetaFiles = await pathExists3(sessionMetaDir) ? (await fs4.readdir(sessionMetaDir)).filter((file) => file.endsWith(".json")) : [];
   let rateLimitHit = 0;
   let apiTokenLimit = 0;
   let contextLimit = 0;
   for (const file of facetFiles) {
-    const json = await readJsonFile(join3(facetsDir, file));
+    const json = await readJsonFile(join4(facetsDir, file));
     const friction = json?.friction_counts || {};
     rateLimitHit += friction.rate_limit_hit || 0;
     apiTokenLimit += friction.api_token_limit || 0;
@@ -3141,7 +3603,7 @@ async function inspectClaudeUsage(claudeDir = getClaudeDir2()) {
   let inputTokens = 0;
   let outputTokens = 0;
   for (const file of sessionMetaFiles) {
-    const json = await readJsonFile(join3(sessionMetaDir, file));
+    const json = await readJsonFile(join4(sessionMetaDir, file));
     if (!json) continue;
     if (json.uses_task_agent) sessionsUsingTaskAgent += 1;
     inputTokens += json.input_tokens || 0;
@@ -3216,7 +3678,9 @@ var USAGE_COMMAND_FLAGS = /* @__PURE__ */ new Set([
   "metric",
   "model",
   "monthly",
+  "no-cache",
   "project",
+  "refresh-cache",
   "sessions",
   "share",
   "since",
@@ -3241,9 +3705,11 @@ var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "minimax",
   "model",
   "monthly",
+  "no-cache",
   "no-short",
   "project",
   "quiet",
+  "refresh-cache",
   "sessions",
   "share",
   "total",
@@ -3390,7 +3856,7 @@ function applyCliIntent(args, intent) {
 // src/limits/claude.ts
 import { execFile as execFile2 } from "child_process";
 import { randomUUID } from "crypto";
-import { dirname } from "path";
+import { dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 
 // src/limits/pace.ts
@@ -3760,13 +4226,13 @@ function execFileCommand(command, args, options = {}) {
     );
   });
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function resolveDefaultClaudeUsageCwd() {
   const envCwd = process.env.VIBESTATS_CLAUDE_USAGE_CWD ?? process.env.VIBESTATS_USAGE_CWD;
   if (envCwd?.trim()) return envCwd;
-  return dirname(fileURLToPath(import.meta.url));
+  return dirname2(fileURLToPath(import.meta.url));
 }
 async function captureUsageWithTmux(options) {
   const sessionName = `${TMUX_SESSION_PREFIX}-${randomUUID().replaceAll("-", "").slice(0, 16)}`;
@@ -3834,7 +4300,7 @@ async function fetchClaudeLimits(options = {}) {
       timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
       now,
       runCommand: options.runCommand ?? execFileCommand,
-      sleepFn: options.sleepFn ?? sleep
+      sleepFn: options.sleepFn ?? sleep2
     });
   } catch (error) {
     return {
@@ -4291,9 +4757,9 @@ function displayUsageLimits(limits, options = {}) {
 
 // src/config.ts
 import { readFileSync, existsSync, writeFileSync } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join4 } from "path";
-var CONFIG_PATH = join4(homedir4(), ".vibestats.json");
+import { homedir as homedir5 } from "os";
+import { join as join5 } from "path";
+var CONFIG_PATH = join5(homedir5(), ".vibestats.json");
 var DEFAULT_CONFIG = {
   baseUrl: "https://vibestats.wolfai.dev",
   outputFormat: "normal",
@@ -4381,6 +4847,24 @@ function getSelectedModelFamilies(args) {
   if (args.minimax === true) families.push("minimax");
   return families;
 }
+var cacheArgs = {
+  "no-cache": {
+    type: "boolean",
+    description: "Bypass the persistent local usage cache for this run",
+    default: false
+  },
+  "refresh-cache": {
+    type: "boolean",
+    description: "Rebuild the persistent local usage cache before showing stats",
+    default: false
+  }
+};
+function getUsageCacheOptions(args) {
+  return {
+    useCache: args["no-cache"] !== true,
+    refreshCache: args["refresh-cache"] === true
+  };
+}
 
 // src/index.ts
 function printCommandHelp(error) {
@@ -4539,7 +5023,7 @@ async function publishArtifactWithFallback(artifact, baseUrl, fallbackUrl, prefe
 var main = defineCommand({
   meta: {
     name: "vibestats",
-    version: "1.3.13",
+    version: "1.3.14",
     description: "AI coding stats - usage tracking and annual wrapped for Claude Code & Codex"
   },
   args: {
@@ -4664,6 +5148,7 @@ var main = defineCommand({
       description: "Disable shortlink generation",
       default: false
     },
+    ...cacheArgs,
     // Config management
     init: {
       type: "boolean",
@@ -4750,6 +5235,7 @@ async function runUsage(args, config) {
   else if (args.model) aggregation = "model";
   else if (args.total) aggregation = "total";
   const shouldShowSpinner = !args.json && !args.quiet;
+  const cacheOptions = getUsageCacheOptions(args);
   const statsPromise = loadUsageStats({
     aggregation,
     since,
@@ -4758,7 +5244,8 @@ async function runUsage(args, config) {
     combined: args.combined,
     projectFilter: args.project ? process.cwd() : void 0,
     families,
-    scopeLabel
+    scopeLabel,
+    ...cacheOptions
   });
   const stats = shouldShowSpinner ? await createSpinner("Loading vibestats...").whilePromise(statsPromise) : await statsPromise;
   if (!stats) {
@@ -4865,14 +5352,15 @@ async function runWrapped(args, config) {
   const scopeLabel = formatModelFamilyLabel(families);
   const metric = parseActivityMetric(args.metric);
   const days = parseActivityDays(args.days);
+  const cacheOptions = getUsageCacheOptions(args);
   const spinner = createSpinner("Preparing wrapped...");
   const [data, activityStats] = await spinner.whilePromise(
     Promise.all([
-      loadData({ codexOnly: args.codex, combined: args.combined, families, scopeLabel }),
-      loadActivityStats({ codexOnly: args.codex, combined: args.combined, families, scopeLabel })
+      loadData({ codexOnly: args.codex, combined: args.combined, families, scopeLabel, ...cacheOptions }),
+      loadActivityStats({ codexOnly: args.codex, combined: args.combined, families, scopeLabel, ...cacheOptions })
     ])
   );
-  validateData(data, { codexOnly: args.codex, combined: args.combined, families, scopeLabel });
+  validateData(data, { codexOnly: args.codex, combined: args.combined, families, scopeLabel, ...cacheOptions });
   let claudeStats = null;
   let codexStats = null;
   if (data.claude) {
@@ -4933,6 +5421,7 @@ async function runActivity(args, config) {
   const metric = parseActivityMetric(args.metric);
   const days = parseActivityDays(args.days);
   const spinner = createSpinner("Preparing activity graph...");
+  const cacheOptions = getUsageCacheOptions(args);
   const stats = await spinner.whilePromise(
     loadActivityStats({
       codexOnly: args.codex,
@@ -4941,7 +5430,8 @@ async function runActivity(args, config) {
       since: args.since,
       until: args.until,
       families,
-      scopeLabel
+      scopeLabel,
+      ...cacheOptions
     })
   );
   if (!stats) {