vibestats 1.3.8 → 1.3.9

package/README.md

@@ -21,6 +21,10 @@ vibestats --total      # Show only totals
 
 # Wrapped summary
 vibestats --wrapped    # Annual wrapped summary
+
+# Claude local diagnostics
+vibestats --claude-system
+vibestats --claude-limits
 ```
 
 ## CLI Flags
@@ -41,6 +45,8 @@ vibestats --wrapped    # Annual wrapped summary
 | `--quiet`, `-q` | Quiet output (totals line) |
 | `--share`, `-s` | Generate a shareable usage URL |
 | `--project`, `-p` | Current project only (Claude Code) |
+| `--claude-system` | Inspect `~/.claude.json` account and app state |
+| `--claude-limits` | Inspect `~/.claude/usage-data`, cache freshness, and local limit signals |
 
 ### Wrapped Mode
 
@@ -90,6 +96,20 @@ Creates `~/.vibestats.json`:
 | Claude Code | `~/.claude/projects/**/*.jsonl` |
 | OpenAI Codex | `~/.codex/sessions/*.jsonl` |
 
+Additional Claude diagnostic files:
+- `~/.claude.json`
+- `~/.claude/stats-cache.json`
+- `~/.claude/usage-data/session-meta/*.json`
+- `~/.claude/usage-data/facets/*.json`
+
+## Session Semantics
+
+- `sessions` means canonical top-level sessions
+- subagents are counted separately and shown as a compact session mix notice
+- token and cost totals still include subagent usage
+- Claude subagents are inferred from sidechain/session metadata
+- Codex subagents are inferred from spawned-thread metadata
+
 ## Requirements
 
 - Node.js 18+
@@ -97,7 +117,11 @@ Creates `~/.vibestats.json`:
 
 ## View Online
 
-Visit [vibestats.wolfai.dev](https://vibestats.wolfai.dev) to view your wrapped in the browser.
+Visit [vibestats.wolfai.dev](https://vibestats.wolfai.dev) to view shares in the browser.
+
+- [vibestats.wolfai.dev/wrapped](https://vibestats.wolfai.dev/wrapped)
+- [vibestats.wolfai.dev/activity](https://vibestats.wolfai.dev/activity)
+- [vibestats.wolfai.dev/changelog](https://vibestats.wolfai.dev/changelog)
 
 ## License
 

package/dist/index.js

@@ -635,7 +635,7 @@ function buildActivityGraph(stats, metric, requestedDays = 365) {
   };
 }
 function buildActivityTitle(source, metric) {
-  const sourceLabel = source === "codex" ? "Codex" : source === "combined" ? "AI Coding" : "Claude";
+  const sourceLabel = source === "codex" ? "Codex" : source === "combined" ? "AI Coding" : "Local AI";
   const metricLabel = metric === "tokens" ? "Activity" : metric === "sessions" ? "Session Activity" : "Message Activity";
   return `${sourceLabel} ${metricLabel}`;
 }
@@ -661,12 +661,38 @@ function buildActivityArtifact(stats, metric, requestedDays = 365) {
 }
 
 // src/usage/loader.ts
+import { promises as fs2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2, basename as basename2 } from "path";
+
+// src/anthropic-sources.ts
+import { execFile } from "child_process";
 import { promises as fs } from "fs";
 import { homedir } from "os";
-import { join, basename } from "path";
+import { basename, join } from "path";
+import { promisify } from "util";
 
 // src/pricing.ts
 var MODEL_PRICING = {
+  // Fireworks router pricing as of 2026-03-30:
+  // https://fireworks.ai/pricing
+  // Fireworks exposes a single "cached input" rate, so cache creation
+  // tokens are treated as regular input and cache reads use the discounted rate.
+  "accounts/fireworks/routers/kimi-k2p5-turbo": {
+    input: 0.99,
+    output: 4.94,
+    cacheWrite: 0.99,
+    cacheRead: 0.16
+  },
+  // Fireworks prices the MiniMax M2 family at one rate. We apply that
+  // official family pricing to MiniMax-M2.7 because Fireworks does not
+  // publish a distinct M2.7 per-token row.
+  "MiniMax-M2.7": {
+    input: 0.3,
+    output: 1.2,
+    cacheWrite: 0.3,
+    cacheRead: 0.03
+  },
   // Opus 4.6 (same pricing as Opus 4.5)
   "claude-opus-4-6-20260101": {
     input: 5,
@@ -730,10 +756,17 @@ var MODEL_PRICING = {
     cacheRead: 0.1
   }
 };
-function getModelPricing(modelName) {
+function tryGetModelPricing(modelName) {
   if (MODEL_PRICING[modelName]) {
     return MODEL_PRICING[modelName];
   }
+  const normalized = modelName.toLowerCase();
+  if (normalized.includes("kimi-k2p5-turbo")) {
+    return MODEL_PRICING["accounts/fireworks/routers/kimi-k2p5-turbo"];
+  }
+  if (normalized.includes("minimax-m2.7")) {
+    return MODEL_PRICING["MiniMax-M2.7"];
+  }
   if (modelName.includes("opus-4-6") || modelName.includes("opus-4.6")) {
     return MODEL_PRICING["claude-opus-4-6-20260101"];
   }
@@ -758,9 +791,16 @@ function getModelPricing(modelName) {
   if (modelName.includes("haiku")) {
     return MODEL_PRICING["claude-3-5-haiku-20241022"];
   }
-  return MODEL_PRICING["claude-sonnet-4-5-20250929"];
+  return null;
 }
 function getModelDisplayName(modelName) {
+  const normalized = modelName.toLowerCase();
+  if (normalized.includes("accounts/fireworks/routers/kimi-k2p5-turbo") || normalized.includes("custom:kimi-k2.5-turbo")) {
+    return "Kimi K2.5 Turbo";
+  }
+  if (normalized.includes("minimax-m2.7") || normalized.includes("custom:minimax-m2.7")) {
+    return "MiniMax-M2.7";
+  }
   if (modelName.includes("opus-4-6") || modelName.includes("opus-4.6")) return "Opus 4.6";
   if (modelName.includes("opus-4-5") || modelName.includes("opus-4.5")) return "Opus 4.5";
   if (modelName.includes("opus-4-1") || modelName.includes("opus-4.1")) return "Opus 4.1";
@@ -775,8 +815,10 @@ function getModelDisplayName(modelName) {
   return modelName;
 }
 
-// src/usage/loader.ts
-var MAX_RECURSION_DEPTH = 10;
+// src/anthropic-sources.ts
+var execFileAsync = promisify(execFile);
+var SQLITE_SEPARATOR = "";
+var SQLITE_MAX_BUFFER = 64 * 1024 * 1024;
 function toLocalDateString(isoTimestamp) {
   const date = new Date(isoTimestamp);
   const year = date.getFullYear();
@@ -784,12 +826,6 @@ function toLocalDateString(isoTimestamp) {
   const day = String(date.getDate()).padStart(2, "0");
   return `${year}-${month}-${day}`;
 }
-function getClaudeDir() {
-  return process.env.CLAUDE_HOME || join(homedir(), ".claude");
-}
-function getCodexDir() {
-  return process.env.CODEX_HOME || join(homedir(), ".codex");
-}
 async function pathExists(path) {
   try {
     await fs.access(path);
@@ -805,9 +841,8 @@ async function safeRealpath(path) {
     return path;
   }
 }
-async function findJsonlFiles(dir, visited = /* @__PURE__ */ new Set(), depth = 0, result = []) {
+async function findFiles(dir, matcher, visited = /* @__PURE__ */ new Set(), result = []) {
   if (!await pathExists(dir)) return result;
-  if (depth > MAX_RECURSION_DEPTH) return result;
   const realPath = await safeRealpath(dir);
   if (visited.has(realPath)) return result;
   visited.add(realPath);
@@ -826,13 +861,37 @@ async function findJsonlFiles(dir, visited = /* @__PURE__ */ new Set(), depth =
       continue;
     }
     if (stat.isDirectory()) {
-      await findJsonlFiles(fullPath, visited, depth + 1, result);
-    } else if (entry.endsWith(".jsonl")) {
+      await findFiles(fullPath, matcher, visited, result);
+    } else if (matcher(entry)) {
       result.push(fullPath);
     }
   }
   return result;
 }
+function normalizeAnthropicModelName(modelName) {
+  const trimmed = modelName.trim();
+  const normalized = trimmed.toLowerCase();
+  if (/^custom:minimax-m2\.7(?:-\d+)?$/.test(normalized)) {
+    return "MiniMax-M2.7";
+  }
+  if (/^custom:kimi-k2\.5-turbo(?:-\d+)?$/.test(normalized)) {
+    return "accounts/fireworks/routers/kimi-k2p5-turbo";
+  }
+  return trimmed;
+}
+function calculateKnownCost(modelName, inputTokens, outputTokens, cacheWriteTokens, cacheReadTokens, explicitCost) {
+  if (typeof explicitCost === "number" && explicitCost > 0) {
+    return explicitCost;
+  }
+  const pricing = tryGetModelPricing(modelName);
+  if (!pricing) {
+    return 0;
+  }
+  return inputTokens / 1e6 * pricing.input + outputTokens / 1e6 * pricing.output + cacheWriteTokens / 1e6 * pricing.cacheWrite + cacheReadTokens / 1e6 * pricing.cacheRead;
+}
+function entryTotalTokens(entry) {
+  return entry.inputTokens + entry.outputTokens + entry.cacheWriteTokens + entry.cacheReadTokens;
+}
 async function resolveProjectDir(projectsDir, cwd) {
   let current = cwd;
   while (current && current !== "/") {
@@ -845,79 +904,413 @@ async function resolveProjectDir(projectsDir, cwd) {
   }
   return null;
 }
-async function parseClaudeJsonl(projectFilter) {
+function getClaudeDir() {
+  return process.env.CLAUDE_HOME || join(homedir(), ".claude");
+}
+function getOpenCodeDbPath() {
+  if (process.env.OPENCODE_DB_PATH) {
+    return process.env.OPENCODE_DB_PATH;
+  }
+  return join(homedir(), ".local", "share", "opencode", "opencode.db");
+}
+function getFactorySessionsDir() {
+  if (process.env.FACTORY_SESSIONS_DIR) {
+    return process.env.FACTORY_SESSIONS_DIR;
+  }
+  return join(homedir(), ".factory", "sessions");
+}
+async function claudeCompatibleDataExists() {
+  const [claudeProjects, opencodeDb, factorySessions] = await Promise.all([
+    pathExists(join(getClaudeDir(), "projects")),
+    pathExists(getOpenCodeDbPath()),
+    pathExists(getFactorySessionsDir())
+  ]);
+  return claudeProjects || opencodeDb || factorySessions;
+}
+async function parseClaudeProjectEntries(projectFilter) {
   const entries = [];
-  const seenMessageIds = /* @__PURE__ */ new Set();
   const claudeDir = getClaudeDir();
   const projectsDir = join(claudeDir, "projects");
   if (!await pathExists(projectsDir)) return entries;
-  let searchDir;
+  let searchDir = projectsDir;
   if (projectFilter) {
     const resolved = await resolveProjectDir(projectsDir, projectFilter);
     if (!resolved) return entries;
     searchDir = resolved;
-  } else {
-    searchDir = projectsDir;
   }
-  const jsonlFiles = await findJsonlFiles(searchDir);
+  const jsonlFiles = await findFiles(searchDir, (entry) => entry.endsWith(".jsonl"));
   for (const filePath of jsonlFiles) {
     try {
       const content = await fs.readFile(filePath, "utf-8");
-      if (!content.trim()) continue;
       const lines = content.split("\n");
       const fallbackSessionId = basename(filePath, ".jsonl");
       const isSubagentFile = filePath.includes("/subagents/");
-      for (const line of lines) {
+      const bestByMessageKey = /* @__PURE__ */ new Map();
+      for (let index = 0; index < lines.length; index++) {
+        const line = lines[index];
         if (!line.trim()) continue;
         try {
           const entry = JSON.parse(line);
-          if (entry.type !== "assistant" || !entry.message?.usage) continue;
-          const messageId = entry.message?.id;
-          if (messageId) {
-            if (seenMessageIds.has(messageId)) continue;
-            seenMessageIds.add(messageId);
-          }
-          const usage = entry.message.usage;
-          const model = entry.message.model || "unknown";
-          const timestamp = entry.timestamp;
-          if (!timestamp) continue;
+          if (entry.type !== "assistant" || !entry.message?.usage || !entry.timestamp) continue;
+          const rawModel = normalizeAnthropicModelName(entry.message.model || "unknown");
           const sessionId = entry.sessionId || fallbackSessionId;
           const sessionKind = entry.isSidechain === true || isSubagentFile ? "subagent" : "main";
-          const date = toLocalDateString(timestamp);
-          const pricing = getModelPricing(model);
-          const inputTokens = usage.input_tokens || 0;
-          const outputTokens = usage.output_tokens || 0;
-          const cacheWriteTokens = usage.cache_creation_input_tokens || 0;
-          const cacheReadTokens = usage.cache_read_input_tokens || 0;
-          const cost = inputTokens * pricing.input / 1e6 + outputTokens * pricing.output / 1e6 + cacheWriteTokens * pricing.cacheWrite / 1e6 + cacheReadTokens * pricing.cacheRead / 1e6;
-          entries.push({
-            date,
-            model: getModelDisplayName(model),
-            inputTokens,
-            outputTokens,
-            cacheWriteTokens,
-            cacheReadTokens,
-            cost,
+          const usage = entry.message.usage;
+          const messageKey = entry.message.id ? `${sessionId}:${entry.message.id}` : `${filePath}:${index}`;
+          const candidate = {
+            date: toLocalDateString(entry.timestamp),
+            timestamp: entry.timestamp,
+            rawModel,
+            model: getModelDisplayName(rawModel),
+            inputTokens: usage.input_tokens || 0,
+            outputTokens: usage.output_tokens || 0,
+            cacheWriteTokens: usage.cache_creation_input_tokens || 0,
+            cacheReadTokens: usage.cache_read_input_tokens || 0,
+            cost: calculateKnownCost(
+              rawModel,
+              usage.input_tokens || 0,
+              usage.output_tokens || 0,
+              usage.cache_creation_input_tokens || 0,
+              usage.cache_read_input_tokens || 0
+            ),
             messageCount: 1,
             source: "claude",
+            sourceKey: "claude",
             sessionId,
             sessionKind,
-            subagentId: sessionKind === "subagent" ? filePath : void 0,
-            timestamp
-          });
+            subagentId: sessionKind === "subagent" ? filePath : void 0
+          };
+          const existing = bestByMessageKey.get(messageKey);
+          if (!existing || entryTotalTokens(candidate) > entryTotalTokens(existing)) {
+            bestByMessageKey.set(messageKey, candidate);
+          }
         } catch {
         }
       }
+      entries.push(...bestByMessageKey.values());
     } catch {
     }
   }
   return entries;
 }
+async function parseOpenCodeEntries() {
+  const dbPath = getOpenCodeDbPath();
+  if (!await pathExists(dbPath)) return [];
+  const sql = `
+    SELECT
+      COALESCE(m.id, ''),
+      COALESCE(m.session_id, ''),
+      COALESCE(s.parent_id, ''),
+      COALESCE(json_extract(m.data, '$.modelID'), ''),
+      COALESCE(json_extract(m.data, '$.time.created'), 0),
+      COALESCE(json_extract(m.data, '$.tokens.input'), 0),
+      COALESCE(json_extract(m.data, '$.tokens.output'), 0),
+      COALESCE(json_extract(m.data, '$.tokens.cache.write'), 0),
+      COALESCE(json_extract(m.data, '$.tokens.cache.read'), 0),
+      COALESCE(json_extract(m.data, '$.cost'), 0)
+    FROM message m
+    JOIN session s ON s.id = m.session_id
+    WHERE json_extract(m.data, '$.role') = 'assistant'
+      AND json_extract(m.data, '$.modelID') IS NOT NULL;
+  `;
+  let stdout = "";
+  try {
+    const result = await execFileAsync(
+      "sqlite3",
+      ["-separator", SQLITE_SEPARATOR, dbPath, sql],
+      { maxBuffer: SQLITE_MAX_BUFFER }
+    );
+    stdout = result.stdout;
+  } catch {
+    return [];
+  }
+  const entries = [];
+  for (const line of stdout.split("\n")) {
+    if (!line.trim()) continue;
+    const [
+      messageId,
+      sessionId,
+      parentId,
+      modelId,
+      createdMsText,
+      inputText,
+      outputText,
+      cacheWriteText,
+      cacheReadText,
+      costText
+    ] = line.split(SQLITE_SEPARATOR);
+    const createdMs = Number(createdMsText);
+    if (!sessionId || !modelId || !Number.isFinite(createdMs) || createdMs <= 0) continue;
+    const rawModel = normalizeAnthropicModelName(modelId);
+    const timestamp = new Date(createdMs).toISOString();
+    const inputTokens = Number(inputText) || 0;
+    const outputTokens = Number(outputText) || 0;
+    const cacheWriteTokens = Number(cacheWriteText) || 0;
+    const cacheReadTokens = Number(cacheReadText) || 0;
+    const explicitCost = Number(costText) || 0;
+    const sessionKind = parentId ? "subagent" : "main";
+    entries.push({
+      date: toLocalDateString(timestamp),
+      timestamp,
+      rawModel,
+      model: getModelDisplayName(rawModel),
+      inputTokens,
+      outputTokens,
+      cacheWriteTokens,
+      cacheReadTokens,
+      cost: calculateKnownCost(rawModel, inputTokens, outputTokens, cacheWriteTokens, cacheReadTokens, explicitCost),
+      messageCount: 1,
+      source: "claude",
+      sourceKey: "opencode",
+      sessionId,
+      sessionKind,
+      subagentId: sessionKind === "subagent" ? messageId || sessionId : void 0
+    });
+  }
+  return entries;
+}
+async function readFactorySessionMeta(sessionFilePath) {
+  let messageCount = 0;
+  let timestamp;
+  let sessionKind = "main";
+  let subagentId;
+  try {
+    const content = await fs.readFile(sessionFilePath, "utf-8");
+    for (const line of content.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        if (!timestamp && typeof entry.timestamp === "string") {
+          timestamp = entry.timestamp;
+        }
+        if (entry.type === "session_start") {
+          const parent = typeof entry.callingSessionId === "string" ? entry.callingSessionId : void 0;
+          if (parent) {
+            sessionKind = "subagent";
+            subagentId = String(entry.id || sessionFilePath);
+          }
+        }
+        const message = entry.message;
+        if (message?.role === "assistant") {
+          messageCount++;
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return { messageCount: Math.max(messageCount, 1), timestamp, sessionKind, subagentId };
+}
+async function parseFactoryEntries() {
+  const sessionsDir = getFactorySessionsDir();
+  if (!await pathExists(sessionsDir)) return [];
+  const settingsFiles = await findFiles(sessionsDir, (entry) => entry.endsWith(".settings.json"));
+  const entries = [];
+  for (const settingsPath of settingsFiles) {
+    try {
+      const settings = JSON.parse(await fs.readFile(settingsPath, "utf-8"));
+      const usage = settings.tokenUsage;
+      const configuredModel = settings.model;
+      if (!usage || !configuredModel) continue;
+      const rawModel = normalizeAnthropicModelName(configuredModel);
+      const inputTokens = usage.inputTokens || 0;
+      const cacheWriteTokens = usage.cacheCreationTokens || 0;
+      const cacheReadTokens = usage.cacheReadTokens || 0;
+      const outputTokens = (usage.outputTokens || 0) + (usage.thinkingTokens || 0);
+      const totalTokens = inputTokens + outputTokens + cacheWriteTokens + cacheReadTokens;
+      if (totalTokens === 0) continue;
+      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) continue;
+      entries.push({
+        date: toLocalDateString(timestamp),
+        timestamp,
+        rawModel,
+        model: getModelDisplayName(rawModel),
+        inputTokens,
+        outputTokens,
+        cacheWriteTokens,
+        cacheReadTokens,
+        cost: calculateKnownCost(rawModel, inputTokens, outputTokens, cacheWriteTokens, cacheReadTokens),
+        messageCount: meta.messageCount,
+        source: "claude",
+        sourceKey: "factory",
+        sessionId,
+        sessionKind: meta.sessionKind,
+        subagentId: meta.subagentId
+      });
+    } catch {
+    }
+  }
+  return entries;
+}
+async function collectAnthropicUsageEntries(options = {}) {
+  const [claudeEntries, opencodeEntries, factoryEntries] = await Promise.all([
+    parseClaudeProjectEntries(options.projectFilter),
+    parseOpenCodeEntries(),
+    parseFactoryEntries()
+  ]);
+  return [...claudeEntries, ...opencodeEntries, ...factoryEntries];
+}
+async function loadClaudeStatsFromJsonl() {
+  const entries = await collectAnthropicUsageEntries();
+  if (entries.length === 0) {
+    return null;
+  }
+  const modelUsage = /* @__PURE__ */ new Map();
+  const dailyMap = /* @__PURE__ */ new Map();
+  const sessionsByDate = /* @__PURE__ */ new Map();
+  const mainSessions = /* @__PURE__ */ new Set();
+  const subagentSessions = /* @__PURE__ */ new Set();
+  const hourCounts = {};
+  let firstTimestamp = null;
+  let totalMessages = 0;
+  for (const entry of entries) {
+    const existing = modelUsage.get(entry.rawModel) ?? {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadInputTokens: 0,
+      cacheCreationInputTokens: 0,
+      webSearchRequests: 0,
+      costUSD: 0,
+      contextWindow: 2e5
+    };
+    existing.inputTokens += entry.inputTokens;
+    existing.outputTokens += entry.outputTokens;
+    existing.cacheCreationInputTokens += entry.cacheWriteTokens;
+    existing.cacheReadInputTokens += entry.cacheReadTokens;
+    existing.costUSD += entry.cost;
+    modelUsage.set(entry.rawModel, existing);
+    const daily = dailyMap.get(entry.date) ?? { messageCount: 0, sessionCount: 0, toolCallCount: 0 };
+    daily.messageCount += entry.messageCount;
+    dailyMap.set(entry.date, daily);
+    const dateSessions = sessionsByDate.get(entry.date) ?? /* @__PURE__ */ new Set();
+    dateSessions.add(`${entry.sourceKey}:${entry.sessionId}`);
+    sessionsByDate.set(entry.date, dateSessions);
+    const hour = new Date(entry.timestamp).getHours().toString();
+    hourCounts[hour] = (hourCounts[hour] || 0) + entry.messageCount;
+    totalMessages += entry.messageCount;
+    mainSessions.add(`${entry.sourceKey}:${entry.sessionId}`);
+    if (entry.sessionKind === "subagent") {
+      subagentSessions.add(`${entry.sourceKey}:${entry.subagentId || entry.sessionId}`);
+    }
+    if (!firstTimestamp || entry.timestamp < firstTimestamp) {
+      firstTimestamp = entry.timestamp;
+    }
+  }
+  const dailyActivity = Array.from(dailyMap.entries()).map(([date, data]) => ({
+    date,
+    messageCount: data.messageCount,
+    sessionCount: sessionsByDate.get(date)?.size || 0,
+    toolCallCount: data.toolCallCount
+  })).sort((a, b) => a.date.localeCompare(b.date));
+  const sessionCounts = {
+    main: mainSessions.size,
+    subagent: subagentSessions.size,
+    total: mainSessions.size + subagentSessions.size
+  };
+  return {
+    version: 1,
+    lastComputedDate: toLocalDateString((/* @__PURE__ */ new Date()).toISOString()),
+    dailyActivity,
+    dailyModelTokens: [],
+    modelUsage: Object.fromEntries(modelUsage.entries()),
+    totalSessions: sessionCounts.main,
+    totalMessages,
+    longestSession: {
+      sessionId: "",
+      duration: 0,
+      messageCount: 0,
+      timestamp: ""
+    },
+    firstSessionDate: firstTimestamp || (/* @__PURE__ */ new Date()).toISOString(),
+    hourCounts,
+    sessionCounts
+  };
+}
+
+// src/usage/loader.ts
+var MAX_RECURSION_DEPTH = 10;
+function toLocalDateString2(isoTimestamp) {
+  const date = new Date(isoTimestamp);
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function getCodexDir() {
+  return process.env.CODEX_HOME || join2(homedir2(), ".codex");
+}
+async function pathExists2(path) {
+  try {
+    await fs2.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function safeRealpath2(path) {
+  try {
+    return await fs2.realpath(path);
+  } catch {
+    return path;
+  }
+}
+async function findJsonlFiles(dir, visited = /* @__PURE__ */ new Set(), depth = 0, result = []) {
+  if (!await pathExists2(dir)) return result;
+  if (depth > MAX_RECURSION_DEPTH) return result;
+  const realPath = await safeRealpath2(dir);
+  if (visited.has(realPath)) return result;
+  visited.add(realPath);
+  let entries;
+  try {
+    entries = await fs2.readdir(dir);
+  } catch {
+    return result;
+  }
+  for (const entry of entries) {
+    const fullPath = join2(dir, entry);
+    let stat;
+    try {
+      stat = await fs2.stat(fullPath);
+    } catch {
+      continue;
+    }
+    if (stat.isDirectory()) {
+      await findJsonlFiles(fullPath, visited, depth + 1, result);
+    } else if (entry.endsWith(".jsonl")) {
+      result.push(fullPath);
+    }
+  }
+  return result;
+}
+async function parseClaudeJsonl(projectFilter) {
+  const entries = await collectAnthropicUsageEntries({ projectFilter });
+  return entries.map((entry) => ({
+    date: entry.date,
+    model: entry.model,
+    rawModel: entry.rawModel,
+    inputTokens: entry.inputTokens,
+    outputTokens: entry.outputTokens,
+    cacheWriteTokens: entry.cacheWriteTokens,
+    cacheReadTokens: entry.cacheReadTokens,
+    cost: entry.cost,
+    messageCount: entry.messageCount,
+    source: entry.source,
+    sourceKey: entry.sourceKey,
+    sessionId: entry.sessionId,
+    sessionKind: entry.sessionKind,
+    subagentId: entry.subagentId,
+    timestamp: entry.timestamp
+  }));
+}
 async function parseCodexJsonl() {
   const entries = [];
   const codexDir = getCodexDir();
-  const sessionsDir = join(codexDir, "sessions");
-  const archivedDir = join(codexDir, "archived_sessions");
+  const sessionsDir = join2(codexDir, "sessions");
+  const archivedDir = join2(codexDir, "archived_sessions");
   const [sessionFiles, archivedFiles] = await Promise.all([
     findJsonlFiles(sessionsDir),
     findJsonlFiles(archivedDir)
@@ -926,10 +1319,10 @@ async function parseCodexJsonl() {
   if (jsonlFiles.length === 0) return entries;
   for (const filePath of jsonlFiles) {
     try {
-      const content = await fs.readFile(filePath, "utf-8");
+      const content = await fs2.readFile(filePath, "utf-8");
       const lines = content.split("\n");
       let currentModel = "gpt-5";
-      let fileSessionId = basename(filePath, ".jsonl");
+      let fileSessionId = basename2(filePath, ".jsonl");
       let canonicalSessionId = fileSessionId;
       let sessionKind = "main";
       for (const line of lines) {
@@ -955,7 +1348,7 @@ async function parseCodexJsonl() {
             const usage = info.last_token_usage;
             const timestamp = entry.timestamp;
             if (!timestamp) continue;
-            const date = toLocalDateString(timestamp);
+            const date = toLocalDateString2(timestamp);
             const pricing = getCodexModelPricing(currentModel);
             const inputTokens = usage.input_tokens || 0;
             const outputTokens = usage.output_tokens || 0;
@@ -989,11 +1382,12 @@ function computeSessionCounts(entries) {
   const mainSessions = /* @__PURE__ */ new Set();
   const subagentSessions = /* @__PURE__ */ new Set();
   for (const entry of entries) {
+    const sourceKey = entry.sourceKey || entry.source;
     if (entry.sessionId) {
-      mainSessions.add(`${entry.source}:${entry.sessionId}`);
+      mainSessions.add(`${sourceKey}:${entry.sessionId}`);
     }
     if (entry.sessionKind === "subagent" && entry.subagentId) {
-      subagentSessions.add(`${entry.source}:${entry.subagentId}`);
+      subagentSessions.add(`${sourceKey}:${entry.subagentId}`);
     }
   }
   return {
@@ -1032,13 +1426,14 @@ function sortModelsByTier(models) {
 function aggregateByDay(entries) {
   const dayMap = /* @__PURE__ */ new Map();
   for (const e of entries) {
+    const entryTotal = e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens;
     const existing = dayMap.get(e.date);
     if (existing) {
       existing.inputTokens += e.inputTokens;
       existing.outputTokens += e.outputTokens;
       existing.cacheWriteTokens += e.cacheWriteTokens;
       existing.cacheReadTokens += e.cacheReadTokens;
-      existing.totalTokens += e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens;
+      existing.totalTokens += entryTotal;
       existing.cost += e.cost;
       existing.modelsSet.add(e.model);
     } else {
@@ -1048,7 +1443,7 @@ function aggregateByDay(entries) {
         outputTokens: e.outputTokens,
         cacheWriteTokens: e.cacheWriteTokens,
         cacheReadTokens: e.cacheReadTokens,
-        totalTokens: e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens,
+        totalTokens: entryTotal,
         cost: e.cost,
         modelsSet: /* @__PURE__ */ new Set([e.model])
       });
@@ -1063,13 +1458,14 @@ function aggregateByMonth(entries) {
   const monthMap = /* @__PURE__ */ new Map();
   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);
     if (existing) {
       existing.inputTokens += e.inputTokens;
       existing.outputTokens += e.outputTokens;
       existing.cacheWriteTokens += e.cacheWriteTokens;
       existing.cacheReadTokens += e.cacheReadTokens;
-      existing.totalTokens += e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens;
+      existing.totalTokens += entryTotal;
       existing.cost += e.cost;
       existing.modelsSet.add(e.model);
     } else {
@@ -1079,7 +1475,7 @@ function aggregateByMonth(entries) {
         outputTokens: e.outputTokens,
         cacheWriteTokens: e.cacheWriteTokens,
         cacheReadTokens: e.cacheReadTokens,
-        totalTokens: e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens,
+        totalTokens: entryTotal,
         cost: e.cost,
         modelsSet: /* @__PURE__ */ new Set([e.model])
       });
@@ -1093,13 +1489,14 @@ function aggregateByMonth(entries) {
 function aggregateByModel(entries) {
   const modelMap = /* @__PURE__ */ new Map();
   for (const e of entries) {
+    const entryTotal = e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens;
     const existing = modelMap.get(e.model);
     if (existing) {
       existing.inputTokens += e.inputTokens;
       existing.outputTokens += e.outputTokens;
       existing.cacheWriteTokens += e.cacheWriteTokens;
       existing.cacheReadTokens += e.cacheReadTokens;
-      existing.totalTokens += e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens;
+      existing.totalTokens += entryTotal;
       existing.cost += e.cost;
     } else {
       modelMap.set(e.model, {
@@ -1108,7 +1505,7 @@ function aggregateByModel(entries) {
         outputTokens: e.outputTokens,
         cacheWriteTokens: e.cacheWriteTokens,
         cacheReadTokens: e.cacheReadTokens,
-        totalTokens: e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens,
+        totalTokens: entryTotal,
         cost: e.cost
       });
     }
@@ -1118,14 +1515,16 @@ function aggregateByModel(entries) {
 function aggregateBySession(entries) {
   const sessionMap = /* @__PURE__ */ new Map();
   for (const e of entries) {
-    const sid = e.sessionId ? `${e.source}:${e.sessionId}` : "unknown";
+    const sourceKey = e.sourceKey || e.source;
+    const sid = e.sessionId ? `${sourceKey}:${e.sessionId}` : "unknown";
+    const entryTotal = e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens;
     const existing = sessionMap.get(sid);
     if (existing) {
       existing.inputTokens += e.inputTokens;
       existing.outputTokens += e.outputTokens;
       existing.cacheWriteTokens += e.cacheWriteTokens;
       existing.cacheReadTokens += e.cacheReadTokens;
-      existing.totalTokens += e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens;
+      existing.totalTokens += entryTotal;
       existing.cost += e.cost;
       existing.modelsSet.add(e.model);
       if (e.timestamp && e.timestamp < existing.firstTimestamp) {
@@ -1139,14 +1538,14 @@ function aggregateBySession(entries) {
         outputTokens: e.outputTokens,
         cacheWriteTokens: e.cacheWriteTokens,
         cacheReadTokens: e.cacheReadTokens,
-        totalTokens: e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens,
+        totalTokens: entryTotal,
         cost: e.cost,
         firstTimestamp: e.timestamp || ""
       });
     }
   }
   return Array.from(sessionMap.entries()).filter(([, data]) => data.totalTokens > 0).map(([sessionId, data]) => {
-    const date = data.firstTimestamp ? toLocalDateString(data.firstTimestamp) : "unknown";
+    const date = data.firstTimestamp ? toLocalDateString2(data.firstTimestamp) : "unknown";
     const shortId = data.displaySessionId.slice(0, 12);
     return {
       key: `${date} ${shortId}`,
@@ -1506,180 +1905,6 @@ function displayTotalOnly(stats, options = {}) {
   console.log();
 }
 
-// src/claude-jsonl-loader.ts
-import { promises as fs2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { basename as basename2, join as join2 } from "path";
-function getClaudeDir2() {
-  return process.env.CLAUDE_HOME || join2(homedir2(), ".claude");
-}
-function toLocalDateString2(isoTimestamp) {
-  const date = new Date(isoTimestamp);
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  const day = String(date.getDate()).padStart(2, "0");
-  return `${year}-${month}-${day}`;
-}
-async function pathExists2(path) {
-  try {
-    await fs2.access(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function claudeJsonlDataExists() {
-  const projectsDir = join2(getClaudeDir2(), "projects");
-  return pathExists2(projectsDir);
-}
-async function findJsonlFiles2(dir) {
-  const files = [];
-  if (!await pathExists2(dir)) return files;
-  let entries;
-  try {
-    entries = await fs2.readdir(dir);
-  } catch {
-    return files;
-  }
-  for (const entry of entries) {
-    const fullPath = join2(dir, entry);
-    try {
-      const stat = await fs2.stat(fullPath);
-      if (stat.isDirectory()) {
-        files.push(...await findJsonlFiles2(fullPath));
-      } else if (entry.endsWith(".jsonl")) {
-        files.push(fullPath);
-      }
-    } catch {
-    }
-  }
-  return files;
-}
-async function loadClaudeStatsFromJsonl() {
-  const claudeDir = getClaudeDir2();
-  const projectsDir = join2(claudeDir, "projects");
-  if (!await claudeJsonlDataExists()) {
-    return null;
-  }
-  const jsonlFiles = await findJsonlFiles2(projectsDir);
-  if (jsonlFiles.length === 0) {
-    return null;
-  }
-  const modelUsage = {};
-  const dailyMap = /* @__PURE__ */ new Map();
-  const sessionsByDate = /* @__PURE__ */ new Map();
-  const mainSessions = /* @__PURE__ */ new Set();
-  const subagentSessions = /* @__PURE__ */ new Set();
-  const hourCounts = {};
-  let firstTimestamp = null;
-  let totalMessages = 0;
-  const messageIds = /* @__PURE__ */ new Set();
-  for (const filePath of jsonlFiles) {
-    try {
-      const content = await fs2.readFile(filePath, "utf-8");
-      const lines = content.split("\n");
-      const fallbackSessionId = basename2(filePath, ".jsonl");
-      const isSubagentFile = filePath.includes("/subagents/");
-      for (const line of lines) {
-        if (!line.trim()) continue;
-        try {
-          const entry = JSON.parse(line);
-          if (entry.type !== "assistant") continue;
-          if (!entry.message?.usage) continue;
-          const usage = entry.message.usage;
-          const model = entry.message.model || "unknown";
-          const timestamp = entry.timestamp;
-          const messageId = entry.message.id;
-          const sessionId = entry.sessionId || fallbackSessionId;
-          const sessionKind = entry.isSidechain === true || isSubagentFile ? "subagent" : "main";
-          if (!modelUsage[model]) {
-            modelUsage[model] = {
-              inputTokens: 0,
-              outputTokens: 0,
-              cacheReadInputTokens: 0,
-              cacheCreationInputTokens: 0
-            };
-          }
-          modelUsage[model].inputTokens += usage.input_tokens || 0;
-          modelUsage[model].outputTokens += usage.output_tokens || 0;
-          modelUsage[model].cacheReadInputTokens += usage.cache_read_input_tokens || 0;
-          modelUsage[model].cacheCreationInputTokens += usage.cache_creation_input_tokens || 0;
-          if (messageId) {
-            messageIds.add(messageId);
-          }
-          if (timestamp) {
-            const date = toLocalDateString2(timestamp);
-            const hour = new Date(timestamp).getHours().toString();
-            if (!dailyMap.has(date)) {
-              dailyMap.set(date, { messageCount: 0, sessionCount: 0, toolCallCount: 0 });
-            }
-            const daily = dailyMap.get(date);
-            daily.messageCount++;
-            const dateSessions = sessionsByDate.get(date) || /* @__PURE__ */ new Set();
-            dateSessions.add(sessionId);
-            sessionsByDate.set(date, dateSessions);
-            hourCounts[hour] = (hourCounts[hour] || 0) + 1;
-          }
-          mainSessions.add(sessionId);
-          if (sessionKind === "subagent") {
-            subagentSessions.add(filePath);
-          }
-          if (timestamp && (!firstTimestamp || timestamp < firstTimestamp)) {
-            firstTimestamp = timestamp;
-          }
-        } catch {
-        }
-      }
-    } catch {
-    }
-  }
-  totalMessages = messageIds.size;
-  if (totalMessages === 0) {
-    return null;
-  }
-  const statsCacheModelUsage = {};
-  for (const [model, usage] of Object.entries(modelUsage)) {
-    statsCacheModelUsage[model] = {
-      inputTokens: usage.inputTokens,
-      outputTokens: usage.outputTokens,
-      cacheReadInputTokens: usage.cacheReadInputTokens,
-      cacheCreationInputTokens: usage.cacheCreationInputTokens,
-      webSearchRequests: 0,
-      costUSD: 0,
-      contextWindow: 2e5
-    };
-  }
-  const dailyActivity = Array.from(dailyMap.entries()).map(([date, data]) => ({
-    date,
-    messageCount: data.messageCount,
-    sessionCount: sessionsByDate.get(date)?.size || 0,
-    toolCallCount: data.toolCallCount
-  })).sort((a, b) => a.date.localeCompare(b.date));
-  const sessionCounts = {
-    main: mainSessions.size,
-    subagent: subagentSessions.size,
-    total: mainSessions.size + subagentSessions.size
-  };
-  return {
-    version: 1,
-    lastComputedDate: toLocalDateString2((/* @__PURE__ */ new Date()).toISOString()),
-    dailyActivity,
-    dailyModelTokens: [],
-    modelUsage: statsCacheModelUsage,
-    totalSessions: sessionCounts.main,
-    totalMessages,
-    longestSession: {
-      sessionId: "",
-      duration: 0,
-      messageCount: 0,
-      timestamp: ""
-    },
-    firstSessionDate: firstTimestamp || (/* @__PURE__ */ new Date()).toISOString(),
-    hourCounts,
-    sessionCounts
-  };
-}
-
 // src/codex-loader.ts
 import { promises as fs3 } from "fs";
 import { homedir as homedir3 } from "os";
@@ -1709,7 +1934,7 @@ async function codexDataExists() {
   const archivedDir = join3(codexDir, "archived_sessions");
   return await pathExists3(sessionsDir) || await pathExists3(archivedDir);
 }
-async function findJsonlFiles3(dir) {
+async function findJsonlFiles2(dir) {
   const files = [];
   if (!await pathExists3(dir)) return files;
   let entries;
@@ -1727,7 +1952,7 @@ async function findJsonlFiles3(dir) {
       continue;
     }
     if (stat.isDirectory()) {
-      files.push(...await findJsonlFiles3(fullPath));
+      files.push(...await findJsonlFiles2(fullPath));
     } else if (entry.endsWith(".jsonl")) {
       files.push(fullPath);
     }
@@ -1822,8 +2047,8 @@ async function loadCodexStats() {
   const sessionsDir = join3(codexDir, "sessions");
   const archivedDir = join3(codexDir, "archived_sessions");
   const [sessionFiles, archivedFiles] = await Promise.all([
-    findJsonlFiles3(sessionsDir),
-    findJsonlFiles3(archivedDir)
+    findJsonlFiles2(sessionsDir),
+    findJsonlFiles2(archivedDir)
   ]);
   const jsonlFiles = [...sessionFiles, ...archivedFiles];
   if (jsonlFiles.length === 0) {
@@ -1920,7 +2145,7 @@ async function loadData(options) {
   let claude = null;
   let codex = null;
   if (!codexOnly) {
-    if (await claudeJsonlDataExists()) {
+    if (await claudeCompatibleDataExists()) {
       claude = await loadClaudeStatsFromJsonl();
     }
   }
@@ -1941,10 +2166,10 @@ function validateData(data, options) {
       console.error("Make sure you have used the Codex CLI at least once.");
     } else if (options.combined) {
       console.error("Error: No usage data found");
-      console.error("Make sure you have used Claude Code or Codex CLI at least once.");
+      console.error("Make sure you have used a supported local CLI source such as Claude Code, OpenCode, Droid, or Codex at least once.");
     } else {
-      console.error("Error: Claude Code data not found at ~/.claude");
-      console.error("Make sure you have used Claude Code at least once.");
+      console.error("Error: No Claude-compatible local data found");
+      console.error("Checked ~/.claude, ~/.local/share/opencode/opencode.db, and ~/.factory/sessions.");
     }
     process.exit(1);
   }
@@ -1958,7 +2183,10 @@ function toLocalDateString4(date) {
   return `${year}-${month}-${day}`;
 }
 function calculateModelCost(modelName, usage) {
-  const pricing = getModelPricing(modelName);
+  const pricing = tryGetModelPricing(modelName);
+  if (!pricing) {
+    return 0;
+  }
   const inputCost = usage.inputTokens / 1e6 * pricing.input;
   const outputCost = usage.outputTokens / 1e6 * pricing.output;
   const cacheWriteCost = usage.cacheCreationInputTokens / 1e6 * pricing.cacheWrite;
@@ -2062,34 +2290,39 @@ function shouldExcludeModel(modelName) {
   const lower = modelName.toLowerCase();
   return EXCLUDED_MODELS.some((excluded) => lower.includes(excluded));
 }
-function getModelBreakdown(modelUsage) {
-  const totalTokens = calculateTotalTokens(modelUsage);
-  if (totalTokens === 0) return [];
-  const breakdown = [];
+function getUsageTokens(usage) {
+  return usage.inputTokens + usage.outputTokens + usage.cacheCreationInputTokens + usage.cacheReadInputTokens;
+}
+function getDisplayModelTokens(modelUsage) {
+  const aggregated = /* @__PURE__ */ new Map();
   for (const [modelName, usage] of Object.entries(modelUsage)) {
     if (shouldExcludeModel(modelName)) continue;
-    const modelTokens = usage.inputTokens + usage.outputTokens + usage.cacheCreationInputTokens + usage.cacheReadInputTokens;
-    breakdown.push({
-      model: getModelDisplayName(modelName),
-      percentage: Math.round(modelTokens / totalTokens * 100),
-      tokens: modelTokens
-    });
+    const displayName = getModelDisplayName(modelName);
+    const modelTokens = getUsageTokens(usage);
+    aggregated.set(displayName, (aggregated.get(displayName) || 0) + modelTokens);
   }
-  breakdown.sort((a, b) => b.tokens - a.tokens);
-  return breakdown.map(({ model, percentage }) => ({ model, percentage }));
+  return Array.from(aggregated.entries()).map(([model, tokens]) => ({ model, tokens })).sort((a, b) => b.tokens - a.tokens);
+}
+function getModelBreakdown(modelUsage) {
+  const breakdown = getDisplayModelTokens(modelUsage);
+  const totalTokens = breakdown.reduce((sum, entry) => sum + entry.tokens, 0);
+  if (totalTokens === 0) return [];
+  return breakdown.map(({ model, tokens }) => ({
+    model,
+    percentage: Math.round(tokens / totalTokens * 100)
+  }));
 }
 function getFavoriteModel(modelUsage) {
-  let favoriteModel = "";
-  let maxTokens = 0;
+  return getDisplayModelTokens(modelUsage)[0]?.model || "";
+}
+function getCodexDisplayModelTokens(modelUsage) {
+  const aggregated = /* @__PURE__ */ new Map();
   for (const [modelName, usage] of Object.entries(modelUsage)) {
-    if (shouldExcludeModel(modelName)) continue;
-    const modelTokens = usage.inputTokens + usage.outputTokens + usage.cacheCreationInputTokens + usage.cacheReadInputTokens;
-    if (modelTokens > maxTokens) {
-      maxTokens = modelTokens;
-      favoriteModel = modelName;
-    }
+    const displayName = getCodexModelDisplayName(modelName);
+    const modelTokens = usage.inputTokens + usage.outputTokens;
+    aggregated.set(displayName, (aggregated.get(displayName) || 0) + modelTokens);
   }
-  return getModelDisplayName(favoriteModel);
+  return Array.from(aggregated.entries()).map(([model, tokens]) => ({ model, tokens })).sort((a, b) => b.tokens - a.tokens);
 }
 function calculateWordsGenerated(modelUsage) {
   let totalOutputTokens = 0;
@@ -2196,23 +2429,11 @@ function computeCodexWrappedStats(cache) {
       busiestMonth = month;
     }
   }
-  let favoriteModel = "";
-  let maxModelTokens = 0;
-  const breakdown = [];
-  for (const [modelName, usage] of Object.entries(cache.modelUsage)) {
-    const modelTokens = usage.inputTokens + usage.outputTokens;
-    breakdown.push({
-      model: getCodexModelDisplayName(modelName),
-      percentage: totalTokens > 0 ? Math.round(modelTokens / totalTokens * 100) : 0,
-      tokens: modelTokens
-    });
-    if (modelTokens > maxModelTokens) {
-      maxModelTokens = modelTokens;
-      favoriteModel = modelName;
-    }
-  }
-  breakdown.sort((a, b) => b.tokens - a.tokens);
-  const modelBreakdown = breakdown.map(({ model, percentage }) => ({ model, percentage }));
+  const breakdown = getCodexDisplayModelTokens(cache.modelUsage);
+  const modelBreakdown = breakdown.map(({ model, tokens }) => ({
+    model,
+    percentage: totalTokens > 0 ? Math.round(tokens / totalTokens * 100) : 0
+  }));
   const wordsGenerated = Math.round(totalOutputTokens * 0.75);
   return {
     sessions: cache.totalSessions,
@@ -2225,7 +2446,7 @@ function computeCodexWrappedStats(cache) {
     peakHour,
     peakDay,
     busiestMonth,
-    favoriteModel: getCodexModelDisplayName(favoriteModel),
+    favoriteModel: breakdown[0]?.model || "",
     modelBreakdown,
     wordsGenerated,
     firstSessionDate: cache.firstSessionDate,
@@ -2491,7 +2712,7 @@ async function publishArtifact(artifact, baseUrl, legacyUrl) {
 import { promises as fs4 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join4 } from "path";
-function getClaudeDir3() {
+function getClaudeDir2() {
   return process.env.CLAUDE_HOME || join4(homedir4(), ".claude");
 }
 async function pathExists4(path) {
@@ -2555,7 +2776,7 @@ async function inspectClaudeSystem(home = homedir4()) {
     projectCount: json?.projects ? Object.keys(json.projects).length : void 0
   };
 }
-async function inspectClaudeUsage(claudeDir = getClaudeDir3()) {
+async function inspectClaudeUsage(claudeDir = getClaudeDir2()) {
   const statsCachePath = join4(claudeDir, "stats-cache.json");
   const statsCache = await readJsonFile(statsCachePath);
   const facetsDir = join4(claudeDir, "usage-data", "facets");
@@ -3060,9 +3281,9 @@ async function runUsage(args, config) {
       if (args.codex) {
         console.error("Checked: ~/.codex/sessions and ~/.codex/archived_sessions");
       } else if (args.combined) {
-        console.error("Checked: ~/.claude/projects and ~/.codex/sessions (plus archived sessions)");
+        console.error("Checked: ~/.claude/projects, ~/.local/share/opencode/opencode.db, ~/.factory/sessions, and ~/.codex/sessions (plus archived sessions)");
       } else {
-        console.error("Checked: ~/.claude/projects");
+        console.error("Checked: ~/.claude/projects, ~/.local/share/opencode/opencode.db, and ~/.factory/sessions");
       }
       console.error("Try widening the range or removing the date filter.");
       process.exit(1);
@@ -3072,10 +3293,10 @@ async function runUsage(args, config) {
       console.error("Make sure you have used the Codex CLI at least once.");
     } else if (args.combined) {
       console.error("Error: No usage data found");
-      console.error("Make sure you have used Claude Code or Codex CLI at least once.");
+      console.error("Make sure you have used a supported local CLI source such as Claude Code, OpenCode, Droid, or Codex at least once.");
     } else {
-      console.error("Error: Claude Code data not found at ~/.claude");
-      console.error("Make sure you have used Claude Code at least once.");
+      console.error("Error: No Claude-compatible local data found");
+      console.error("Checked ~/.claude, ~/.local/share/opencode/opencode.db, and ~/.factory/sessions.");
     }
     process.exit(1);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibestats",
-  "version": "1.3.8",
+  "version": "1.3.9",
   "description": "AI coding stats - usage tracking and annual wrapped for Claude Code & Codex",
   "type": "module",
   "main": "./dist/index.js",
@@ -18,12 +18,6 @@
   "files": [
     "dist"
   ],
-  "scripts": {
-    "dev": "tsx src/index.ts",
-    "build": "tsup src/index.ts --format esm --dts --clean --shims",
-    "test": "tsx --test src/**/*.test.ts",
-    "prepublishOnly": "pnpm build"
-  },
   "keywords": [
     "claude",
     "claude-code",
@@ -51,5 +45,10 @@
   },
   "engines": {
     "node": ">=18.0.0"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsup src/index.ts --format esm --dts --clean --shims",
+    "test": "tsx --test src/**/*.test.ts"
   }
-}
+}