@yishiguji/tokenarena 0.16.6 → 0.18.1

package/dist/index.js

@@ -646,11 +646,11 @@ function readRollout(path) {
   let minLineTimestampOrder = null;
   let line = 0;
   let maxOrdinal = null;
-  for (const text of content.split("\n")) {
+  for (const text2 of content.split("\n")) {
     line++;
-    if (!text.trim()) continue;
+    if (!text2.trim()) continue;
     try {
-      const event = JSON.parse(text);
+      const event = JSON.parse(text2);
       if (typeof event.ordinal === "number" && Number.isSafeInteger(event.ordinal) && event.ordinal >= 0 && (maxOrdinal === null || event.ordinal > maxOrdinal)) {
         maxOrdinal = event.ordinal;
       }
@@ -1358,7 +1358,7 @@ async function readSqliteRowsWithBuiltin(dbPath, query) {
     throw err;
   }
 }
-function readSqliteRowsWithCli(dbPath, query) {
+function readSqliteRowsWithCli(dbPath, query, readOnly = false) {
   const candidates = [
     process.env.TOKEN_ARENA_SQLITE3,
     "sqlite3",
@@ -1367,7 +1367,8 @@ function readSqliteRowsWithCli(dbPath, query) {
   let lastError = null;
   for (const command of candidates) {
     try {
-      const output = execFileSync(command, ["-json", dbPath, query], {
+      const args = [...readOnly ? ["-readonly"] : [], "-json", dbPath, query];
+      const output = execFileSync(command, args, {
         encoding: "utf-8",
         maxBuffer: 100 * 1024 * 1024,
         timeout: 3e4,
@@ -1380,7 +1381,7 @@ function readSqliteRowsWithCli(dbPath, query) {
     } catch (err) {
       lastError = err;
       const nodeError = err;
-      if (nodeError.status === 127 || nodeError.message?.includes("ENOENT")) {
+      if (nodeError.status === 127 || nodeError.code === "ENOENT") {
         continue;
       }
       throw err;
@@ -1390,6 +1391,37 @@ function readSqliteRowsWithCli(dbPath, query) {
     `sqlite3 CLI not found. Install sqlite3 or set TOKEN_ARENA_SQLITE3 to its full path. Last error: ${lastError?.message || "not found"}`
   );
 }
+async function readSqliteRowsReadonly(dbPath, query) {
+  return withSuppressedSqliteWarning(async () => {
+    const sqliteModuleId = "node:sqlite";
+    let sqlite;
+    try {
+      sqlite = await import(sqliteModuleId);
+    } catch (error) {
+      if (error.code !== "ERR_UNKNOWN_BUILTIN_MODULE") {
+        throw error;
+      }
+      return readSqliteRowsWithCli(dbPath, query, true);
+    }
+    let supportsReadOnly = false;
+    const probe = new sqlite.DatabaseSync(":memory:", {
+      get readOnly() {
+        supportsReadOnly = true;
+        return false;
+      }
+    });
+    probe.close();
+    if (!supportsReadOnly) {
+      return readSqliteRowsWithCli(dbPath, query, true);
+    }
+    const db = new sqlite.DatabaseSync(dbPath, { readOnly: true });
+    try {
+      return db.prepare(query).all();
+    } finally {
+      db.close();
+    }
+  });
+}
 async function readSqliteRows(dbPath, query) {
   const builtinRows = await readSqliteRowsWithBuiltin(dbPath, query);
   return builtinRows ?? readSqliteRowsWithCli(dbPath, query);
@@ -4039,8 +4071,8 @@ var ClineParser = class {
             if (msgType === "say" && msgSay === "api_req_started") {
               let info = null;
               try {
-                const text = msg.text;
-                if (typeof text === "string") info = JSON.parse(text);
+                const text2 = msg.text;
+                if (typeof text2 === "string") info = JSON.parse(text2);
               } catch {
               }
               if (!info) continue;
@@ -4494,76 +4526,540 @@ var RooCodeParser = class {
 registerParser(new RooCodeParser());
 
 // src/parsers/snow.ts
-import { existsSync as existsSync22 } from "fs";
+import { existsSync as existsSync22, readdirSync as readdirSync12, statSync as statSync6 } from "fs";
 import { homedir as homedir22 } from "os";
-import { join as join23 } from "path";
-var DEFAULT_DATA_DIR6 = join23(homedir22(), ".snow", "usage");
+import { basename as basename10, join as join23 } from "path";
+var DEFAULT_SNOW_DIR = join23(homedir22(), ".snow");
+var USAGE_DIR_NAME = "usage";
+var SESSIONS_DIR_NAME = "sessions";
+var NON_TRANSCRIPT_DIRS = /* @__PURE__ */ new Set(["subagent", "compressed"]);
+var SESSION_MATCH_WINDOW_MS = 5 * 60 * 1e3;
+var DAMAGED_TRANSCRIPT_SETTLE_MS = 60 * 1e3;
+var MIN_TIMESTAMP_MS = Date.UTC(2020, 0, 1);
+var MAX_TIMESTAMP_MS = Date.UTC(2080, 0, 1);
 function toNonNegativeNumber2(value) {
+  if (typeof value !== "number" && typeof value !== "string") return 0;
   const numberValue = Number(value);
   return Number.isFinite(numberValue) && numberValue >= 0 ? numberValue : 0;
 }
+function toTime(value) {
+  const time = typeof value === "string" ? Date.parse(value) : typeof value === "number" ? value : Number.NaN;
+  return time >= MIN_TIMESTAMP_MS && time < MAX_TIMESTAMP_MS ? time : null;
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function findSourceFiles(dir, extension, results = []) {
+  let entries;
+  try {
+    entries = readdirSync12(dir, { withFileTypes: true });
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT" || code === "ENOTDIR") return results;
+    throw error;
+  }
+  for (const entry of entries) {
+    const fullPath = join23(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (extension === ".json" && NON_TRANSCRIPT_DIRS.has(entry.name)) {
+        continue;
+      }
+      findSourceFiles(fullPath, extension, results);
+    } else if (entry.name.endsWith(extension)) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+function resolveProject(session) {
+  if (typeof session.projectPath === "string" && session.projectPath) {
+    const segments = session.projectPath.split(/[\\/]+/).filter(Boolean);
+    return segments.at(-1) || "unknown";
+  }
+  return "unknown";
+}
+function readTranscript(filePath) {
+  const content = readFileSafe(filePath);
+  if (content === null) return { status: "damaged" };
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return { status: "damaged" };
+  }
+  if (!isRecord(parsed) || !Array.isArray(parsed.messages)) {
+    return { status: "foreign" };
+  }
+  const session = parsed;
+  const compressedFrom = typeof session.compressedFrom === "string" && session.compressedFrom ? session.compressedFrom : void 0;
+  const copiedUntil = compressedFrom !== void 0 || typeof session.branchedFrom === "string" ? Math.max(
+    toTime(session.compressedAt) ?? Number.NEGATIVE_INFINITY,
+    toTime(session.createdAt) ?? Number.NEGATIVE_INFINITY
+  ) : Number.NEGATIVE_INFINITY;
+  const messages = [];
+  let lastMessageAt = 0;
+  for (const message of parsed.messages) {
+    if (!isRecord(message)) continue;
+    if (message.role !== "user" && message.role !== "assistant") continue;
+    const time = toTime(message.timestamp);
+    if (time === null) continue;
+    if (time > lastMessageAt) lastMessageAt = time;
+    if (time <= copiedUntil) continue;
+    messages.push({ role: message.role, time });
+  }
+  return {
+    status: "ok",
+    transcript: {
+      filePath,
+      sessionId: typeof session.id === "string" && session.id ? session.id : basename10(filePath, ".json"),
+      project: resolveProject(session),
+      updatedAt: toTime(session.updatedAt) ?? lastMessageAt,
+      ...compressedFrom !== void 0 ? { compressedFrom } : {},
+      messages
+    }
+  };
+}
+function isNewerCopy(candidate, current) {
+  if (candidate.updatedAt !== current.updatedAt) {
+    return candidate.updatedAt > current.updatedAt;
+  }
+  if (candidate.messages.length !== current.messages.length) {
+    return candidate.messages.length > current.messages.length;
+  }
+  return candidate.filePath < current.filePath;
+}
+function resolveConversationId(transcript, transcripts) {
+  let current = transcript;
+  const visited = /* @__PURE__ */ new Set([current.sessionId]);
+  while (current.compressedFrom && !visited.has(current.compressedFrom)) {
+    visited.add(current.compressedFrom);
+    const source = transcripts.get(current.compressedFrom);
+    if (!source) return current.compressedFrom;
+    current = source;
+  }
+  return current.sessionId;
+}
+function mayStillBeWriting(filePath, now) {
+  try {
+    return now - statSync6(filePath).mtimeMs < DAMAGED_TRANSCRIPT_SETTLE_MS;
+  } catch {
+    return true;
+  }
+}
+function distanceToNearest(sortedTimes, time) {
+  let low = 0;
+  let high = sortedTimes.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (sortedTimes[middle] < time) low = middle + 1;
+    else high = middle;
+  }
+  let distance = Number.POSITIVE_INFINITY;
+  if (low < sortedTimes.length) distance = sortedTimes[low] - time;
+  if (low > 0) distance = Math.min(distance, time - sortedTimes[low - 1]);
+  return distance;
+}
+function attributeUsage(entries, windows) {
+  if (windows.length === 0) return;
+  const byStart = [...windows].sort((left, right) => left.start - right.start);
+  const byTime = entries.map((entry) => ({ entry, time: entry.timestamp.getTime() })).sort((left, right) => left.time - right.time);
+  const open = [];
+  let nextWindow = 0;
+  for (const { entry, time } of byTime) {
+    while (nextWindow < byStart.length && byStart[nextWindow].start <= time) {
+      open.push(byStart[nextWindow]);
+      nextWindow++;
+    }
+    let kept = 0;
+    let best;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (const window of open) {
+      if (window.end < time) continue;
+      open[kept++] = window;
+      const distance = distanceToNearest(window.assistantTimes, time);
+      if (best === void 0 || distance < bestDistance || distance === bestDistance && window.sessionId < best.sessionId) {
+        best = window;
+        bestDistance = distance;
+      }
+    }
+    open.length = kept;
+    if (best) entry.sessionId = best.sessionId;
+  }
+}
 var SnowParser = class {
-  constructor(dataDir = DEFAULT_DATA_DIR6) {
-    this.dataDir = dataDir;
-    this.tool = { id: "snow", name: "Snow CLI", dataDir };
+  constructor(snowDir = DEFAULT_SNOW_DIR) {
+    this.snowDir = snowDir;
+    this.tool = {
+      id: "snow",
+      name: "Snow CLI",
+      dataDir: join23(snowDir, USAGE_DIR_NAME)
+    };
   }
-  dataDir;
+  snowDir;
   tool;
   async parse() {
+    const usage = this.parseUsage();
+    const sessions = this.parseSessions();
+    attributeUsage(usage.entries, sessions.windows);
+    return {
+      buckets: aggregateToBuckets(usage.entries),
+      sessions: extractSessions(sessions.events, usage.entries),
+      ...usage.incomplete ? { incomplete: true } : {}
+    };
+  }
+  listSourceFiles() {
+    return [
+      ...findSourceFiles(join23(this.snowDir, USAGE_DIR_NAME), ".jsonl"),
+      ...findSourceFiles(join23(this.snowDir, SESSIONS_DIR_NAME), ".json")
+    ];
+  }
+  /**
+   * Build session timing events plus the windows used to attribute usage
+   * records. Message timestamps drive turn boundaries, so active time, session
+   * duration, and message counts all come from real transcripts.
+   *
+   * Transcripts only feed sessions, never buckets, so a damaged one is skipped
+   * rather than holding back the whole source: Snow cannot open it either and
+   * will not rewrite it, so deferring would block Snow uploads for good.
+   */
+  parseSessions() {
+    const transcripts = /* @__PURE__ */ new Map();
+    const damaged = [];
+    const now = Date.now();
+    for (const filePath of findSourceFiles(
+      join23(this.snowDir, SESSIONS_DIR_NAME),
+      ".json"
+    )) {
+      const read = readTranscript(filePath);
+      if (read.status === "damaged") {
+        if (!mayStillBeWriting(filePath, now)) damaged.push(filePath);
+        continue;
+      }
+      if (read.status === "foreign") continue;
+      const current = transcripts.get(read.transcript.sessionId);
+      if (!current || isNewerCopy(read.transcript, current)) {
+        transcripts.set(read.transcript.sessionId, read.transcript);
+      }
+    }
+    if (damaged.length > 0) {
+      const more = damaged.length > 1 ? ` and ${damaged.length - 1} more` : "";
+      logger.warn(
+        `Skipped damaged Snow session file ${damaged[0]}${more}. Token usage is still counted.`
+      );
+    }
+    const events = [];
+    const windows = [];
+    for (const transcript of transcripts.values()) {
+      if (transcript.messages.length === 0) continue;
+      const sessionId = resolveConversationId(transcript, transcripts);
+      const assistantTimes = [];
+      let start = Number.POSITIVE_INFINITY;
+      let end = Number.NEGATIVE_INFINITY;
+      for (const message of transcript.messages) {
+        events.push({
+          sessionId,
+          source: "snow",
+          project: transcript.project,
+          timestamp: new Date(message.time),
+          role: message.role
+        });
+        if (message.role === "assistant") assistantTimes.push(message.time);
+        if (message.time < start) start = message.time;
+        if (message.time > end) end = message.time;
+      }
+      windows.push({
+        sessionId,
+        assistantTimes: assistantTimes.sort((left, right) => left - right),
+        start: start - SESSION_MATCH_WINDOW_MS,
+        end: end + SESSION_MATCH_WINDOW_MS
+      });
+    }
+    return { events, windows };
+  }
+  /**
+   * Parse usage JSONL. Session attribution happens afterwards, because it needs
+   * the transcripts.
+   *
+   * The bucket project stays `unknown` on purpose; see the note on
+   * `SESSION_MATCH_WINDOW_MS`.
+   */
+  parseUsage() {
     const entries = [];
-    for (const filePath of findJsonlFiles(this.dataDir)) {
+    let incomplete = false;
+    for (const filePath of findSourceFiles(
+      join23(this.snowDir, USAGE_DIR_NAME),
+      ".jsonl"
+    )) {
       const content = readFileSafe(filePath);
-      if (!content) continue;
+      if (content === null) {
+        if (existsSync22(filePath)) incomplete = true;
+        continue;
+      }
       for (const line of content.split("\n")) {
         if (!line.trim()) continue;
+        let record;
         try {
-          const record = JSON.parse(line);
-          if (typeof record.timestamp !== "string") continue;
-          const timestamp = new Date(record.timestamp);
-          if (Number.isNaN(timestamp.getTime())) continue;
-          const inputTokens = toNonNegativeNumber2(record.inputTokens);
-          const outputTokens = toNonNegativeNumber2(record.outputTokens);
-          const cachedTokens = toNonNegativeNumber2(record.cacheReadInputTokens);
-          const reasoningTokens = toNonNegativeNumber2(record.reasoningTokens);
-          if (inputTokens + outputTokens + cachedTokens + reasoningTokens === 0)
-            continue;
-          entries.push({
-            source: "snow",
-            model: typeof record.model === "string" && record.model ? record.model : "unknown",
-            project: "unknown",
-            timestamp,
-            inputTokens,
-            outputTokens,
-            reasoningTokens,
-            cachedTokens
-          });
+          const parsed = JSON.parse(line);
+          if (!isRecord(parsed)) continue;
+          record = parsed;
         } catch {
+          continue;
         }
+        const time = toTime(record.timestamp);
+        if (time === null) continue;
+        const reportedInputTokens = toNonNegativeNumber2(record.inputTokens);
+        const outputTokens = toNonNegativeNumber2(record.outputTokens);
+        const cachedTokens = toNonNegativeNumber2(record.cacheReadInputTokens);
+        const cacheCreationTokens = toNonNegativeNumber2(
+          record.cacheCreationInputTokens
+        );
+        const reasoningTokens = toNonNegativeNumber2(record.reasoningTokens);
+        const inputTokens = record.cacheCreationInputTokens === void 0 && cachedTokens <= reportedInputTokens ? reportedInputTokens - cachedTokens : reportedInputTokens;
+        if (inputTokens + outputTokens + cachedTokens + cacheCreationTokens + reasoningTokens === 0)
+          continue;
+        entries.push({
+          source: "snow",
+          model: typeof record.model === "string" && record.model ? record.model : "unknown",
+          project: "unknown",
+          timestamp: new Date(time),
+          inputTokens,
+          outputTokens,
+          reasoningTokens,
+          cachedTokens,
+          cacheCreationTokens
+        });
       }
     }
-    return { buckets: aggregateToBuckets(entries), sessions: [] };
+    return { entries, incomplete };
   }
   isInstalled() {
-    return existsSync22(this.dataDir);
+    return existsSync22(join23(this.snowDir, USAGE_DIR_NAME));
   }
 };
 registerParser(new SnowParser());
 
+// src/parsers/snow-app.ts
+import { statSync as statSync7 } from "fs";
+import { homedir as homedir23 } from "os";
+import { dirname as dirname4, join as join24 } from "path";
+var TOOL_ID14 = "snow-app";
+var DEFAULT_DB_PATH3 = join24(homedir23(), ".snowapp", "snowapp.db");
+var SNAPSHOT_QUERY = `SELECT 'usage' AS kind, u.id, u.conversation_id AS sessionId,
+  u.directory_id AS directoryId,
+  u.model, u.created_at AS timestamp, '' AS role,
+  u.input_tokens AS inputTokens, u.output_tokens AS outputTokens,
+  u.cache_read_input_tokens AS cacheReadTokens,
+  u.cache_creation_input_tokens AS cacheCreationTokens,
+  '' AS forkedFrom, 0 AS forkMessageCount
+FROM usage_records u
+UNION ALL
+SELECT 'message' AS kind, m.id, m.conversation_id AS sessionId,
+  (SELECT u.directory_id FROM usage_records u
+    WHERE u.conversation_id = m.conversation_id
+    ORDER BY u.created_at, u.id LIMIT 1) AS directoryId,
+  '' AS model, m.created_at AS timestamp, m.role,
+  0 AS inputTokens, 0 AS outputTokens, 0 AS cacheReadTokens, 0 AS cacheCreationTokens,
+  '' AS forkedFrom, 0 AS forkMessageCount
+FROM chat_messages m
+WHERE m.role IN ('user', 'assistant')
+  AND EXISTS (SELECT 1 FROM usage_records u WHERE u.conversation_id = m.conversation_id)
+UNION ALL
+SELECT 'conversation' AS kind, c.conversation_id AS id, c.conversation_id AS sessionId,
+  '' AS directoryId, '' AS model, '' AS timestamp, '' AS role,
+  0 AS inputTokens, 0 AS outputTokens, 0 AS cacheReadTokens, 0 AS cacheCreationTokens,
+  c.forked_from_conversation_id AS forkedFrom, c.fork_message_count AS forkMessageCount
+FROM chat_conversations c
+WHERE EXISTS (SELECT 1 FROM usage_records u WHERE u.conversation_id = c.conversation_id)
+ORDER BY timestamp, kind, id`;
+function text(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function tokenCount4(value) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    throw new Error("Snow App contains invalid token counts; scan deferred.");
+  }
+  return value;
+}
+function parseTimestamp4(value) {
+  const raw = text(value);
+  const match = /^(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,3}))?(Z|[+-]\d{2}:\d{2})?$/.exec(
+    raw
+  );
+  if (!match)
+    throw new Error("Snow App contains an invalid timestamp; scan deferred.");
+  const [year, month, day, hour, minute, second] = match.slice(1, 7).map(Number);
+  const calendar = new Date(
+    Date.UTC(year, month - 1, day, hour, minute, second)
+  );
+  if (year < 1e3 || calendar.getUTCFullYear() !== year || calendar.getUTCMonth() !== month - 1 || calendar.getUTCDate() !== day || hour > 23 || minute > 59 || second > 59) {
+    throw new Error(
+      "Snow App contains an invalid calendar date; scan deferred."
+    );
+  }
+  const date = new Date(raw.replace(" ", "T"));
+  if (!Number.isFinite(date.getTime()) || !match[8] && (date.getFullYear() !== year || date.getMonth() !== month - 1 || date.getDate() !== day || date.getHours() !== hour || date.getMinutes() !== minute)) {
+    throw new Error(
+      "Snow App contains an invalid local timestamp; scan deferred."
+    );
+  }
+  if (date.getTime() < Date.UTC(2020, 0, 1) || date.getTime() >= Date.UTC(2080, 0, 1)) {
+    throw new Error(
+      "Snow App timestamp is outside the supported range; scan deferred."
+    );
+  }
+  if (!match[8]) {
+    const nextDay = new Date(date);
+    nextDay.setDate(nextDay.getDate() + 1);
+    const overlapMinutes = nextDay.getTimezoneOffset() - date.getTimezoneOffset();
+    if (overlapMinutes > 0) {
+      const later = new Date(date.getTime() + overlapMinutes * 6e4);
+      if (later.getHours() === hour && later.getMinutes() === minute && later.getDate() === day) {
+        throw new Error(
+          "Snow App contains an ambiguous local timestamp; scan deferred."
+        );
+      }
+    }
+  }
+  const elapsed = date.getTime() - roundToHalfHour(date).getTime();
+  if (elapsed < 0 || elapsed >= 30 * 6e4) {
+    throw new Error(
+      "Snow App timestamp cannot be bucketed safely across DST; scan deferred."
+    );
+  }
+  return date;
+}
+function projectName(value) {
+  if (value === "") return "unknown";
+  if (typeof value !== "string" || !/^local:(?:[A-Za-z]:[\\/]|\/|\\\\)/.test(value)) {
+    throw new Error(
+      "Snow App contains an unsupported directory identity; scan deferred."
+    );
+  }
+  return value.slice("local:".length).split(/[\\/]+/).filter(Boolean).at(-1) || "unknown";
+}
+var SnowAppParser = class {
+  tool;
+  dbPath;
+  queryRows;
+  constructor(options = {}) {
+    this.dbPath = options.dbPath ?? DEFAULT_DB_PATH3;
+    this.queryRows = options.queryRows ?? readSqliteRowsReadonly;
+    this.tool = {
+      id: TOOL_ID14,
+      name: "Snow App",
+      dataDir: dirname4(this.dbPath)
+    };
+  }
+  isInstalled() {
+    try {
+      return statSync7(this.dbPath).isFile();
+    } catch (error) {
+      if (error.code === "ENOENT") return false;
+      throw error;
+    }
+  }
+  // Intentionally no parse cache: DB mtime alone misses uncheckpointed WAL writes.
+  async parse() {
+    if (!this.isInstalled()) return { buckets: [], sessions: [] };
+    const rows = await this.queryRows(this.dbPath, SNAPSHOT_QUERY);
+    const entries = [];
+    const events = [];
+    const seen = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const id = text(row.id);
+      if (!id || row.kind !== "usage" && row.kind !== "message" && row.kind !== "conversation") {
+        throw new Error(
+          "Snow App contains an invalid record identity; scan deferred."
+        );
+      }
+      const key = JSON.stringify([row.kind, id]);
+      const signature = JSON.stringify(row);
+      const previous = seen.get(key);
+      if (previous !== void 0) {
+        if (previous !== signature)
+          throw new Error("Conflicting Snow App record IDs; scan deferred.");
+        continue;
+      }
+      seen.set(key, signature);
+      if (row.kind === "conversation") {
+        if (typeof row.forkedFrom !== "string" || row.forkedFrom !== "" || row.forkMessageCount !== 0) {
+          throw new Error(
+            "Snow App fork metadata is unsupported or invalid; scan deferred."
+          );
+        }
+        continue;
+      }
+      const sessionId = text(row.sessionId);
+      const project = projectName(row.directoryId);
+      if (row.kind === "message") {
+        if (!sessionId || row.role !== "user" && row.role !== "assistant") {
+          throw new Error(
+            "Snow App contains invalid message metadata; scan deferred."
+          );
+        }
+        events.push({
+          sessionId,
+          source: TOOL_ID14,
+          project,
+          role: row.role,
+          timestamp: parseTimestamp4(row.timestamp)
+        });
+        continue;
+      }
+      const input2 = tokenCount4(row.inputTokens);
+      const outputTokens = tokenCount4(row.outputTokens);
+      const cachedTokens = Math.min(input2, tokenCount4(row.cacheReadTokens));
+      const cacheCreationTokens = tokenCount4(row.cacheCreationTokens);
+      if (cacheCreationTokens > input2 - cachedTokens || !Number.isSafeInteger(input2 + outputTokens)) {
+        throw new Error(
+          "Snow App cache counts exceed inclusive input; scan deferred."
+        );
+      }
+      if (input2 + outputTokens === 0) continue;
+      entries.push({
+        sessionId: sessionId || void 0,
+        source: TOOL_ID14,
+        project,
+        model: text(row.model) || "unknown",
+        timestamp: parseTimestamp4(row.timestamp),
+        inputTokens: input2 - cachedTokens - cacheCreationTokens,
+        outputTokens,
+        cachedTokens,
+        cacheCreationTokens,
+        reasoningTokens: 0
+      });
+    }
+    const buckets = aggregateToBuckets(entries);
+    const sessions = extractSessions(events, entries);
+    if ([...buckets, ...sessions].some(
+      (row) => !Number.isSafeInteger(row.totalTokens)
+    ) || sessions.some(
+      (row) => row.durationSeconds > 2147483647 || row.activeSeconds > 2147483647
+    )) {
+      throw new Error(
+        "Snow App aggregate exceeds supported counts or duration; scan deferred."
+      );
+    }
+    return { buckets, sessions };
+  }
+};
+registerParser(new SnowAppParser());
+
 // src/parsers/cursor.ts
 import { execFileSync as execFileSync4 } from "child_process";
 import { copyFileSync as copyFileSync2, existsSync as existsSync23, mkdtempSync as mkdtempSync2, rmSync as rmSync2 } from "fs";
-import { homedir as homedir23, tmpdir as tmpdir2 } from "os";
-import { dirname as dirname4, join as join24, resolve as resolve2 } from "path";
-var TOOL_ID14 = "cursor";
+import { homedir as homedir24, tmpdir as tmpdir2 } from "os";
+import { dirname as dirname5, join as join25, resolve as resolve2 } from "path";
+var TOOL_ID15 = "cursor";
 var TOOL_NAME13 = "Cursor";
-var STATE_DB_RELATIVE = join24("User", "globalStorage", "state.vscdb");
+var STATE_DB_RELATIVE = join25("User", "globalStorage", "state.vscdb");
 var ACCESS_TOKEN_KEY = "cursorAuth/accessToken";
 var SESSION_COOKIE = "WorkosCursorSessionToken";
 var FETCH_TIMEOUT_MS = 1e4;
 function getDefaultStateDbPath() {
   if (process.platform === "darwin") {
-    return join24(
-      homedir23(),
+    return join25(
+      homedir24(),
       "Library",
       "Application Support",
       "Cursor",
@@ -4571,11 +5067,11 @@ function getDefaultStateDbPath() {
     );
   }
   if (process.platform === "win32") {
-    const appData = process.env.APPDATA?.trim() || join24(homedir23(), "AppData", "Roaming");
-    return join24(appData, "Cursor", STATE_DB_RELATIVE);
+    const appData = process.env.APPDATA?.trim() || join25(homedir24(), "AppData", "Roaming");
+    return join25(appData, "Cursor", STATE_DB_RELATIVE);
   }
-  const xdgConfigHome = process.env.XDG_CONFIG_HOME?.trim() || join24(homedir23(), ".config");
-  return join24(xdgConfigHome, "Cursor", STATE_DB_RELATIVE);
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME?.trim() || join25(homedir24(), ".config");
+  return join25(xdgConfigHome, "Cursor", STATE_DB_RELATIVE);
 }
 function getCursorStateDbPath() {
   const explicit = process.env.CURSOR_STATE_DB_PATH?.trim();
@@ -4586,7 +5082,7 @@ function getCursorStateDbPath() {
   const configDirs = process.env.CURSOR_CONFIG_DIR?.trim();
   const candidates = configDirs ? configDirs.split(",").map((v) => v.trim()).filter(Boolean).map((v) => {
     const r = resolve2(v);
-    return r.endsWith(".vscdb") ? r : join24(r, STATE_DB_RELATIVE);
+    return r.endsWith(".vscdb") ? r : join25(r, STATE_DB_RELATIVE);
   }) : [getDefaultStateDbPath()];
   for (const c of candidates) {
     if (existsSync23(c)) return c;
@@ -4629,8 +5125,8 @@ function readAccessToken(dbPath) {
     return queryAccessToken(dbPath);
   } catch (err) {
     if (!isLockError2(err)) throw err;
-    const snapshotDir = mkdtempSync2(join24(tmpdir2(), "tokenarena-cursor-"));
-    const queryPath = join24(snapshotDir, "state.vscdb");
+    const snapshotDir = mkdtempSync2(join25(tmpdir2(), "tokenarena-cursor-"));
+    const queryPath = join25(snapshotDir, "state.vscdb");
     try {
       copyFileSync2(dbPath, queryPath);
       for (const suffix of ["-shm", "-wal"]) {
@@ -4693,17 +5189,17 @@ async function fetchUsageCsv(token) {
   }
   throw new Error(`Cursor usage export auth failed (${failures.join("; ")})`);
 }
-function parseCsv(text) {
+function parseCsv(text2) {
   const rows = [];
   let field = "";
   let row = [];
   let inQuotes = false;
   let i = 0;
-  while (i < text.length) {
-    const c = text[i];
+  while (i < text2.length) {
+    const c = text2[i];
     if (inQuotes) {
       if (c === '"') {
-        if (text[i + 1] === '"') {
+        if (text2[i + 1] === '"') {
           field += '"';
           i += 2;
           continue;
@@ -4763,9 +5259,9 @@ function parseInt0(value) {
 }
 function createToolDefinition9(dbPath) {
   return {
-    id: TOOL_ID14,
+    id: TOOL_ID15,
     name: TOOL_NAME13,
-    dataDir: dirname4(dbPath)
+    dataDir: dirname5(dbPath)
   };
 }
 var CursorParser = class {
@@ -4827,7 +5323,7 @@ var CursorParser = class {
       const output = outputIdx >= 0 ? parseInt0(row[outputIdx]) : 0;
       if (inputCacheWrite + inputNoCache + cacheRead + output === 0) continue;
       entries.push({
-        source: TOOL_ID14,
+        source: TOOL_ID15,
         model,
         project: "unknown",
         timestamp,
@@ -4852,11 +5348,11 @@ registerParser(new CursorParser());
 // src/parsers/zcode.ts
 import { createHash as createHash5 } from "crypto";
 import { existsSync as existsSync24 } from "fs";
-import { homedir as homedir24, hostname as hostname5 } from "os";
-import { dirname as dirname5, join as join25 } from "path";
-var TOOL_ID15 = "zcode";
+import { homedir as homedir25, hostname as hostname5 } from "os";
+import { dirname as dirname6, join as join26 } from "path";
+var TOOL_ID16 = "zcode";
 var TOOL_NAME14 = "ZCode";
-var DEFAULT_DB_PATH3 = join25(homedir24(), ".zcode", "cli", "db", "db.sqlite");
+var DEFAULT_DB_PATH4 = join26(homedir25(), ".zcode", "cli", "db", "db.sqlite");
 var MODEL_USAGE_QUERY = `SELECT
   model_usage.session_id as sessionId,
   session.directory as directory,
@@ -4865,13 +5361,15 @@ var MODEL_USAGE_QUERY = `SELECT
   model_usage.input_tokens as inputTokens,
   model_usage.output_tokens as outputTokens,
   model_usage.reasoning_tokens as reasoningTokens,
-  model_usage.cache_read_input_tokens as cacheReadInputTokens
+  model_usage.cache_read_input_tokens as cacheReadInputTokens,
+  model_usage.cache_creation_input_tokens as cacheCreationInputTokens
   FROM model_usage
   LEFT JOIN session ON session.id = model_usage.session_id
   WHERE model_usage.input_tokens > 0
     OR model_usage.output_tokens > 0
     OR model_usage.reasoning_tokens > 0
-    OR model_usage.cache_read_input_tokens > 0`;
+    OR model_usage.cache_read_input_tokens > 0
+    OR model_usage.cache_creation_input_tokens > 0`;
 var SESSION_QUERY = `SELECT
   id,
   directory,
@@ -4891,9 +5389,9 @@ var TURN_USAGE_QUERY = `SELECT
   WHERE duration_ms IS NOT NULL`;
 function createToolDefinition10(dbPath) {
   return {
-    id: TOOL_ID15,
+    id: TOOL_ID16,
     name: TOOL_NAME14,
-    dataDir: dirname5(dbPath)
+    dataDir: dirname6(dbPath)
   };
 }
 function toSafeNumber10(value) {
@@ -4940,7 +5438,7 @@ function getOrCreateDraft(drafts, sessionId, project) {
   }
   const next = {
     sessionId,
-    source: TOOL_ID15,
+    source: TOOL_ID16,
     project,
     firstMessageAt: null,
     lastMessageAt: null,
@@ -4965,13 +5463,15 @@ function buildSessionUsage3(entries) {
       byModel = /* @__PURE__ */ new Map();
       usageBySession.set(entry.sessionId, byModel);
     }
-    const totalTokens = entry.inputTokens + entry.outputTokens + entry.reasoningTokens + entry.cachedTokens;
+    const cacheCreationTokens = entry.cacheCreationTokens ?? 0;
+    const totalTokens = entry.inputTokens + entry.outputTokens + entry.reasoningTokens + entry.cachedTokens + cacheCreationTokens;
     const existing = byModel.get(entry.model);
     if (existing) {
       existing.inputTokens += entry.inputTokens;
       existing.outputTokens += entry.outputTokens;
       existing.reasoningTokens += entry.reasoningTokens;
       existing.cachedTokens += entry.cachedTokens;
+      existing.cacheCreationTokens = (existing.cacheCreationTokens ?? 0) + cacheCreationTokens;
       existing.totalTokens += totalTokens;
       continue;
     }
@@ -4981,6 +5481,7 @@ function buildSessionUsage3(entries) {
       outputTokens: entry.outputTokens,
       reasoningTokens: entry.reasoningTokens,
       cachedTokens: entry.cachedTokens,
+      cacheCreationTokens,
       totalTokens
     });
   }
@@ -5068,6 +5569,10 @@ function buildSessions2(input2) {
       (sum, usage) => sum + usage.cachedTokens,
       0
     );
+    const cacheCreationTokens = modelUsages.reduce(
+      (sum, usage) => sum + (usage.cacheCreationTokens ?? 0),
+      0
+    );
     const totalTokens = modelUsages.reduce(
       (sum, usage) => sum + usage.totalTokens,
       0
@@ -5094,6 +5599,7 @@ function buildSessions2(input2) {
       outputTokens,
       reasoningTokens,
       cachedTokens,
+      cacheCreationTokens,
       totalTokens,
       primaryModel: modelUsages[0]?.model ?? "",
       modelUsages
@@ -5105,7 +5611,7 @@ var ZCodeParser = class {
   dbPath;
   queryRows;
   constructor(options = {}) {
-    this.dbPath = options.dbPath || DEFAULT_DB_PATH3;
+    this.dbPath = options.dbPath || DEFAULT_DB_PATH4;
     this.queryRows = options.queryRows || readSqliteRows;
     this.tool = createToolDefinition10(this.dbPath);
   }
@@ -5123,23 +5629,31 @@ var ZCodeParser = class {
       if (!timestamp) {
         continue;
       }
-      const inputTokens = toSafeNumber10(row.inputTokens);
-      const outputTokens = toSafeNumber10(row.outputTokens);
-      const reasoningTokens = toSafeNumber10(row.reasoningTokens);
       const cachedTokens = toSafeNumber10(row.cacheReadInputTokens);
-      if (inputTokens === 0 && outputTokens === 0 && reasoningTokens === 0 && cachedTokens === 0) {
+      const cacheCreationTokens = toSafeNumber10(row.cacheCreationInputTokens);
+      const inputTokens = Math.max(
+        0,
+        toSafeNumber10(row.inputTokens) - cachedTokens - cacheCreationTokens
+      );
+      const reasoningTokens = toSafeNumber10(row.reasoningTokens);
+      const outputTokens = Math.max(
+        0,
+        toSafeNumber10(row.outputTokens) - reasoningTokens
+      );
+      if (inputTokens + outputTokens + reasoningTokens + cachedTokens + cacheCreationTokens === 0) {
         continue;
       }
       entries.push({
         sessionId: getString3(row.sessionId) ?? void 0,
-        source: TOOL_ID15,
+        source: TOOL_ID16,
         model: getString3(row.model) ?? "unknown",
         project: getPathLeaf7(getString3(row.directory)),
         timestamp,
         inputTokens,
         outputTokens,
         reasoningTokens,
-        cachedTokens
+        cachedTokens,
+        cacheCreationTokens
       });
     }
     let sessionRows = [];
@@ -5174,20 +5688,20 @@ var ZCodeParser = class {
 registerParser(new ZCodeParser());
 
 // src/parsers/qodercli.ts
-import { existsSync as existsSync25, readdirSync as readdirSync12 } from "fs";
-import { homedir as homedir25 } from "os";
-import { basename as basename10, join as join26 } from "path";
-var TOOL_ID16 = "qodercli";
+import { existsSync as existsSync25, readdirSync as readdirSync13 } from "fs";
+import { homedir as homedir26 } from "os";
+import { basename as basename11, join as join27 } from "path";
+var TOOL_ID17 = "qodercli";
 var TOOL_NAME15 = "Qoder CLI";
-var DEFAULT_PROJECTS_DIR = join26(homedir25(), ".qoder", "projects");
-var DEFAULT_LOGS_DIR = join26(homedir25(), ".qoder", "logs", "sessions");
-var DEFAULT_RUNS_DIR = join26(homedir25(), ".qoder", "logs", "runs");
+var DEFAULT_PROJECTS_DIR = join27(homedir26(), ".qoder", "projects");
+var DEFAULT_LOGS_DIR = join27(homedir26(), ".qoder", "logs", "sessions");
+var DEFAULT_RUNS_DIR = join27(homedir26(), ".qoder", "logs", "runs");
 var CLI_ENTRYPOINT = "cli";
 var IDE_ENTRYPOINT = "acp";
 var CREDIT_MODEL_FALLBACK = "credits";
 function createToolDefinition11(projectsDir) {
   return {
-    id: TOOL_ID16,
+    id: TOOL_ID17,
     name: TOOL_NAME15,
     dataDir: projectsDir
   };
@@ -5227,11 +5741,11 @@ function classifyQoderEntrypoint(content) {
   return "unknown";
 }
 function isQodercliBinaryPresent() {
-  const home = homedir25();
+  const home = homedir26();
   const candidates = [
-    join26(home, ".local", "bin", "qodercli"),
-    join26(home, ".qoder", "bin", "qodercli"),
-    join26(home, ".qoder-cli")
+    join27(home, ".local", "bin", "qodercli"),
+    join27(home, ".qoder", "bin", "qodercli"),
+    join27(home, ".qoder-cli")
   ];
   return candidates.some((path) => existsSync25(path));
 }
@@ -5241,7 +5755,7 @@ function projectFromEncodedSlug(slug) {
 }
 function projectFromCwd(cwd) {
   if (!cwd) return "unknown";
-  const leaf = basename10(cwd.replace(/[\\/]+$/, ""));
+  const leaf = basename11(cwd.replace(/[\\/]+$/, ""));
   return leaf || "unknown";
 }
 function totalCreditsUsed(quota) {
@@ -5304,7 +5818,7 @@ function creditSnapshotsToEntries(snapshots) {
       if (creditDelta > 0) {
         entries.push({
           sessionId: snap.sessionId,
-          source: TOOL_ID16,
+          source: TOOL_ID17,
           model: snap.model || CREDIT_MODEL_FALLBACK,
           project: snap.project,
           timestamp: snap.timestamp,
@@ -5344,7 +5858,7 @@ var QoderCliParser = class {
   parseProjectSessions(sessionEvents) {
     if (!existsSync25(this.projectsDir)) return;
     for (const filePath of findJsonlFiles(this.projectsDir)) {
-      if (basename10(filePath).startsWith("verified-")) continue;
+      if (basename11(filePath).startsWith("verified-")) continue;
       const content = readFileSafe(filePath);
       if (!content) continue;
       if (classifyQoderEntrypoint(content) !== CLI_ENTRYPOINT) continue;
@@ -5364,7 +5878,7 @@ var QoderCliParser = class {
           if (Number.isNaN(ts.getTime())) continue;
           sessionEvents.push({
             sessionId,
-            source: TOOL_ID16,
+            source: TOOL_ID17,
             project,
             timestamp: ts,
             role: obj.type === "user" ? "user" : "assistant"
@@ -5382,7 +5896,7 @@ var QoderCliParser = class {
     if (!existsSync25(this.runsDir)) return [];
     let runDirs;
     try {
-      runDirs = readdirSync12(this.runsDir, { withFileTypes: true }).filter(
+      runDirs = readdirSync13(this.runsDir, { withFileTypes: true }).filter(
         (d) => d.isDirectory()
       );
     } catch {
@@ -5390,15 +5904,15 @@ var QoderCliParser = class {
     }
     const allSnapshots = [];
     for (const dir of runDirs) {
-      const runPath = join26(this.runsDir, dir.name);
-      const logPath = join26(runPath, "qodercli.log");
+      const runPath = join27(this.runsDir, dir.name);
+      const logPath = join27(runPath, "qodercli.log");
       if (!existsSync25(logPath)) continue;
       const logContent = readFileSafe(logPath);
       if (!logContent?.includes("quota/usage response:")) {
         continue;
       }
       const manifest = parseRunManifest(
-        readFileSafe(join26(runPath, "manifest.json"))
+        readFileSafe(join27(runPath, "manifest.json"))
       );
       const project = manifest?.project_id ? projectFromEncodedSlug(manifest.project_id) : projectFromCwd(manifest?.cwd);
       const snapshots = extractCreditSnapshotsFromLog(logContent, {
@@ -5416,16 +5930,16 @@ var QoderCliParser = class {
 registerParser(new QoderCliParser());
 
 // src/parsers/grok-build.ts
-import { existsSync as existsSync26, readdirSync as readdirSync13 } from "fs";
-import { homedir as homedir26 } from "os";
-import { basename as basename11, join as join27 } from "path";
-var TOOL_ID17 = "grok-build";
+import { existsSync as existsSync26, readdirSync as readdirSync14 } from "fs";
+import { homedir as homedir27 } from "os";
+import { basename as basename12, join as join28 } from "path";
+var TOOL_ID18 = "grok-build";
 var TOOL_NAME16 = "Grok Build";
-var DEFAULT_DATA_DIR7 = join27(homedir26(), ".grok", "sessions");
-var DEFAULT_ARCHIVE_DIR2 = join27(homedir26(), ".grok", "archived_sessions");
+var DEFAULT_DATA_DIR6 = join28(homedir27(), ".grok", "sessions");
+var DEFAULT_ARCHIVE_DIR2 = join28(homedir27(), ".grok", "archived_sessions");
 function createToolDefinition12(dataDir) {
   return {
-    id: TOOL_ID17,
+    id: TOOL_ID18,
     name: TOOL_NAME16,
     dataDir
   };
@@ -5437,10 +5951,10 @@ function toSafeNumber12(value) {
 function projectFromEncodedCwd(encoded) {
   try {
     const decoded = decodeURIComponent(encoded);
-    const leaf = basename11(decoded.replace(/[\\/]+$/, ""));
+    const leaf = basename12(decoded.replace(/[\\/]+$/, ""));
     return leaf || "unknown";
   } catch {
-    const leaf = basename11(encoded);
+    const leaf = basename12(encoded);
     return leaf || "unknown";
   }
 }
@@ -5477,7 +5991,7 @@ function pushUsageEntries(entries, args) {
     }
     modelEntries.push({
       sessionId,
-      source: TOOL_ID17,
+      source: TOOL_ID18,
       model: model || fallbackModel || "unknown",
       project,
       timestamp,
@@ -5494,25 +6008,25 @@ function findSessionDirs(dataDir) {
   if (!existsSync26(dataDir)) return results;
   let projectDirs;
   try {
-    projectDirs = readdirSync13(dataDir, { withFileTypes: true });
+    projectDirs = readdirSync14(dataDir, { withFileTypes: true });
   } catch {
     return results;
   }
   for (const projectEntry of projectDirs) {
     if (!projectEntry.isDirectory()) continue;
     if (projectEntry.name.endsWith(".sqlite")) continue;
-    const projectDir = join27(dataDir, projectEntry.name);
+    const projectDir = join28(dataDir, projectEntry.name);
     const project = projectFromEncodedCwd(projectEntry.name);
     let sessionEntries;
     try {
-      sessionEntries = readdirSync13(projectDir, { withFileTypes: true });
+      sessionEntries = readdirSync14(projectDir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const sessionEntry of sessionEntries) {
       if (!sessionEntry.isDirectory()) continue;
-      const sessionDir = join27(projectDir, sessionEntry.name);
-      if (!existsSync26(join27(sessionDir, "updates.jsonl"))) continue;
+      const sessionDir = join28(projectDir, sessionEntry.name);
+      if (!existsSync26(join28(sessionDir, "updates.jsonl"))) continue;
       results.push({
         sessionDir,
         project,
@@ -5523,7 +6037,7 @@ function findSessionDirs(dataDir) {
   return results;
 }
 function readFallbackModel(sessionDir) {
-  const summaryPath = join27(sessionDir, "summary.json");
+  const summaryPath = join28(sessionDir, "summary.json");
   const content = readFileSafe(summaryPath);
   if (!content) return "unknown";
   try {
@@ -5534,7 +6048,7 @@ function readFallbackModel(sessionDir) {
   }
 }
 var GrokBuildParser = class {
-  constructor(dataDir = DEFAULT_DATA_DIR7, archiveDir = dataDir === DEFAULT_DATA_DIR7 ? DEFAULT_ARCHIVE_DIR2 : void 0) {
+  constructor(dataDir = DEFAULT_DATA_DIR6, archiveDir = dataDir === DEFAULT_DATA_DIR6 ? DEFAULT_ARCHIVE_DIR2 : void 0) {
     this.dataDir = dataDir;
     this.archiveDir = archiveDir;
     this.tool = createToolDefinition12(dataDir);
@@ -5550,7 +6064,7 @@ var GrokBuildParser = class {
       ...findSessionDirs(this.dataDir)
     ];
     for (const { sessionDir, project, sessionId } of sessions) {
-      const updatesPath = join27(sessionDir, "updates.jsonl");
+      const updatesPath = join28(sessionDir, "updates.jsonl");
       const content = readFileSafe(updatesPath);
       if (!content) continue;
       const fallbackModel = readFallbackModel(sessionDir);
@@ -5587,7 +6101,7 @@ var GrokBuildParser = class {
             ]),
             {
               sessionId: sid,
-              source: TOOL_ID17,
+              source: TOOL_ID18,
               project,
               timestamp: ts,
               role: "user"
@@ -5603,7 +6117,7 @@ var GrokBuildParser = class {
           continue;
         sessionEvents.set(eventKey, {
           sessionId: sid,
-          source: TOOL_ID17,
+          source: TOOL_ID18,
           project,
           timestamp: ts,
           role: "assistant"
@@ -5627,22 +6141,22 @@ var GrokBuildParser = class {
     };
   }
   isInstalled() {
-    return existsSync26(this.dataDir) || Boolean(this.archiveDir && existsSync26(this.archiveDir)) || existsSync26(join27(homedir26(), ".grok")) || existsSync26(join27(homedir26(), ".local", "bin", "grok"));
+    return existsSync26(this.dataDir) || Boolean(this.archiveDir && existsSync26(this.archiveDir)) || existsSync26(join28(homedir27(), ".grok")) || existsSync26(join28(homedir27(), ".local", "bin", "grok"));
   }
 };
 registerParser(new GrokBuildParser());
 
 // src/parsers/atomcode.ts
 import { existsSync as existsSync27 } from "fs";
-import { homedir as homedir27 } from "os";
-import { basename as basename12, join as join28 } from "path";
-var TOOL_ID18 = "atomcode";
+import { homedir as homedir28 } from "os";
+import { basename as basename13, join as join29 } from "path";
+var TOOL_ID19 = "atomcode";
 var TOOL_NAME17 = "AtomCode";
-var DEFAULT_SESSIONS_DIR6 = join28(homedir27(), ".atomcode", "sessions");
+var DEFAULT_SESSIONS_DIR6 = join29(homedir28(), ".atomcode", "sessions");
 function getAtomCodeSessionsDirs(env = process.env) {
   const dirs = [
     env.TOKEN_ARENA_ATOMCODE_DIR,
-    env.ATOMCODE_HOME ? join28(env.ATOMCODE_HOME, "sessions") : void 0,
+    env.ATOMCODE_HOME ? join29(env.ATOMCODE_HOME, "sessions") : void 0,
     DEFAULT_SESSIONS_DIR6
   ].filter((value) => Boolean(value));
   return Array.from(new Set(dirs));
@@ -5651,7 +6165,7 @@ function toNonNegativeNumber3(value) {
   const numberValue = Number(value);
   return Number.isFinite(numberValue) && numberValue >= 0 ? numberValue : 0;
 }
-function parseTimestamp4(value) {
+function parseTimestamp5(value) {
   if (typeof value === "number" && Number.isFinite(value)) {
     const timestamp = new Date(value);
     return Number.isNaN(timestamp.getTime()) ? null : timestamp;
@@ -5690,7 +6204,7 @@ function getMetaModel(meta) {
 }
 function getMetaProject(meta) {
   if (typeof meta?.working_dir === "string" && meta.working_dir) {
-    return basename12(meta.working_dir) || "unknown";
+    return basename13(meta.working_dir) || "unknown";
   }
   return "unknown";
 }
@@ -5700,7 +6214,7 @@ var AtomCodeParser = class {
   constructor(sessionsDir) {
     this.sessionsDirs = sessionsDir ? [sessionsDir] : getAtomCodeSessionsDirs();
     this.tool = {
-      id: TOOL_ID18,
+      id: TOOL_ID19,
       name: TOOL_NAME17,
       dataDir: this.sessionsDirs[0] ?? DEFAULT_SESSIONS_DIR6
     };
@@ -5723,12 +6237,12 @@ var AtomCodeParser = class {
         const model = getMetaModel(meta);
         for (const row of rows) {
           const sessionId = typeof row.session_id === "string" && row.session_id ? row.session_id : fallbackSessionId;
-          const timestamp = parseTimestamp4(row.ts);
+          const timestamp = parseTimestamp5(row.ts);
           if (!timestamp) continue;
           if (row.user !== void 0 || row.assistant !== void 0) {
             sessionEvents.push({
               sessionId,
-              source: TOOL_ID18,
+              source: TOOL_ID19,
               project,
               timestamp,
               role: row.user !== void 0 ? "user" : "assistant"
@@ -5757,7 +6271,7 @@ var AtomCodeParser = class {
           seenEntryKeys.add(entryKey);
           entries.push({
             sessionId,
-            source: TOOL_ID18,
+            source: TOOL_ID19,
             model,
             project,
             timestamp,
@@ -5781,18 +6295,18 @@ var AtomCodeParser = class {
 registerParser(new AtomCodeParser());
 
 // src/parsers/dsh.ts
-import { existsSync as existsSync28, readdirSync as readdirSync14, readFileSync as readFileSync9 } from "fs";
-import { homedir as homedir28 } from "os";
-import { basename as basename13, join as join29 } from "path";
+import { existsSync as existsSync28, readdirSync as readdirSync15, readFileSync as readFileSync9 } from "fs";
+import { homedir as homedir29 } from "os";
+import { basename as basename14, join as join30 } from "path";
 import * as zlib from "zlib";
-var TOOL_ID19 = "dsh";
+var TOOL_ID20 = "dsh";
 var TOOL_NAME18 = "DeepSeek Harness";
-var DEFAULT_SESSIONS_DIR7 = join29(homedir28(), ".dsh", "sessions");
+var DEFAULT_SESSIONS_DIR7 = join30(homedir29(), ".dsh", "sessions");
 var LOG_BASENAME = "session";
 function getDshSessionsDirs(env = process.env) {
   const dirs = [
     env.TOKEN_ARENA_DSH_DIR,
-    env.DSH_HOME ? join29(env.DSH_HOME, "sessions") : void 0,
+    env.DSH_HOME ? join30(env.DSH_HOME, "sessions") : void 0,
     DEFAULT_SESSIONS_DIR7
   ].filter((value) => Boolean(value));
   return Array.from(new Set(dirs));
@@ -5883,8 +6397,8 @@ function findSessionLogs(dir) {
   const results = [];
   if (!existsSync28(dir)) return results;
   try {
-    for (const entry of readdirSync14(dir, { withFileTypes: true })) {
-      const fullPath = join29(dir, entry.name);
+    for (const entry of readdirSync15(dir, { withFileTypes: true })) {
+      const fullPath = join30(dir, entry.name);
       if (entry.isDirectory()) {
         results.push(...findSessionLogs(fullPath));
       } else if (entry.name === `${LOG_BASENAME}.jsonl` || entry.name === `${LOG_BASENAME}.jsonl.zstd`) {
@@ -5915,7 +6429,7 @@ var DshParser = class {
   constructor(sessionsDir) {
     this.sessionsDirs = sessionsDir ? [sessionsDir] : getDshSessionsDirs();
     this.tool = {
-      id: TOOL_ID19,
+      id: TOOL_ID20,
       name: TOOL_NAME18,
       dataDir: this.sessionsDirs[0] ?? DEFAULT_SESSIONS_DIR7
     };
@@ -5933,7 +6447,7 @@ var DshParser = class {
         const relativeParts = filePath.slice(sessionsDir.length + 1).split(/[\\/]/);
         const header = rows[0]?.type === "session" ? rows[0] : void 0;
         const sessionId = (header?.id ?? decodeSegment(relativeParts[1] ?? "")) || "unknown";
-        const project = typeof header?.cwd === "string" && header.cwd ? basename13(header.cwd) || "unknown" : projectFromDirName(relativeParts[0] ?? "");
+        const project = typeof header?.cwd === "string" && header.cwd ? basename14(header.cwd) || "unknown" : projectFromDirName(relativeParts[0] ?? "");
         let currentModel = "unknown";
         for (const row of rows) {
           if (row.type === "request/context") {
@@ -5953,7 +6467,7 @@ var DshParser = class {
             if (timestamp) {
               sessionEvents.push({
                 sessionId,
-                source: TOOL_ID19,
+                source: TOOL_ID20,
                 project,
                 timestamp,
                 role: "user"
@@ -5966,7 +6480,7 @@ var DshParser = class {
           if (timestamp && !isCompaction) {
             sessionEvents.push({
               sessionId,
-              source: TOOL_ID19,
+              source: TOOL_ID20,
               project,
               timestamp,
               role: "assistant"
@@ -6001,7 +6515,7 @@ var DshParser = class {
           seenEntryKeys.add(entryKey);
           entries.push({
             sessionId,
-            source: TOOL_ID19,
+            source: TOOL_ID20,
             model,
             project,
             timestamp,
@@ -6027,11 +6541,11 @@ registerParser(new DshParser());
 
 // src/parsers/cherry-studio.ts
 import { existsSync as existsSync29 } from "fs";
-import { homedir as homedir29 } from "os";
-import { dirname as dirname6, join as join30, resolve as resolve3 } from "path";
-var TOOL_ID20 = "cherry-studio";
+import { homedir as homedir30 } from "os";
+import { dirname as dirname7, join as join31, resolve as resolve3 } from "path";
+var TOOL_ID21 = "cherry-studio";
 var TOOL_NAME19 = "Cherry Studio";
-var DB_RELATIVE = join30("Data", "cherrystudio.sqlite");
+var DB_RELATIVE = join31("Data", "cherrystudio.sqlite");
 var USAGE_QUERY = `SELECT
   u.model_id as modelId,
   u.no_cache_tokens as noCacheTokens,
@@ -6054,14 +6568,14 @@ var MESSAGES_QUERY3 = `SELECT
   ORDER BY created_at`;
 function getDefaultUserDataDir(env = process.env) {
   if (process.platform === "darwin") {
-    return join30(homedir29(), "Library", "Application Support", "CherryStudio");
+    return join31(homedir30(), "Library", "Application Support", "CherryStudio");
   }
   if (process.platform === "win32") {
-    const appData = env.APPDATA?.trim() || join30(homedir29(), "AppData", "Roaming");
-    return join30(appData, "CherryStudio");
+    const appData = env.APPDATA?.trim() || join31(homedir30(), "AppData", "Roaming");
+    return join31(appData, "CherryStudio");
   }
-  const xdgConfigHome = env.XDG_CONFIG_HOME?.trim() || join30(homedir29(), ".config");
-  return join30(xdgConfigHome, "CherryStudio");
+  const xdgConfigHome = env.XDG_CONFIG_HOME?.trim() || join31(homedir30(), ".config");
+  return join31(xdgConfigHome, "CherryStudio");
 }
 function getCherryStudioDbPaths(env = process.env) {
   const paths = [];
@@ -6069,10 +6583,10 @@ function getCherryStudioDbPaths(env = process.env) {
   if (explicit) {
     const resolved = resolve3(explicit);
     paths.push(
-      resolved.endsWith(".sqlite") ? resolved : join30(resolved, DB_RELATIVE)
+      resolved.endsWith(".sqlite") ? resolved : join31(resolved, DB_RELATIVE)
     );
   }
-  paths.push(join30(getDefaultUserDataDir(env), DB_RELATIVE));
+  paths.push(join31(getDefaultUserDataDir(env), DB_RELATIVE));
   return Array.from(new Set(paths));
 }
 function resolveCherryStudioDbPath() {
@@ -6081,9 +6595,9 @@ function resolveCherryStudioDbPath() {
 }
 function createToolDefinition13(dbPath) {
   return {
-    id: TOOL_ID20,
+    id: TOOL_ID21,
     name: TOOL_NAME19,
-    dataDir: dbPath ? dirname6(dbPath) : join30(getDefaultUserDataDir(), "Data")
+    dataDir: dbPath ? dirname7(dbPath) : join31(getDefaultUserDataDir(), "Data")
   };
 }
 function toSafeCount(value) {
@@ -6148,7 +6662,7 @@ var CherryStudioParser = class {
         // Rows the topic join could not resolve still count toward buckets,
         // they just cannot take part in session timing.
         sessionId: getNonEmptyString(row.sessionId) ?? void 0,
-        source: TOOL_ID20,
+        source: TOOL_ID21,
         model: getNonEmptyString(row.modelId) ?? "unknown",
         project: "unknown",
         timestamp,
@@ -6181,7 +6695,7 @@ var CherryStudioParser = class {
       if (!timestamp) continue;
       sessionEvents.push({
         sessionId,
-        source: TOOL_ID20,
+        source: TOOL_ID21,
         project: "unknown",
         timestamp,
         role
@@ -6210,25 +6724,25 @@ import {
   unlinkSync,
   writeFileSync
 } from "fs";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 
 // src/infrastructure/xdg.ts
-import { homedir as homedir30 } from "os";
-import { join as join31 } from "path";
+import { homedir as homedir31 } from "os";
+import { join as join32 } from "path";
 function getConfigHome() {
-  return process.env.XDG_CONFIG_HOME || join31(homedir30(), ".config");
+  return process.env.XDG_CONFIG_HOME || join32(homedir31(), ".config");
 }
 function getStateHome() {
-  return process.env.XDG_STATE_HOME || join31(homedir30(), ".local", "state");
+  return process.env.XDG_STATE_HOME || join32(homedir31(), ".local", "state");
 }
 function getRuntimeDir() {
   return process.env.XDG_RUNTIME_DIR || getStateHome();
 }
 
 // src/infrastructure/config/manager.ts
-var CONFIG_DIR = join32(getConfigHome(), "tokenarena");
+var CONFIG_DIR = join33(getConfigHome(), "tokenarena");
 var isDev = process.env.TOKEN_ARENA_DEV === "1";
-var CONFIG_FILE = join32(CONFIG_DIR, isDev ? "config.dev.json" : "config.json");
+var CONFIG_FILE = join33(CONFIG_DIR, isDev ? "config.dev.json" : "config.json");
 var DEFAULT_API_URL = "https://token.guji.uno";
 var VALID_CONFIG_KEYS = [
   "apiKey",
@@ -7090,22 +7604,22 @@ import {
 
 // src/infrastructure/runtime/paths.ts
 import { mkdirSync as mkdirSync2 } from "fs";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 var APP_NAME = "tokenarena";
 function getRuntimeDirPath() {
-  return join33(getRuntimeDir(), APP_NAME);
+  return join34(getRuntimeDir(), APP_NAME);
 }
 function getStateDir() {
-  return join33(getStateHome(), APP_NAME);
+  return join34(getStateHome(), APP_NAME);
 }
 function getSyncLockPath() {
-  return join33(getRuntimeDirPath(), "sync.lock");
+  return join34(getRuntimeDirPath(), "sync.lock");
 }
 function getSyncStatePath() {
-  return join33(getStateDir(), "status.json");
+  return join34(getStateDir(), "status.json");
 }
 function getUploadManifestPath() {
-  return join33(getStateDir(), "upload-manifest.json");
+  return join34(getStateDir(), "upload-manifest.json");
 }
 function ensureAppDirs() {
   mkdirSync2(getRuntimeDirPath(), { recursive: true });
@@ -7311,19 +7825,19 @@ function saveUploadManifest(manifest) {
 
 // src/services/parse-cache.ts
 import { createHash as createHash7 } from "crypto";
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync14, statSync as statSync6, writeFileSync as writeFileSync5 } from "fs";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync14, statSync as statSync8, writeFileSync as writeFileSync5 } from "fs";
 import { hostname as hostname6 } from "os";
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 
 // src/infrastructure/runtime/cli-version.ts
-import { dirname as dirname7, join as join34 } from "path";
+import { dirname as dirname8, join as join35 } from "path";
 import { fileURLToPath } from "url";
 var FALLBACK_VERSION = "0.0.0";
 var versionCache = /* @__PURE__ */ new Map();
 function readPackageVersion(startDir) {
   let dir = startDir;
   while (true) {
-    const contents = readFileSafe(join34(dir, "package.json"));
+    const contents = readFileSafe(join35(dir, "package.json"));
     if (contents !== null) {
       try {
         const { version } = JSON.parse(contents);
@@ -7332,7 +7846,7 @@ function readPackageVersion(startDir) {
         return void 0;
       }
     }
-    const parent = dirname7(dir);
+    const parent = dirname8(dir);
     if (parent === dir) {
       return void 0;
     }
@@ -7340,7 +7854,7 @@ function readPackageVersion(startDir) {
   }
 }
 function getCliVersion(metaUrl = import.meta.url) {
-  const startDir = dirname7(fileURLToPath(metaUrl));
+  const startDir = dirname8(fileURLToPath(metaUrl));
   const cached = versionCache.get(startDir);
   if (cached !== void 0) {
     return cached;
@@ -7354,10 +7868,10 @@ function getCliVersion(metaUrl = import.meta.url) {
 var CACHE_FORMAT_VERSION = 1;
 var SETTLE_MS = 5e3;
 function getParseCacheDir() {
-  return join35(getStateDir(), "parse-cache");
+  return join36(getStateDir(), "parse-cache");
 }
 function getParseCachePath(toolId) {
-  return join35(getParseCacheDir(), `${toolId}.json`);
+  return join36(getParseCacheDir(), `${toolId}.json`);
 }
 function computeScanFingerprint(files, now = Date.now()) {
   const hash = createHash7("sha256");
@@ -7367,7 +7881,7 @@ function computeScanFingerprint(files, now = Date.now()) {
   for (const file of [...files].sort()) {
     let stats;
     try {
-      stats = statSync6(file);
+      stats = statSync8(file);
     } catch {
       return null;
     }
@@ -7575,12 +8089,12 @@ function createProjectIdentityResolver(settings) {
     return identity;
   };
 }
-function toUploadBuckets(buckets, settings, device, resolveProject = createProjectIdentityResolver(
+function toUploadBuckets(buckets, settings, device, resolveProject2 = createProjectIdentityResolver(
   settings
 )) {
   const aggregated = /* @__PURE__ */ new Map();
   for (const bucket of buckets) {
-    const project = resolveProject(bucket.project);
+    const project = resolveProject2(bucket.project);
     const key = [
       bucket.source,
       bucket.model,
@@ -7616,11 +8130,11 @@ function toUploadBuckets(buckets, settings, device, resolveProject = createProje
   }
   return Array.from(aggregated.values());
 }
-function toUploadSessions(sessions, settings, device, resolveProject = createProjectIdentityResolver(
+function toUploadSessions(sessions, settings, device, resolveProject2 = createProjectIdentityResolver(
   settings
 )) {
   return sessions.map((session) => {
-    const project = resolveProject(session.project);
+    const project = resolveProject2(session.project);
     return {
       source: session.source,
       projectKey: project.projectKey,
@@ -7799,18 +8313,18 @@ async function runSync(config, opts = {}) {
       deviceId: device.deviceId,
       settings
     });
-    const resolveProject = createProjectIdentityResolver(settings);
+    const resolveProject2 = createProjectIdentityResolver(settings);
     const uploadBuckets = toUploadBuckets(
       allBuckets,
       settings,
       device,
-      resolveProject
+      resolveProject2
     );
     const uploadSessions = toUploadSessions(
       allSessions,
       settings,
       device,
-      resolveProject
+      resolveProject2
     );
     const previousManifest = loadUploadManifest();
     const uploadDiff = diffUploadManifest({
@@ -8032,8 +8546,8 @@ View your dashboard at: ${apiUrl}/usage`);
 import { execFileSync as execFileSync8, spawn } from "child_process";
 import { existsSync as existsSync36 } from "fs";
 import { appendFile, mkdir, readFile } from "fs/promises";
-import { homedir as homedir33, platform as platform5 } from "os";
-import { dirname as dirname8, join as join36, posix as posix3, win32 } from "path";
+import { homedir as homedir34, platform as platform5 } from "os";
+import { dirname as dirname9, join as join37, posix as posix3, win32 } from "path";
 
 // src/infrastructure/service/index.ts
 import { platform as platform4 } from "os";
@@ -8041,7 +8555,7 @@ import { platform as platform4 } from "os";
 // src/infrastructure/service/linux-systemd.ts
 import { execFileSync as execFileSync6 } from "child_process";
 import { existsSync as existsSync34, mkdirSync as mkdirSync4, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "fs";
-import { homedir as homedir31, platform as platform2 } from "os";
+import { homedir as homedir32, platform as platform2 } from "os";
 import { posix } from "path";
 
 // src/utils/command.ts
@@ -8122,10 +8636,10 @@ function escapeXml(value) {
 
 // src/infrastructure/service/linux-systemd.ts
 var SYSTEMD_SERVICE_NAME = "tokenarena";
-function getLinuxSystemdServiceDir(homePath = homedir31()) {
+function getLinuxSystemdServiceDir(homePath = homedir32()) {
   return posix.join(homePath, ".config", "systemd", "user");
 }
-function getLinuxSystemdServiceFile(homePath = homedir31()) {
+function getLinuxSystemdServiceFile(homePath = homedir32()) {
   return posix.join(
     getLinuxSystemdServiceDir(homePath),
     `${SYSTEMD_SERVICE_NAME}.service`
@@ -8369,16 +8883,16 @@ function createLinuxSystemdServiceBackend() {
 // src/infrastructure/service/macos-launchd.ts
 import { execFileSync as execFileSync7 } from "child_process";
 import { existsSync as existsSync35, mkdirSync as mkdirSync5, rmSync as rmSync5, writeFileSync as writeFileSync7 } from "fs";
-import { homedir as homedir32, platform as platform3 } from "os";
+import { homedir as homedir33, platform as platform3 } from "os";
 import { posix as posix2 } from "path";
 var MACOS_LAUNCHD_LABEL = "com.guji.tokenarena";
 function getCurrentUid() {
   return typeof process.getuid === "function" ? process.getuid() : null;
 }
-function getMacosLaunchAgentDir(homePath = homedir32()) {
+function getMacosLaunchAgentDir(homePath = homedir33()) {
   return posix2.join(homePath, "Library", "LaunchAgents");
 }
-function getMacosLaunchAgentFile(homePath = homedir32()) {
+function getMacosLaunchAgentFile(homePath = homedir33()) {
   return posix2.join(
     getMacosLaunchAgentDir(homePath),
     `${MACOS_LAUNCHD_LABEL}.plist`
@@ -8505,7 +9019,7 @@ function writeLaunchAgentPlist() {
     label: MACOS_LAUNCHD_LABEL,
     programArguments: [command.execPath, ...command.args],
     environment: getManagedServiceEnvironment(),
-    workingDirectory: homedir32(),
+    workingDirectory: homedir33(),
     standardOutPath: stdoutPath,
     standardErrorPath: stderrPath
   });
@@ -8782,7 +9296,7 @@ function resolvePowerShellProfilePath() {
   const systemRoot = process.env.SYSTEMROOT || "C:\\Windows";
   const candidates = [
     "pwsh.exe",
-    join36(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
+    join37(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
   ];
   for (const command of candidates) {
     try {
@@ -8811,7 +9325,7 @@ function resolvePowerShellProfilePath() {
 function resolveShellAliasSetup(options = {}) {
   const currentPlatform = options.currentPlatform ?? platform5();
   const env = options.env ?? process.env;
-  const homeDir = options.homeDir ?? homedir33();
+  const homeDir = options.homeDir ?? homedir34();
   const pathExists = options.exists ?? existsSync36;
   const shellFromEnv = env.SHELL ? basenameLikeShell(env.SHELL).toLowerCase() : "";
   const shellName = shellFromEnv || (currentPlatform === "win32" ? "powershell" : "");
@@ -9007,7 +9521,7 @@ async function setupShellAlias() {
     return;
   }
   try {
-    await mkdir(dirname8(setup.configFile), { recursive: true });
+    await mkdir(dirname9(setup.configFile), { recursive: true });
     let existingContent = "";
     if (existsSync36(setup.configFile)) {
       existingContent = await readFile(setup.configFile, "utf-8");
@@ -9171,16 +9685,16 @@ function buildToolSummary(input2) {
     models.add(bucket.model || "unknown");
   }
   for (const session of input2.sessions) {
-    const projectName = session.project || "unknown";
+    const projectName2 = session.project || "unknown";
     const modelName = session.primaryModel || "unknown";
-    projects.add(projectName);
+    projects.add(projectName2);
     models.add(modelName);
-    const project = projectTotals.get(projectName);
+    const project = projectTotals.get(projectName2);
     if (project) {
       project.sessions += 1;
     } else {
-      projectTotals.set(projectName, {
-        name: projectName,
+      projectTotals.set(projectName2, {
+        name: projectName2,
         inputTokens: 0,
         outputTokens: 0,
         cachedTokens: 0,
@@ -9671,7 +10185,7 @@ async function runSyncCommand(opts = {}) {
 
 // src/commands/uninstall.ts
 import { existsSync as existsSync37, readFileSync as readFileSync15, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "fs";
-import { homedir as homedir34, platform as platform6 } from "os";
+import { homedir as homedir35, platform as platform6 } from "os";
 function removeShellAlias() {
   const shell = process.env.SHELL;
   if (!shell) return;
@@ -9680,17 +10194,17 @@ function removeShellAlias() {
   let configFile;
   switch (shellName) {
     case "zsh":
-      configFile = `${homedir34()}/.zshrc`;
+      configFile = `${homedir35()}/.zshrc`;
       break;
     case "bash":
-      if (platform6() === "darwin" && existsSync37(`${homedir34()}/.bash_profile`)) {
-        configFile = `${homedir34()}/.bash_profile`;
+      if (platform6() === "darwin" && existsSync37(`${homedir35()}/.bash_profile`)) {
+        configFile = `${homedir35()}/.bash_profile`;
       } else {
-        configFile = `${homedir34()}/.bashrc`;
+        configFile = `${homedir35()}/.bashrc`;
       }
       break;
     case "fish":
-      configFile = `${homedir34()}/.config/fish/config.fish`;
+      configFile = `${homedir35()}/.config/fish/config.fish`;
       break;
     default:
       return;