@yishiguji/tokenarena 0.15.0 → 0.16.0

package/dist/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 // src/parsers/claude-code.ts
+import { createHash as createHash2 } from "crypto";
 import { existsSync as existsSync3, realpathSync } from "fs";
 import { homedir } from "os";
 import { join as join2, sep as sep2 } from "path";
@@ -16,6 +17,8 @@ var TOKEN_COUNT_KEYS = [
   "cachedTokens"
 ];
 function hasInvalidTokenCounts(entry) {
+  const cacheCreation = entry.cacheCreationTokens ?? 0;
+  if (!Number.isSafeInteger(cacheCreation) || cacheCreation < 0) return true;
   return TOKEN_COUNT_KEYS.some((key) => {
     const value = entry[key];
     return !Number.isSafeInteger(value) || value < 0;
@@ -48,6 +51,7 @@ function aggregateToBuckets(entries) {
         outputTokens: 0,
         reasoningTokens: 0,
         cachedTokens: 0,
+        cacheCreationTokens: 0,
         totalTokens: 0
       });
     }
@@ -57,7 +61,8 @@ function aggregateToBuckets(entries) {
     b.outputTokens += e.outputTokens || 0;
     b.reasoningTokens += e.reasoningTokens || 0;
     b.cachedTokens += e.cachedTokens || 0;
-    b.totalTokens += (e.inputTokens || 0) + (e.outputTokens || 0) + (e.reasoningTokens || 0) + (e.cachedTokens || 0);
+    b.cacheCreationTokens = (b.cacheCreationTokens ?? 0) + (e.cacheCreationTokens ?? 0);
+    b.totalTokens += (e.inputTokens || 0) + (e.outputTokens || 0) + (e.reasoningTokens || 0) + (e.cachedTokens || 0) + (e.cacheCreationTokens ?? 0);
   }
   return Array.from(map.values());
 }
@@ -66,7 +71,7 @@ function aggregateToBuckets(entries) {
 import { createHash } from "crypto";
 import { hostname as hostname2 } from "os";
 function toEntryTotalTokens(entry) {
-  return entry.inputTokens + entry.outputTokens + entry.reasoningTokens + entry.cachedTokens;
+  return entry.inputTokens + entry.outputTokens + entry.reasoningTokens + entry.cachedTokens + (entry.cacheCreationTokens ?? 0);
 }
 function buildSessionUsage(entries) {
   const usageBySession = /* @__PURE__ */ new Map();
@@ -88,6 +93,7 @@ function buildSessionUsage(entries) {
       existing.outputTokens += entry.outputTokens;
       existing.reasoningTokens += entry.reasoningTokens;
       existing.cachedTokens += entry.cachedTokens;
+      existing.cacheCreationTokens = (existing.cacheCreationTokens ?? 0) + (entry.cacheCreationTokens ?? 0);
       existing.totalTokens += toEntryTotalTokens(entry);
       continue;
     }
@@ -97,6 +103,7 @@ function buildSessionUsage(entries) {
       outputTokens: entry.outputTokens,
       reasoningTokens: entry.reasoningTokens,
       cachedTokens: entry.cachedTokens,
+      cacheCreationTokens: entry.cacheCreationTokens ?? 0,
       totalTokens: toEntryTotalTokens(entry)
     });
   }
@@ -177,6 +184,10 @@ function extractSessions(events, entries = []) {
       (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
@@ -199,6 +210,7 @@ function extractSessions(events, entries = []) {
       outputTokens,
       reasoningTokens,
       cachedTokens,
+      cacheCreationTokens,
       totalTokens,
       primaryModel,
       modelUsages
@@ -330,109 +342,164 @@ function extractProject(filePath, projectsDir) {
   const parts = firstSegment.split("-").filter(Boolean);
   return parts.length > 0 ? parts[parts.length - 1] : "unknown";
 }
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function getIdentifier(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function tokenCount(value) {
+  if (value == null) return 0;
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : Number.NaN;
+}
+function selectSnapshot(current, candidate) {
+  if (!current) return candidate;
+  const replace = candidate.completed !== current.completed ? candidate.completed : candidate.entry.outputTokens !== current.entry.outputTokens ? candidate.entry.outputTokens > current.entry.outputTokens : candidate.entry.timestamp > current.entry.timestamp;
+  const selected = replace ? candidate : current;
+  const owner = current.order < candidate.order ? current : candidate;
+  return {
+    ...selected,
+    order: owner.order,
+    entry: {
+      ...selected.entry,
+      sessionId: owner.entry.sessionId,
+      project: owner.entry.project
+    }
+  };
+}
 var ClaudeCodeParser = class {
   tool = TOOL;
   async parse() {
-    const entries = [];
-    const sessionEvents = [];
-    const seenUuids = /* @__PURE__ */ new Set();
-    const seenSessionIds = /* @__PURE__ */ new Set();
-    const seenProjectFiles = /* @__PURE__ */ new Set();
-    const roots = getClaudeRoots();
-    for (const root of roots) {
-      const projectsDir = join2(root, "projects");
-      const projectFiles = findJsonlFiles(projectsDir);
-      for (const filePath of projectFiles) {
-        const relative = projectRelativePath(filePath, projectsDir);
-        if (relative !== null) {
-          if (seenProjectFiles.has(relative)) continue;
-          seenProjectFiles.add(relative);
-        }
-        const content = readFileSafe(filePath);
-        if (!content) continue;
-        const project = extractProject(filePath, projectsDir);
-        const sessionId = extractSessionId(filePath);
-        seenSessionIds.add(sessionId);
-        for (const line of content.split("\n")) {
-          if (!line.trim()) continue;
-          try {
-            const obj = JSON.parse(line);
-            const timestamp = obj.timestamp;
-            if (!timestamp) continue;
-            const parsedTimestamp = new Date(timestamp);
-            if (Number.isNaN(parsedTimestamp.getTime())) continue;
-            if (obj.type === "user" || obj.type === "assistant" || obj.type === "tool_use" || obj.type === "tool_result") {
-              sessionEvents.push({
-                sessionId,
-                source: "claude-code",
-                project,
-                timestamp: parsedTimestamp,
-                role: obj.type === "user" ? "user" : "assistant"
-              });
-            }
-            if (obj.type !== "assistant") continue;
-            const message = obj.message;
-            if (!message?.usage) continue;
-            const usage = message.usage;
-            if (usage.input_tokens == null && usage.output_tokens == null) {
-              continue;
-            }
-            const uuid = obj.uuid;
-            if (uuid) {
-              if (seenUuids.has(uuid)) continue;
-              seenUuids.add(uuid);
-            }
-            entries.push({
+    const snapshots = /* @__PURE__ */ new Map();
+    const sessionEvents = /* @__PURE__ */ new Map();
+    const projectSessionIds = /* @__PURE__ */ new Set();
+    let snapshotOrder = 0;
+    const scanFile = (filePath, fileIdentity, project, includeUsage) => {
+      const content = readFileSafe(filePath);
+      if (!content) return;
+      const sessionId = extractSessionId(filePath);
+      if (includeUsage) projectSessionIds.add(sessionId);
+      for (const [lineIndex, line] of content.split("\n").entries()) {
+        if (!line.trim()) continue;
+        try {
+          const record = asRecord(JSON.parse(line));
+          if (!record || typeof record.timestamp !== "string" && typeof record.timestamp !== "number") {
+            continue;
+          }
+          const timestamp = new Date(record.timestamp);
+          if (Number.isNaN(timestamp.getTime())) continue;
+          const message = asRecord(record.message);
+          const messageId = getIdentifier(message?.id);
+          const requestId = getIdentifier(record.requestId) ?? getIdentifier(record.request_id) ?? "";
+          const uuid = getIdentifier(record.uuid);
+          const anonymousId = uuid || messageId ? "" : createHash2("sha256").update(JSON.stringify([fileIdentity, lineIndex, line])).digest("hex");
+          const eventKey = uuid ? JSON.stringify(["uuid", uuid]) : messageId ? JSON.stringify([
+            "message",
+            messageId,
+            requestId,
+            record.type,
+            record.timestamp
+          ]) : JSON.stringify(["anonymous", anonymousId]);
+          if (!sessionEvents.has(eventKey) && (record.type === "user" || record.type === "assistant" || record.type === "tool_use" || record.type === "tool_result")) {
+            sessionEvents.set(eventKey, {
               sessionId,
               source: "claude-code",
-              model: message.model || "unknown",
               project,
-              timestamp: parsedTimestamp,
-              inputTokens: usage.input_tokens || 0,
-              outputTokens: usage.output_tokens || 0,
-              reasoningTokens: 0,
-              cachedTokens: usage.cache_read_input_tokens || 0
+              timestamp,
+              role: record.type === "user" ? "user" : "assistant"
             });
-          } catch {
           }
+          if (!includeUsage || record.type !== "assistant" || !message)
+            continue;
+          const usage = asRecord(message.usage);
+          if (!usage) continue;
+          const cacheCreation = asRecord(usage.cache_creation);
+          const cacheCreationTokens = tokenCount(
+            usage.cache_creation_input_tokens ?? tokenCount(cacheCreation?.ephemeral_5m_input_tokens) + tokenCount(cacheCreation?.ephemeral_1h_input_tokens)
+          );
+          const event = sessionEvents.get(eventKey);
+          const entry = {
+            sessionId: event?.sessionId ?? sessionId,
+            source: "claude-code",
+            model: getIdentifier(message.model) ?? "unknown",
+            project: event?.project ?? project,
+            timestamp,
+            inputTokens: tokenCount(usage.input_tokens),
+            outputTokens: tokenCount(usage.output_tokens),
+            reasoningTokens: 0,
+            cachedTokens: tokenCount(usage.cache_read_input_tokens),
+            cacheCreationTokens
+          };
+          if (hasInvalidTokenCounts(entry) || entry.inputTokens + entry.outputTokens + entry.cachedTokens + cacheCreationTokens === 0) {
+            continue;
+          }
+          const messageKey = messageId ? JSON.stringify(["message", messageId]) : uuid ? JSON.stringify(["uuid", uuid]) : JSON.stringify(["anonymous", anonymousId]);
+          let requests = snapshots.get(messageKey);
+          if (!requests) {
+            requests = /* @__PURE__ */ new Map();
+            snapshots.set(messageKey, requests);
+          }
+          requests.set(
+            requestId,
+            selectSnapshot(requests.get(requestId), {
+              entry,
+              completed: getIdentifier(message.stop_reason) !== null,
+              order: snapshotOrder++
+            })
+          );
+        } catch {
         }
       }
+    };
+    const roots = getClaudeRoots();
+    for (const root of roots) {
+      const projectsDir = join2(root, "projects");
+      for (const filePath of findJsonlFiles(projectsDir)) {
+        scanFile(
+          filePath,
+          join2(
+            "projects",
+            projectRelativePath(filePath, projectsDir) ?? filePath
+          ),
+          extractProject(filePath, projectsDir),
+          true
+        );
+      }
     }
     for (const root of roots) {
-      for (const transcriptsDir of ["transcripts", "sessions"]) {
-        const transcriptFiles = findJsonlFiles(join2(root, transcriptsDir));
-        for (const filePath of transcriptFiles) {
-          const sessionId = extractSessionId(filePath);
-          if (seenSessionIds.has(sessionId)) continue;
-          seenSessionIds.add(sessionId);
-          const content = readFileSafe(filePath);
-          if (!content) continue;
-          for (const line of content.split("\n")) {
-            if (!line.trim()) continue;
-            try {
-              const obj = JSON.parse(line);
-              const timestamp = obj.timestamp;
-              if (!timestamp) continue;
-              const parsedTimestamp = new Date(timestamp);
-              if (Number.isNaN(parsedTimestamp.getTime())) continue;
-              if (obj.type === "user" || obj.type === "assistant" || obj.type === "tool_use" || obj.type === "tool_result") {
-                sessionEvents.push({
-                  sessionId,
-                  source: "claude-code",
-                  project: "unknown",
-                  timestamp: parsedTimestamp,
-                  role: obj.type === "user" ? "user" : "assistant"
-                });
-              }
-            } catch {
-            }
-          }
+      for (const directory of ["transcripts", "sessions"]) {
+        const transcriptDir = join2(root, directory);
+        for (const filePath of findJsonlFiles(transcriptDir)) {
+          if (projectSessionIds.has(extractSessionId(filePath))) continue;
+          scanFile(
+            filePath,
+            join2(
+              directory,
+              projectRelativePath(filePath, transcriptDir) ?? filePath
+            ),
+            "unknown",
+            false
+          );
         }
       }
     }
+    const entries = [];
+    for (const requests of snapshots.values()) {
+      const unidentified = requests.get("");
+      if (unidentified && requests.size === 2) {
+        const identified = Array.from(requests.entries()).find(([id]) => id);
+        if (identified) {
+          entries.push(selectSnapshot(unidentified, identified[1]).entry);
+          continue;
+        }
+      }
+      entries.push(
+        ...Array.from(requests.values(), (snapshot) => snapshot.entry)
+      );
+    }
     return {
       buckets: aggregateToBuckets(entries),
-      sessions: extractSessions(sessionEvents, entries)
+      sessions: extractSessions(Array.from(sessionEvents.values()), entries)
     };
   }
   isInstalled() {
@@ -445,216 +512,376 @@ var ClaudeCodeParser = class {
 registerParser(new ClaudeCodeParser());
 
 // src/parsers/codex.ts
+import { existsSync as existsSync4 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
+import { basename as basename2, join as join3 } from "path";
+
+// src/utils/logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var Logger = class {
+  level;
+  constructor(level = "info") {
+    this.level = level;
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  debug(msg) {
+    if (LOG_LEVELS[this.level] <= LOG_LEVELS.debug) {
+      process.stderr.write(`[debug] ${msg}
+`);
+    }
+  }
+  info(msg) {
+    if (LOG_LEVELS[this.level] <= LOG_LEVELS.info) {
+      process.stdout.write(`${msg}
+`);
+    }
+  }
+  warn(msg) {
+    if (LOG_LEVELS[this.level] <= LOG_LEVELS.warn) {
+      process.stderr.write(`warn: ${msg}
+`);
+    }
+  }
+  error(msg) {
+    if (LOG_LEVELS[this.level] <= LOG_LEVELS.error) {
+      process.stderr.write(`error: ${msg}
+`);
+    }
+  }
+  log(msg) {
+    this.info(msg);
+  }
+};
+var logger = new Logger();
+
+// src/parsers/codex.ts
 var TOOL_ID = "codex";
-var TOOL_NAME = "Codex CLI";
 var DEFAULT_DATA_DIR = join3(homedir2(), ".codex", "sessions");
-function createToolDefinition(dataDir) {
+var DEFAULT_ARCHIVE_DIR = join3(homedir2(), ".codex", "archived_sessions");
+function safeCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+function readUsage(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const fields = value;
+  const names = [
+    "input_tokens",
+    "output_tokens",
+    "cached_input_tokens",
+    "cache_read_input_tokens",
+    "reasoning_output_tokens",
+    "total_tokens"
+  ];
+  if (!names.some((name) => Object.hasOwn(fields, name))) return null;
   return {
-    id: TOOL_ID,
-    name: TOOL_NAME,
-    dataDir
+    input: safeCount(fields.input_tokens),
+    output: safeCount(fields.output_tokens),
+    cached: safeCount(
+      fields.cached_input_tokens ?? fields.cache_read_input_tokens
+    ),
+    reasoning: safeCount(fields.reasoning_output_tokens),
+    reportedTotal: typeof fields.total_tokens === "number" ? safeCount(fields.total_tokens) : null
   };
 }
-function toSafeNumber(value) {
-  const numberValue = Number(value);
-  return Number.isFinite(numberValue) ? numberValue : 0;
+function readTimestamp(value) {
+  if (typeof value !== "string") return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date;
 }
-function toNonNegativeDelta(current, previous) {
-  return Math.max(0, toSafeNumber(current) - toSafeNumber(previous));
+function timestampOrder(value, timestamp) {
+  if (!timestamp) return null;
+  const fraction = typeof value === "string" ? value.match(/\.(\d+)(?:z|[+-]\d{2}:?\d{2})?$/i)?.[1] ?? "" : "";
+  const remainder = fraction.slice(3, 9).padEnd(6, "0");
+  return BigInt(timestamp.getTime()) * 1000000n + BigInt(remainder);
 }
-function getPathLeaf(value) {
-  const normalized = value.replace(/\\/g, "/").replace(/\/+$/, "");
-  const leaf = normalized.split("/").filter(Boolean).pop();
-  return leaf || "unknown";
+function readId(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function filenameThreadId(path) {
+  return basename2(path).match(
+    /([\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12})\.jsonl$/i
+  )?.[1] ?? null;
 }
 function resolveCodexProject(payload) {
-  if (!payload) {
-    return "unknown";
-  }
-  const repositoryUrl = payload.git?.repository_url;
-  if (repositoryUrl) {
+  const repositoryUrl = payload?.git?.repository_url;
+  if (typeof repositoryUrl === "string" && repositoryUrl) {
     const match = repositoryUrl.match(/([^/]+\/[^/]+?)(?:\.git)?$/);
-    if (match) {
-      return match[1];
-    }
+    if (match) return match[1];
   }
-  if (payload.cwd) {
-    return getPathLeaf(payload.cwd);
+  const normalized = typeof payload?.cwd === "string" ? payload.cwd.replace(/\\/g, "/").replace(/\/+$/, "") : "";
+  return normalized?.split("/").filter(Boolean).pop() || "unknown";
+}
+function readRollout(path) {
+  const content = readFileSafe(path);
+  if (!content) return null;
+  const tokens = [];
+  const prompts = [];
+  let rootMeta = null;
+  let model = "unknown";
+  let latestTimestampOrder = 0n;
+  let line = 0;
+  for (const text of content.split("\n")) {
+    line++;
+    if (!text.trim()) continue;
+    try {
+      const event = JSON.parse(text);
+      const timestamp = readTimestamp(event.timestamp);
+      const order = timestampOrder(event.timestamp, timestamp);
+      if (order !== null && order > latestTimestampOrder)
+        latestTimestampOrder = order;
+      if (event.type === "session_meta" && !rootMeta) rootMeta = event;
+      if (event.type === "turn_context") {
+        model = readId(event.payload?.model) || readId(event.payload?.info?.model) || model;
+        if (timestamp && order !== null)
+          prompts.push({ line, timestamp, timestampOrder: order });
+      }
+      if (event.type !== "event_msg" || event.payload?.type !== "token_count")
+        continue;
+      const info = event.payload.info;
+      if (!info) continue;
+      const total = readUsage(info.total_token_usage);
+      const last = readUsage(info.last_token_usage);
+      if (!total && !last) continue;
+      model = readId(info.model) || readId(info.model_name) || readId(event.payload.model) || model;
+      tokens.push({
+        line,
+        timestamp,
+        timestampOrder: order,
+        model,
+        total,
+        last,
+        signature: JSON.stringify([total, last]),
+        snapshotSource: readId(event.payload.rate_limits?.limit_id) || ""
+      });
+    } catch {
+    }
   }
-  return "unknown";
+  const meta = rootMeta?.payload;
+  const threadId = readId(meta?.id) || readId(meta?.thread_id) || readId(meta?.threadId);
+  const forkedFrom = readId(meta?.forked_from_id);
+  const spawnedFrom = readId(
+    meta?.source?.subagent?.thread_spawn?.parent_thread_id
+  );
+  return {
+    path,
+    threadId,
+    sessionId: threadId ? `codex:${threadId}` : `codex-file:${path}`,
+    project: resolveCodexProject(meta),
+    parentId: forkedFrom || spawnedFrom,
+    parentConflict: Boolean(
+      forkedFrom && spawnedFrom && forkedFrom !== spawnedFrom
+    ),
+    rootTimestampOrder: timestampOrder(
+      rootMeta?.timestamp,
+      readTimestamp(rootMeta?.timestamp)
+    ),
+    latestTimestampOrder,
+    tokens,
+    prompts
+  };
+}
+function matchingReplayPrefix(tokens, history) {
+  let offset = 0;
+  let matched = 0;
+  for (const token of tokens) {
+    while (offset < history.length && (history[offset].signature !== token.signature || // 缺少累计值时，相同用量不能证明回放；还必须对应同一时刻和模型。
+    !token.total && (token.timestampOrder === null || token.timestampOrder !== history[offset].timestampOrder || token.model !== history[offset].model)))
+      offset++;
+    if (offset === history.length) break;
+    offset++;
+    matched++;
+  }
+  return matched;
+}
+function usageDelta(current, previous) {
+  return {
+    input: Math.max(0, current.input - (previous?.input ?? 0)),
+    output: Math.max(0, current.output - (previous?.output ?? 0)),
+    cached: Math.max(0, current.cached - (previous?.cached ?? 0)),
+    reasoning: Math.max(0, current.reasoning - (previous?.reasoning ?? 0)),
+    reportedTotal: null
+  };
+}
+function highWater(previous, current) {
+  return {
+    input: Math.max(previous?.input ?? 0, current.input),
+    output: Math.max(previous?.output ?? 0, current.output),
+    cached: Math.max(previous?.cached ?? 0, current.cached),
+    reasoning: Math.max(previous?.reasoning ?? 0, current.reasoning),
+    reportedTotal: null
+  };
 }
 var CodexParser = class {
-  constructor(dataDir = DEFAULT_DATA_DIR) {
-    this.dataDir = dataDir;
-    this.tool = createToolDefinition(dataDir);
-  }
-  dataDir;
   tool;
+  dataDirs;
+  constructor(dataDir = DEFAULT_DATA_DIR, archiveDir = dataDir === DEFAULT_DATA_DIR ? DEFAULT_ARCHIVE_DIR : void 0) {
+    this.dataDirs = archiveDir ? [dataDir, archiveDir] : [dataDir];
+    this.tool = { id: TOOL_ID, name: "Codex CLI", dataDir };
+  }
+  isInstalled() {
+    return this.dataDirs.some((directory) => existsSync4(directory));
+  }
   async parse() {
     const entries = [];
     const sessionEvents = [];
-    const files = findJsonlFiles(this.dataDir);
-    if (files.length === 0) {
-      return { buckets: [], sessions: [] };
-    }
-    const seenTotalStates = /* @__PURE__ */ new Set();
-    const seenLastOnly = /* @__PURE__ */ new Set();
-    for (const filePath of files) {
-      const content = readFileSafe(filePath);
-      if (!content) continue;
-      let sessionProject = "unknown";
-      const sessionModel = "unknown";
-      for (const line of content.split("\n")) {
-        if (!line.trim()) continue;
-        try {
-          const obj = JSON.parse(line);
-          if (obj.type === "session_meta") {
-            sessionProject = resolveCodexProject(obj.payload);
-            break;
-          }
-        } catch {
-          break;
-        }
-      }
-      let turnContextModel = "unknown";
-      const prevTotal = /* @__PURE__ */ new Map();
-      for (const line of content.split("\n")) {
-        if (!line.trim()) continue;
-        try {
-          const obj = JSON.parse(line);
-          if (obj.type === "turn_context" && obj.timestamp) {
-            const eventTimestamp = new Date(obj.timestamp);
-            if (!Number.isNaN(eventTimestamp.getTime())) {
-              sessionEvents.push({
-                sessionId: filePath,
-                source: TOOL_ID,
-                project: sessionProject,
-                timestamp: eventTimestamp,
-                role: "user"
-              });
-            }
-          }
-          if (obj.type === "turn_context" && obj.payload?.model) {
-            turnContextModel = obj.payload.model;
-            continue;
-          }
-          if (obj.type !== "event_msg") continue;
-          const payload = obj.payload;
-          if (!payload || payload.type !== "token_count") continue;
-          const info = payload.info;
-          if (!info) continue;
-          const timestamp = obj.timestamp ? new Date(obj.timestamp) : null;
-          if (!timestamp || Number.isNaN(timestamp.getTime())) continue;
-          const model = info.model || payload.model || turnContextModel || sessionModel;
-          let isDuplicate = false;
-          if (info.total_token_usage) {
-            const curr = info.total_token_usage;
-            const stateKey = `${model}|${toSafeNumber(curr.input_tokens)}|${toSafeNumber(curr.output_tokens)}|${toSafeNumber(curr.cached_input_tokens)}|${toSafeNumber(curr.reasoning_output_tokens)}`;
-            isDuplicate = seenTotalStates.has(stateKey);
-            if (!isDuplicate) seenTotalStates.add(stateKey);
-          } else if (info.last_token_usage) {
-            const u = info.last_token_usage;
-            const lastKey = `${obj.timestamp}|${toSafeNumber(u.input_tokens)}|${toSafeNumber(u.output_tokens)}|${toSafeNumber(u.cached_input_tokens)}|${toSafeNumber(u.reasoning_output_tokens)}`;
-            isDuplicate = seenLastOnly.has(lastKey);
-            if (!isDuplicate) seenLastOnly.add(lastKey);
-          }
-          if (!isDuplicate) {
-            sessionEvents.push({
-              sessionId: filePath,
-              source: TOOL_ID,
-              project: sessionProject,
-              timestamp,
-              role: "assistant"
-            });
-          }
-          let usage = info.last_token_usage;
-          if (!usage && info.total_token_usage) {
-            const totalKey = `${info.model || payload.model || turnContextModel || ""}`;
-            const prev = prevTotal.get(totalKey);
-            const curr = info.total_token_usage;
-            if (prev) {
-              usage = {
-                input_tokens: toNonNegativeDelta(
-                  curr.input_tokens,
-                  prev.input_tokens
-                ),
-                output_tokens: toNonNegativeDelta(
-                  curr.output_tokens,
-                  prev.output_tokens
-                ),
-                cached_input_tokens: toNonNegativeDelta(
-                  curr.cached_input_tokens,
-                  prev.cached_input_tokens
-                ),
-                reasoning_output_tokens: toNonNegativeDelta(
-                  curr.reasoning_output_tokens,
-                  prev.reasoning_output_tokens
-                )
-              };
-            } else {
-              usage = curr;
-            }
-            prevTotal.set(totalKey, { ...curr });
+    const threads = /* @__PURE__ */ new Map();
+    const threadIndex = /* @__PURE__ */ new Map();
+    const files = [...new Set(this.dataDirs.flatMap(findJsonlFiles))].sort();
+    for (const path of files) {
+      const file = readRollout(path);
+      if (!file) continue;
+      let thread = threads.get(file.sessionId);
+      if (!thread) {
+        thread = {
+          files: [],
+          timeline: [],
+          latestTimestampOrder: 0n,
+          invalidTokenTimestamp: false,
+          status: "new"
+        };
+        threads.set(file.sessionId, thread);
+      }
+      thread.files.push(file);
+      if (file.latestTimestampOrder > thread.latestTimestampOrder)
+        thread.latestTimestampOrder = file.latestTimestampOrder;
+      thread.invalidTokenTimestamp ||= file.tokens.some(
+        (token) => !token.timestamp
+      );
+      if (file.threadId) threadIndex.set(file.threadId, thread);
+      const rolloutId = filenameThreadId(path);
+      if (rolloutId) threadIndex.set(rolloutId, thread);
+    }
+    const processThread = (thread) => {
+      if (thread.status !== "new") return thread.status === "done";
+      thread.status = "visiting";
+      const threadEntries = [];
+      const threadEvents = [];
+      let cumulative = null;
+      const eventKeys = /* @__PURE__ */ new Set();
+      thread.files.sort((left, right) => {
+        const firstTime = (file) => file.tokens.find((token) => token.timestampOrder !== null)?.timestampOrder ?? file.rootTimestampOrder ?? 0n;
+        const leftTime = firstTime(left);
+        const rightTime = firstTime(right);
+        return leftTime < rightTime ? -1 : leftTime > rightTime ? 1 : left.path.localeCompare(right.path);
+      });
+      for (const file of thread.files) {
+        let parentPrefix = 0;
+        if (file.parentConflict || file.parentId) {
+          const parent = file.parentId ? threadIndex.get(file.parentId) : void 0;
+          const cutoff = file.rootTimestampOrder;
+          if (file.parentConflict || !parent || parent === thread || cutoff === null || !processThread(parent) || parent.invalidTokenTimestamp || parent.latestTimestampOrder < cutoff) {
+            logger.warn(
+              "Codex fork replay could not be verified; skipping " + basename2(file.path)
+            );
+            thread.status = "deferred";
+            return false;
           }
-          if (!usage) continue;
-          if (isDuplicate) continue;
-          const cachedInput = toSafeNumber(usage.cached_input_tokens);
-          const reasoningTokens = toSafeNumber(usage.reasoning_output_tokens);
-          const inputTokens = Math.max(
-            0,
-            toSafeNumber(usage.input_tokens) - cachedInput
-          );
-          const outputTokens = Math.max(
-            0,
-            toSafeNumber(usage.output_tokens) - reasoningTokens
+          parentPrefix = matchingReplayPrefix(
+            file.tokens,
+            parent.timeline.filter(
+              (token) => token.timestampOrder !== null && token.timestampOrder <= cutoff
+            )
           );
-          if (inputTokens === 0 && outputTokens === 0 && reasoningTokens === 0 && cachedInput === 0) {
-            continue;
-          }
-          entries.push({
-            sessionId: filePath,
+        }
+        const ownPrefix = matchingReplayPrefix(file.tokens, thread.timeline);
+        const replayPrefix = Math.max(parentPrefix, ownPrefix);
+        const replayEndLine = file.tokens[replayPrefix - 1]?.line ?? -1;
+        const snapshots = /* @__PURE__ */ new Map();
+        const lastOnlyEvents = /* @__PURE__ */ new Set();
+        let previousSignature = null;
+        const addEvent = (timestamp, order, role) => {
+          const key = `${role}|${order.toString()}`;
+          if (eventKeys.has(key)) return;
+          eventKeys.add(key);
+          threadEvents.push({
+            sessionId: file.sessionId,
             source: TOOL_ID,
-            model,
-            project: sessionProject,
+            project: file.project,
             timestamp,
-            inputTokens,
-            outputTokens,
+            role
+          });
+        };
+        for (const prompt of file.prompts) {
+          if (prompt.line > replayEndLine)
+            addEvent(prompt.timestamp, prompt.timestampOrder, "user");
+        }
+        for (const [index, token] of file.tokens.entries()) {
+          if (!token.timestamp || token.timestampOrder === null) continue;
+          const duplicate = token.total ? snapshots.get(token.snapshotSource) === token.signature || previousSignature === token.signature : lastOnlyEvents.has(
+            token.model + "|" + token.timestampOrder.toString() + "|" + token.signature
+          );
+          if (token.total) snapshots.set(token.snapshotSource, token.signature);
+          else
+            lastOnlyEvents.add(
+              token.model + "|" + token.timestampOrder.toString() + "|" + token.signature
+            );
+          previousSignature = token.signature;
+          const usage = token.last ?? (token.total ? usageDelta(token.total, cumulative) : null);
+          if (token.total) cumulative = highWater(cumulative, token.total);
+          if (!usage || duplicate || index < replayPrefix) continue;
+          addEvent(token.timestamp, token.timestampOrder, "assistant");
+          const cachedTokens = Math.min(usage.cached, usage.input);
+          const reasoningTokens = Math.min(usage.reasoning, usage.output);
+          if (usage.input === 0 && usage.output === 0) continue;
+          threadEntries.push({
+            sessionId: file.sessionId,
+            source: TOOL_ID,
+            model: token.model,
+            project: file.project,
+            timestamp: token.timestamp,
+            inputTokens: usage.input - cachedTokens,
+            outputTokens: usage.output - reasoningTokens,
             reasoningTokens,
-            cachedTokens: cachedInput
+            cachedTokens
           });
-        } catch {
         }
+        for (let index = ownPrefix; index < file.tokens.length; index++)
+          thread.timeline.push(file.tokens[index]);
       }
+      for (const entry of threadEntries) entries.push(entry);
+      for (const event of threadEvents) sessionEvents.push(event);
+      thread.status = "done";
+      return true;
+    };
+    let incomplete = false;
+    for (const thread of threads.values()) {
+      if (!processThread(thread)) incomplete = true;
     }
     return {
       buckets: aggregateToBuckets(entries),
-      sessions: extractSessions(sessionEvents, entries)
+      sessions: extractSessions(sessionEvents, entries),
+      ...incomplete ? { incomplete: true } : {}
     };
   }
 };
 registerParser(new CodexParser());
 
 // src/parsers/gsd.ts
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join4 } from "path";
 var TOOL_ID2 = "gsd";
-var TOOL_NAME2 = "GSD-2";
+var TOOL_NAME = "GSD-2";
 var DEFAULT_SESSIONS_DIR = join4(homedir3(), ".gsd", "sessions");
-function createToolDefinition2(dataDir) {
+function createToolDefinition(dataDir) {
   return {
     id: TOOL_ID2,
-    name: TOOL_NAME2,
+    name: TOOL_NAME,
     dataDir
   };
 }
-function toSafeNumber2(value) {
+function toSafeNumber(value) {
   const numberValue = Number(value);
   return Number.isFinite(numberValue) ? numberValue : 0;
 }
-function getPathLeaf2(value) {
+function getPathLeaf(value) {
   const normalized = value.replace(/\\/g, "/").replace(/\/+$/, "");
   const leaf = normalized.split("/").filter(Boolean).pop();
   return leaf || "unknown";
@@ -665,7 +892,7 @@ function normalizeForPrefix(value) {
 function getUsageNumber(usage, ...keys) {
   for (const key of keys) {
     const value = usage[key];
-    const numberValue = toSafeNumber2(value);
+    const numberValue = toSafeNumber(value);
     if (numberValue > 0) {
       return numberValue;
     }
@@ -673,7 +900,7 @@ function getUsageNumber(usage, ...keys) {
   return 0;
 }
 function extractGsdProjectFromCwd(cwd) {
-  return getPathLeaf2(cwd);
+  return getPathLeaf(cwd);
 }
 function extractGsdProjectFromDir(filePath, sessionsDir = DEFAULT_SESSIONS_DIR) {
   const normalizedFilePath = normalizeForPrefix(filePath);
@@ -690,7 +917,7 @@ function extractGsdProjectFromDir(filePath, sessionsDir = DEFAULT_SESSIONS_DIR)
   try {
     const decoded = decodeURIComponent(firstSegment);
     if (decoded.includes("/") || decoded.includes("\\")) {
-      return getPathLeaf2(decoded);
+      return getPathLeaf(decoded);
     }
   } catch {
   }
@@ -700,7 +927,7 @@ function extractGsdProjectFromDir(filePath, sessionsDir = DEFAULT_SESSIONS_DIR)
 var GsdParser = class {
   constructor(sessionsDir = DEFAULT_SESSIONS_DIR) {
     this.sessionsDir = sessionsDir;
-    this.tool = createToolDefinition2(sessionsDir);
+    this.tool = createToolDefinition(sessionsDir);
   }
   sessionsDir;
   tool;
@@ -789,15 +1016,15 @@ var GsdParser = class {
     };
   }
   isInstalled() {
-    return existsSync4(this.sessionsDir);
+    return existsSync5(this.sessionsDir);
   }
 };
 registerParser(new GsdParser());
 
 // src/parsers/gemini-cli.ts
-import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync2 } from "fs";
 import { homedir as homedir4 } from "os";
-import { basename as basename2, join as join5 } from "path";
+import { basename as basename3, join as join5 } from "path";
 var TOOL2 = {
   id: "gemini-cli",
   name: "Gemini CLI",
@@ -805,7 +1032,7 @@ var TOOL2 = {
 };
 function findSessionFiles(baseDir) {
   const results = [];
-  if (!existsSync5(baseDir)) return results;
+  if (!existsSync6(baseDir)) return results;
   let projectDirs;
   try {
     projectDirs = readdirSync2(baseDir, { withFileTypes: true });
@@ -847,6 +1074,7 @@ function readRecord(filePath) {
     let directories = null;
     let model = null;
     let createTime = null;
+    let sessionId = null;
     for (const line of raw.split("\n")) {
       const trimmed = line.trim();
       if (!trimmed) continue;
@@ -856,6 +1084,8 @@ function readRecord(filePath) {
       } catch {
         continue;
       }
+      if (!obj || typeof obj !== "object" || Array.isArray(obj)) continue;
+      if (typeof obj.sessionId === "string") sessionId = obj.sessionId;
       if (!directories && Array.isArray(obj.directories)) {
         directories = obj.directories;
         if (typeof obj.model === "string") model = obj.model;
@@ -866,7 +1096,7 @@ function readRecord(filePath) {
         messages.push(obj);
       }
     }
-    return { messages, directories, model, createTime };
+    return { messages, directories, model, createTime, sessionId };
   }
   let data;
   try {
@@ -875,6 +1105,7 @@ function readRecord(filePath) {
     return null;
   }
   return {
+    sessionId: typeof data?.sessionId === "string" ? data.sessionId : null,
     messages: Array.isArray(data?.messages) ? data.messages : Array.isArray(data?.history) ? data.history : [],
     directories: Array.isArray(data?.directories) ? data.directories : null,
     model: typeof data?.model === "string" ? data.model : null,
@@ -891,7 +1122,23 @@ function projectFromDirectories(directories) {
   if (!directories || directories.length === 0) return "unknown";
   const first = directories[0];
   if (!first) return "unknown";
-  return basename2(String(first).replace(/[\\/]+$/, "")) || "unknown";
+  return basename3(String(first).replace(/[\\/]+$/, "")) || "unknown";
+}
+function tokenCount2(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.trunc(value) : 0;
+}
+function selectUsageSnapshot(current, candidate) {
+  if (!current) return candidate;
+  const total = (entry) => entry.inputTokens + entry.outputTokens + entry.reasoningTokens + entry.cachedTokens;
+  const currentTotal = total(current);
+  const candidateTotal = total(candidate);
+  if (candidateTotal === 0 && currentTotal > 0) return current;
+  if (candidate.timestamp.getTime() !== current.timestamp.getTime()) {
+    return candidate.timestamp > current.timestamp ? candidate : current;
+  }
+  if (candidateTotal !== currentTotal)
+    return candidateTotal > currentTotal ? candidate : current;
+  return current.model === "unknown" && candidate.model !== "unknown" ? candidate : current;
 }
 var GeminiCliParser = class {
   tool = TOOL2;
@@ -900,54 +1147,73 @@ var GeminiCliParser = class {
     if (sessionFiles.length === 0) {
       return { buckets: [], sessions: [] };
     }
-    const entries = [];
-    const sessionEvents = [];
+    const entries = /* @__PURE__ */ new Map();
+    const sessionEvents = /* @__PURE__ */ new Map();
+    const storeEntry = (key, entry) => {
+      entries.set(key, selectUsageSnapshot(entries.get(key), entry));
+    };
     for (const filePath of sessionFiles) {
       const record = readRecord(filePath);
       if (!record) continue;
       const project = projectFromDirectories(record.directories);
-      for (const msg of record.messages) {
+      const sessionId = record.sessionId || filePath;
+      for (const [index, msg] of record.messages.entries()) {
+        if (!msg || typeof msg !== "object") continue;
         const role = classifyRole(msg);
         if (!role) continue;
         const timestamp = msg.timestamp || msg.createTime || record.createTime;
         if (!timestamp) continue;
         const ts = new Date(timestamp);
         if (Number.isNaN(ts.getTime())) continue;
-        sessionEvents.push({
-          sessionId: filePath,
-          source: "gemini-cli",
-          project,
-          timestamp: ts,
-          role
-        });
+        const key = JSON.stringify([
+          sessionId,
+          msg.id || `${filePath}:${index}`
+        ]);
+        if ((sessionEvents.get(key)?.timestamp.getTime() ?? -Infinity) <= ts.getTime())
+          sessionEvents.set(key, {
+            sessionId,
+            source: "gemini-cli",
+            project,
+            timestamp: ts,
+            role
+          });
+        if (role !== "assistant") continue;
         const tokens = msg.tokens;
         const usage = msg.usage || msg.usageMetadata || msg.token_count;
         if (!tokens && !usage) continue;
         if (tokens) {
-          const cached = tokens.cached || 0;
-          const thoughts = tokens.thoughts || 0;
-          entries.push({
-            sessionId: filePath,
+          const cached = tokenCount2(tokens.cached);
+          const input2 = tokenCount2(tokens.input);
+          const thoughts = tokenCount2(tokens.thoughts);
+          storeEntry(key, {
+            sessionId,
             source: "gemini-cli",
             model: msg.model || record.model || "unknown",
             project,
             timestamp: ts,
-            inputTokens: (tokens.input || 0) - cached,
-            outputTokens: (tokens.output || 0) - thoughts,
+            inputTokens: input2 >= cached ? input2 - cached : input2,
+            outputTokens: tokenCount2(tokens.output),
             reasoningTokens: thoughts,
             cachedTokens: cached
           });
         } else if (usage) {
-          const cached = usage.cachedContentTokenCount || 0;
-          const thoughts = usage.thoughtsTokenCount || 0;
-          entries.push({
-            sessionId: filePath,
+          const cached = tokenCount2(usage.cachedContentTokenCount);
+          const thoughts = tokenCount2(usage.thoughtsTokenCount);
+          const input2 = tokenCount2(
+            usage.promptTokenCount ?? usage.input_tokens
+          );
+          const output = usage.candidatesTokenCount ?? usage.output_tokens;
+          storeEntry(key, {
+            sessionId,
             source: "gemini-cli",
             model: msg.model || record.model || "unknown",
             project,
             timestamp: ts,
-            inputTokens: (usage.promptTokenCount || usage.input_tokens || 0) - cached,
-            outputTokens: (usage.candidatesTokenCount || usage.output_tokens || 0) - thoughts,
+            inputTokens: input2 >= cached ? input2 - cached : input2,
+            outputTokens: output !== void 0 ? tokenCount2(output) : Math.max(
+              0,
+              tokenCount2(usage.totalTokenCount) - input2 - thoughts
+            ),
             reasoningTokens: thoughts,
             cachedTokens: cached
           });
@@ -955,15 +1221,18 @@ var GeminiCliParser = class {
       }
     }
     return {
-      buckets: aggregateToBuckets(entries),
-      sessions: extractSessions(sessionEvents, entries)
+      buckets: aggregateToBuckets([...entries.values()]),
+      sessions: extractSessions(
+        [...sessionEvents.values()],
+        [...entries.values()]
+      )
     };
   }
 };
 registerParser(new GeminiCliParser());
 
 // src/parsers/hermes.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { homedir as homedir5 } from "os";
 import { dirname, join as join6 } from "path";
 
@@ -971,53 +1240,6 @@ import { dirname, join as join6 } from "path";
 import { execFileSync } from "child_process";
 import { statSync } from "fs";
 import { pathToFileURL } from "url";
-
-// src/utils/logger.ts
-var LOG_LEVELS = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3
-};
-var Logger = class {
-  level;
-  constructor(level = "info") {
-    this.level = level;
-  }
-  setLevel(level) {
-    this.level = level;
-  }
-  debug(msg) {
-    if (LOG_LEVELS[this.level] <= LOG_LEVELS.debug) {
-      process.stderr.write(`[debug] ${msg}
-`);
-    }
-  }
-  info(msg) {
-    if (LOG_LEVELS[this.level] <= LOG_LEVELS.info) {
-      process.stdout.write(`${msg}
-`);
-    }
-  }
-  warn(msg) {
-    if (LOG_LEVELS[this.level] <= LOG_LEVELS.warn) {
-      process.stderr.write(`warn: ${msg}
-`);
-    }
-  }
-  error(msg) {
-    if (LOG_LEVELS[this.level] <= LOG_LEVELS.error) {
-      process.stderr.write(`error: ${msg}
-`);
-    }
-  }
-  log(msg) {
-    this.info(msg);
-  }
-};
-var logger = new Logger();
-
-// src/infrastructure/sqlite.ts
 function withSuppressedSqliteWarning(fn) {
   const originalEmitWarning = process.emitWarning;
   process.emitWarning = ((warning, ...args) => {
@@ -1122,7 +1344,7 @@ async function readSqliteRows(dbPath, query) {
 
 // src/parsers/hermes.ts
 var TOOL_ID3 = "hermes";
-var TOOL_NAME3 = "Hermes Agent";
+var TOOL_NAME2 = "Hermes Agent";
 var DEFAULT_DB_PATH = join6(homedir5(), ".hermes", "state.db");
 var SESSIONS_QUERY = `SELECT
   id,
@@ -1144,14 +1366,14 @@ var MESSAGES_QUERY = `SELECT
   FROM messages
   WHERE role IN ('user', 'assistant')
   ORDER BY timestamp`;
-function createToolDefinition3(dbPath) {
+function createToolDefinition2(dbPath) {
   return {
     id: TOOL_ID3,
-    name: TOOL_NAME3,
+    name: TOOL_NAME2,
     dataDir: dirname(dbPath)
   };
 }
-function toSafeNumber3(value) {
+function toSafeNumber2(value) {
   const numberValue = Number(value);
   return Number.isFinite(numberValue) ? numberValue : 0;
 }
@@ -1170,10 +1392,10 @@ var HermesParser = class {
   constructor(options = {}) {
     this.dbPath = options.dbPath || DEFAULT_DB_PATH;
     this.queryRows = options.queryRows || readSqliteRows;
-    this.tool = createToolDefinition3(this.dbPath);
+    this.tool = createToolDefinition2(this.dbPath);
   }
   async parse() {
-    if (!existsSync6(this.dbPath)) {
+    if (!existsSync7(this.dbPath)) {
       return { buckets: [], sessions: [] };
     }
     const sessionRows = await this.queryRows(
@@ -1186,10 +1408,10 @@ var HermesParser = class {
       if (!sessionId) continue;
       const timestamp = parseUnixTimestamp(row.startedAt);
       if (!timestamp) continue;
-      const inputTokens = toSafeNumber3(row.inputTokens);
-      const outputTokens = toSafeNumber3(row.outputTokens);
-      const cachedTokens = toSafeNumber3(row.cacheReadTokens);
-      const reasoningTokens = toSafeNumber3(row.reasoningTokens);
+      const inputTokens = toSafeNumber2(row.inputTokens);
+      const outputTokens = toSafeNumber2(row.outputTokens);
+      const cachedTokens = toSafeNumber2(row.cacheReadTokens);
+      const reasoningTokens = toSafeNumber2(row.reasoningTokens);
       if (inputTokens === 0 && outputTokens === 0 && cachedTokens === 0 && reasoningTokens === 0) {
         continue;
       }
@@ -1239,17 +1461,17 @@ var HermesParser = class {
     };
   }
   isInstalled() {
-    return existsSync6(this.dbPath);
+    return existsSync7(this.dbPath);
   }
 };
 registerParser(new HermesParser());
 
 // src/parsers/mimocode.ts
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 import { homedir as homedir6 } from "os";
 import { join as join7 } from "path";
 var TOOL_ID4 = "mimocode";
-var TOOL_NAME4 = "MiMoCode";
+var TOOL_NAME3 = "MiMoCode";
 var DEFAULT_DB_PATH2 = join7(
   homedir6(),
   ".local",
@@ -1287,7 +1509,7 @@ function getMimocodeDbPaths() {
   ].filter((value) => Boolean(value));
   return Array.from(new Set(paths));
 }
-function toSafeNumber4(value) {
+function toSafeNumber3(value) {
   const n = Number(value);
   return Number.isFinite(n) && n >= 0 ? Math.round(n) : 0;
 }
@@ -1307,7 +1529,7 @@ var MimocodeParser = class {
     this.resolveDbPaths = resolveDbPaths;
     this.tool = {
       id: TOOL_ID4,
-      name: TOOL_NAME4,
+      name: TOOL_NAME3,
       dataDir: DEFAULT_DB_PATH2
     };
   }
@@ -1316,13 +1538,15 @@ var MimocodeParser = class {
   async parse() {
     const allEntries = [];
     const allSessionEvents = [];
+    let incomplete = false;
     for (const dbPath of this.resolveDbPaths()) {
-      if (!existsSync7(dbPath)) continue;
+      if (!existsSync8(dbPath)) continue;
       try {
         const { entries, sessionEvents } = await this.parseDb(dbPath);
         allEntries.push(...entries);
         allSessionEvents.push(...sessionEvents);
       } catch (err) {
+        incomplete = true;
         process.stderr.write(
           `warn: mimocode parse failed for ${dbPath} (${err.message})
 `
@@ -1331,11 +1555,12 @@ var MimocodeParser = class {
     }
     return {
       buckets: aggregateToBuckets(allEntries),
-      sessions: extractSessions(allSessionEvents, allEntries)
+      sessions: extractSessions(allSessionEvents, allEntries),
+      ...incomplete ? { incomplete: true } : {}
     };
   }
   isInstalled() {
-    return this.resolveDbPaths().some((p) => existsSync7(p));
+    return this.resolveDbPaths().some((p) => existsSync8(p));
   }
   async parseDb(dbPath) {
     const messageRows = await readSqliteRows(
@@ -1353,11 +1578,12 @@ var MimocodeParser = class {
       const model = typeof row.modelID === "string" ? row.modelID : "unknown";
       const sessionId = typeof row.sessionId === "string" ? row.sessionId : "unknown";
       const project = extractProject2(row.directory);
-      const inputTokens = toSafeNumber4(row.inputTokens);
-      const outputTokens = toSafeNumber4(row.outputTokens);
-      const reasoningTokens = toSafeNumber4(row.reasoningTokens);
-      const cachedTokens = toSafeNumber4(row.cacheReadTokens);
-      if (inputTokens + outputTokens + reasoningTokens + cachedTokens === 0) {
+      const inputTokens = toSafeNumber3(row.inputTokens);
+      const outputTokens = toSafeNumber3(row.outputTokens);
+      const reasoningTokens = toSafeNumber3(row.reasoningTokens);
+      const cachedTokens = toSafeNumber3(row.cacheReadTokens);
+      const cacheCreationTokens = toSafeNumber3(row.cacheWriteTokens);
+      if (inputTokens + outputTokens + reasoningTokens + cachedTokens + cacheCreationTokens === 0) {
         continue;
       }
       entries.push({
@@ -1369,7 +1595,8 @@ var MimocodeParser = class {
         inputTokens,
         outputTokens,
         reasoningTokens,
-        cachedTokens
+        cachedTokens,
+        cacheCreationTokens
       });
     }
     for (const row of sessionRows) {
@@ -1392,20 +1619,131 @@ var MimocodeParser = class {
 };
 registerParser(new MimocodeParser());
 
-// src/parsers/mirasim.ts
-import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync8 } from "fs";
-import { homedir as homedir7, hostname as hostname3 } from "os";
+// src/parsers/mcode.ts
+import { existsSync as existsSync9 } from "fs";
+import { homedir as homedir7 } from "os";
 import { join as join8 } from "path";
+function getMcodeDbPath(env = process.env) {
+  const dataDir = [env.MINIMAX_DATA_DIR, env.MAVIS_DATA_DIR].map((value) => value?.trim()).find(Boolean) || join8(homedir7(), ".minimax");
+  return join8(dataDir, "v2", "sqlite", "runtime-state.sqlite");
+}
+function tokenCount3(value) {
+  const count = Number(value);
+  return Number.isFinite(count) && count >= 0 ? Math.trunc(count) : 0;
+}
+var McodeParser = class {
+  tool;
+  dbPath;
+  queryRows;
+  constructor(options = {}) {
+    this.dbPath = options.dbPath ?? getMcodeDbPath();
+    this.queryRows = options.queryRows ?? readSqliteRows;
+    this.tool = { id: "mcode", name: "MiniMax Code", dataDir: this.dbPath };
+  }
+  async parse() {
+    if (!existsSync9(this.dbPath)) return { buckets: [], sessions: [] };
+    let rows;
+    try {
+      rows = await this.queryRows(
+        this.dbPath,
+        `SELECT
+        id, session_id AS sessionId, model, ts AS timestamp,
+        input_tokens AS inputTokens, output_tokens AS outputTokens,
+        reasoning_tokens AS reasoningTokens, cache_read_tokens AS cachedTokens,
+        cache_write_tokens AS cacheCreationTokens
+        FROM local_runtime_token_usage ORDER BY id`
+      );
+    } catch (error) {
+      process.stderr.write(
+        `warn: mcode usage parse failed (${error.message})
+`
+      );
+      return { buckets: [], sessions: [], incomplete: true };
+    }
+    const projects = /* @__PURE__ */ new Map();
+    let incomplete = false;
+    try {
+      const sessions = await this.queryRows(
+        this.dbPath,
+        "SELECT session_id AS sessionId, workspace_dir AS directory FROM local_runtime_sessions"
+      );
+      for (const row of sessions) {
+        const project = row.directory?.replace(/[\\/]+$/, "").split(/[\\/]/).pop();
+        if (project) projects.set(row.sessionId, project);
+      }
+    } catch (error) {
+      if (!error.message.includes(
+        "no such table: local_runtime_sessions"
+      )) {
+        incomplete = true;
+        process.stderr.write(
+          `warn: mcode session metadata parse failed (${error.message})
+`
+        );
+      }
+    }
+    const entries = [];
+    const events = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const row of rows) {
+      if (row.timestamp === null || row.timestamp === void 0) continue;
+      const timestamp = new Date(Number(row.timestamp));
+      if (!Number.isFinite(Number(row.timestamp)) || Number.isNaN(timestamp.getTime()))
+        continue;
+      const key = JSON.stringify([row.sessionId, row.id]);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const nativeModel = row.model || "unknown";
+      const model = nativeModel.includes("/") ? nativeModel.slice(nativeModel.indexOf("/") + 1) : nativeModel;
+      const entry = {
+        sessionId: row.sessionId,
+        source: "mcode",
+        project: projects.get(row.sessionId) || "unknown",
+        model: model || "unknown",
+        timestamp,
+        inputTokens: tokenCount3(row.inputTokens),
+        outputTokens: tokenCount3(row.outputTokens),
+        reasoningTokens: tokenCount3(row.reasoningTokens),
+        cachedTokens: tokenCount3(row.cachedTokens),
+        cacheCreationTokens: tokenCount3(row.cacheCreationTokens)
+      };
+      if (entry.inputTokens + entry.outputTokens + entry.reasoningTokens + entry.cachedTokens + (entry.cacheCreationTokens ?? 0) === 0)
+        continue;
+      entries.push(entry);
+      events.push({
+        sessionId: row.sessionId,
+        source: "mcode",
+        project: entry.project,
+        timestamp,
+        role: "assistant"
+      });
+    }
+    return {
+      buckets: aggregateToBuckets(entries),
+      sessions: extractSessions(events, entries),
+      ...incomplete ? { incomplete: true } : {}
+    };
+  }
+  isInstalled() {
+    return existsSync9(this.dbPath);
+  }
+};
+registerParser(new McodeParser());
+
+// src/parsers/mirasim.ts
+import { createHash as createHash3 } from "crypto";
+import { existsSync as existsSync10 } from "fs";
+import { homedir as homedir8, hostname as hostname3 } from "os";
+import { join as join9 } from "path";
 var TOOL_ID5 = "mirasim";
-var TOOL_NAME5 = "Mirasim";
-var DEFAULT_INSIGHTS_DIR = join8(homedir7(), ".mirasim", "insights");
+var TOOL_NAME4 = "Mirasim";
+var DEFAULT_INSIGHTS_DIR = join9(homedir8(), ".mirasim", "insights");
 var USAGE_FILE_PATTERN = /^usage-\d{4}-\d{2}\.ndjson$/;
 var MIRASIM_OWN_AGENTS = ["gui", "pi-gui"];
 function getInsightsDirs(env = process.env) {
   const dirs = [
     env.TOKEN_ARENA_MIRASIM_DIR,
-    env.MIRASIM_HOME ? join8(env.MIRASIM_HOME, "insights") : void 0,
+    env.MIRASIM_HOME ? join9(env.MIRASIM_HOME, "insights") : void 0,
     DEFAULT_INSIGHTS_DIR
   ].filter((value) => Boolean(value));
   return Array.from(new Set(dirs));
@@ -1435,7 +1773,7 @@ function parseIsoDate(value) {
   const timestamp = new Date(raw);
   return Number.isNaN(timestamp.getTime()) ? null : timestamp;
 }
-function getPathLeaf3(value) {
+function getPathLeaf2(value) {
   if (!value) {
     return "unknown";
   }
@@ -1454,13 +1792,14 @@ function buildSessionUsage2(entries) {
       byModel = /* @__PURE__ */ new Map();
       usageBySession.set(entry.sessionId, byModel);
     }
-    const totalTokens = entry.inputTokens + entry.outputTokens + entry.reasoningTokens + entry.cachedTokens;
+    const totalTokens = entry.inputTokens + entry.outputTokens + entry.reasoningTokens + entry.cachedTokens + (entry.cacheCreationTokens ?? 0);
     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) + (entry.cacheCreationTokens ?? 0);
       existing.totalTokens += totalTokens;
       continue;
     }
@@ -1470,6 +1809,7 @@ function buildSessionUsage2(entries) {
       outputTokens: entry.outputTokens,
       reasoningTokens: entry.reasoningTokens,
       cachedTokens: entry.cachedTokens,
+      cacheCreationTokens: entry.cacheCreationTokens ?? 0,
       totalTokens
     });
   }
@@ -1503,6 +1843,10 @@ function buildSessions(drafts, entries) {
       (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
@@ -1516,7 +1860,7 @@ function buildSessions(drafts, entries) {
     return {
       source: TOOL_ID5,
       project: draft.project,
-      sessionHash: createHash2("sha256").update(draft.sessionId).digest("hex").slice(0, 16),
+      sessionHash: createHash3("sha256").update(draft.sessionId).digest("hex").slice(0, 16),
       hostname: host,
       firstMessageAt: draft.firstCallAt.toISOString(),
       lastMessageAt: draft.lastCallEndAt.toISOString(),
@@ -1536,6 +1880,7 @@ function buildSessions(drafts, entries) {
       outputTokens,
       reasoningTokens,
       cachedTokens,
+      cacheCreationTokens,
       totalTokens,
       primaryModel: modelUsages[0]?.model ?? "",
       modelUsages
@@ -1551,7 +1896,7 @@ var MirasimParser = class {
     this.ownAgents = new Set(options.ownAgents ?? MIRASIM_OWN_AGENTS);
     this.tool = {
       id: TOOL_ID5,
-      name: TOOL_NAME5,
+      name: TOOL_NAME4,
       dataDir: this.insightsDirs[0] ?? DEFAULT_INSIGHTS_DIR
     };
   }
@@ -1575,12 +1920,13 @@ var MirasimParser = class {
             0,
             toNonNegativeInteger(row.output) - reasoningTokens
           );
-          const cachedTokens = toNonNegativeInteger(row.cacheRead) + toNonNegativeInteger(row.cacheWrite);
-          if (inputTokens + outputTokens + reasoningTokens + cachedTokens === 0) {
+          const cachedTokens = toNonNegativeInteger(row.cacheRead);
+          const cacheCreationTokens = toNonNegativeInteger(row.cacheWrite);
+          if (inputTokens + outputTokens + reasoningTokens + cachedTokens + cacheCreationTokens === 0) {
             continue;
           }
           const sessionId = getString(row.sessionId);
-          const project = getPathLeaf3(getString(row.workspace));
+          const project = getPathLeaf2(getString(row.workspace));
           const callId = getString(row.id) ?? [sessionId ?? "", timestamp.toISOString(), agent, model].join("|");
           if (seenCallIds.has(callId)) continue;
           seenCallIds.add(callId);
@@ -1593,7 +1939,8 @@ var MirasimParser = class {
             inputTokens,
             outputTokens,
             reasoningTokens,
-            cachedTokens
+            cachedTokens,
+            cacheCreationTokens
           });
           if (!sessionId) continue;
           const durationMs = toNonNegativeInteger(row.durationMs);
@@ -1626,29 +1973,29 @@ var MirasimParser = class {
     };
   }
   isInstalled() {
-    return this.insightsDirs.some((dir) => existsSync8(dir));
+    return this.insightsDirs.some((dir) => existsSync10(dir));
   }
 };
 registerParser(new MirasimParser());
 
 // src/parsers/copilot-cli.ts
-import { existsSync as existsSync9, readdirSync as readdirSync3, readFileSync as readFileSync3 } from "fs";
-import { homedir as homedir8 } from "os";
-import { basename as basename3, dirname as dirname2, join as join9 } from "path";
-var ROOT_DIR = join9(homedir8(), ".copilot");
+import { existsSync as existsSync11, readdirSync as readdirSync3, readFileSync as readFileSync3 } from "fs";
+import { homedir as homedir9 } from "os";
+import { basename as basename4, dirname as dirname2, join as join10 } from "path";
+var ROOT_DIR = join10(homedir9(), ".copilot");
 var TOOL3 = {
   id: "copilot-cli",
   name: "GitHub Copilot CLI",
   dataDir: ROOT_DIR
 };
 function collectEventFiles(dir, results, visited) {
-  if (!existsSync9(dir) || visited.has(dir)) {
+  if (!existsSync11(dir) || visited.has(dir)) {
     return;
   }
   visited.add(dir);
   try {
     for (const entry of readdirSync3(dir, { withFileTypes: true })) {
-      const fullPath = join9(dir, entry.name);
+      const fullPath = join10(dir, entry.name);
       if (entry.isDirectory()) {
         collectEventFiles(fullPath, results, visited);
         continue;
@@ -1656,7 +2003,7 @@ function collectEventFiles(dir, results, visited) {
       if (entry.isFile() && entry.name === "events.jsonl") {
         results.push({
           filePath: fullPath,
-          sessionId: basename3(dirname2(fullPath))
+          sessionId: basename4(dirname2(fullPath))
         });
       }
     }
@@ -1671,7 +2018,7 @@ function findEventFiles(baseDir) {
 function getProjectFromContext(context) {
   const projectPath = context?.gitRoot || context?.cwd;
   if (!projectPath) return "unknown";
-  return basename3(projectPath.replace(/[\\/]+$/, "")) || "unknown";
+  return basename4(projectPath.replace(/[\\/]+$/, "")) || "unknown";
 }
 var CopilotCliParser = class {
   tool = TOOL3;
@@ -1682,6 +2029,7 @@ var CopilotCliParser = class {
     }
     const entries = [];
     const sessionEvents = [];
+    const cumulativeUsage = /* @__PURE__ */ new Map();
     for (const { filePath, sessionId } of eventFiles) {
       let content;
       try {
@@ -1724,10 +2072,42 @@ var CopilotCliParser = class {
           for (const [model, metrics] of Object.entries(modelMetrics)) {
             const usage = metrics?.usage;
             if (!usage) continue;
-            const totalInput = usage.inputTokens || 0;
-            const cachedRead = usage.cacheReadTokens || 0;
-            const output = usage.outputTokens || 0;
-            if (totalInput === 0 && cachedRead === 0 && output === 0) {
+            const totalInput = usage.inputTokens ?? 0;
+            const cachedRead = usage.cacheReadTokens ?? 0;
+            const cachedWrite = usage.cacheWriteTokens ?? 0;
+            const output = usage.outputTokens ?? 0;
+            if ([totalInput, cachedRead, cachedWrite, output].some(
+              (count) => !Number.isSafeInteger(count) || count < 0
+            )) {
+              continue;
+            }
+            const key = JSON.stringify([sessionId, model]);
+            const previous = cumulativeUsage.get(key) ?? {
+              inputTokens: 0,
+              outputTokens: 0,
+              cachedTokens: 0,
+              cacheCreationTokens: 0
+            };
+            const inputTokens = Math.max(
+              0,
+              totalInput - cachedRead - cachedWrite - previous.inputTokens
+            );
+            const outputTokens = Math.max(0, output - previous.outputTokens);
+            const cachedTokens = Math.max(
+              0,
+              cachedRead - previous.cachedTokens
+            );
+            const cacheCreationTokens = Math.max(
+              0,
+              cachedWrite - previous.cacheCreationTokens
+            );
+            cumulativeUsage.set(key, {
+              inputTokens: previous.inputTokens + inputTokens,
+              outputTokens: previous.outputTokens + outputTokens,
+              cachedTokens: previous.cachedTokens + cachedTokens,
+              cacheCreationTokens: previous.cacheCreationTokens + cacheCreationTokens
+            });
+            if (inputTokens + outputTokens + cachedTokens + cacheCreationTokens === 0) {
               continue;
             }
             entries.push({
@@ -1736,10 +2116,11 @@ var CopilotCliParser = class {
               model,
               project: currentProject,
               timestamp,
-              inputTokens: Math.max(0, totalInput - cachedRead),
-              outputTokens: output,
+              inputTokens,
+              outputTokens,
               reasoningTokens: 0,
-              cachedTokens: cachedRead
+              cachedTokens,
+              cacheCreationTokens
             });
           }
         } catch {
@@ -1752,30 +2133,30 @@ var CopilotCliParser = class {
     };
   }
   isInstalled() {
-    return existsSync9(ROOT_DIR);
+    return existsSync11(ROOT_DIR);
   }
 };
 registerParser(new CopilotCliParser());
 
 // src/parsers/oh-my-pi.ts
-import { existsSync as existsSync10 } from "fs";
-import { homedir as homedir9 } from "os";
-import { join as join10 } from "path";
+import { existsSync as existsSync12 } from "fs";
+import { homedir as homedir10 } from "os";
+import { join as join11 } from "path";
 var TOOL_ID6 = "oh-my-pi";
-var TOOL_NAME6 = "omp";
-var DEFAULT_SESSIONS_DIR2 = join10(homedir9(), ".omp", "agent", "sessions");
-function createToolDefinition4(dataDir) {
+var TOOL_NAME5 = "omp";
+var DEFAULT_SESSIONS_DIR2 = join11(homedir10(), ".omp", "agent", "sessions");
+function createToolDefinition3(dataDir) {
   return {
     id: TOOL_ID6,
-    name: TOOL_NAME6,
+    name: TOOL_NAME5,
     dataDir
   };
 }
-function toSafeNumber5(value) {
+function toSafeNumber4(value) {
   const numberValue = Number(value);
   return Number.isFinite(numberValue) ? numberValue : 0;
 }
-function getPathLeaf4(value) {
+function getPathLeaf3(value) {
   const normalized = value.replace(/\\/g, "/").replace(/\/+$/, "");
   const leaf = normalized.split("/").filter(Boolean).pop();
   return leaf || "unknown";
@@ -1786,7 +2167,7 @@ function normalizeForPrefix2(value) {
 function getUsageNumber2(usage, ...keys) {
   for (const key of keys) {
     const value = usage[key];
-    const numberValue = toSafeNumber5(value);
+    const numberValue = toSafeNumber4(value);
     if (numberValue > 0) {
       return numberValue;
     }
@@ -1794,7 +2175,7 @@ function getUsageNumber2(usage, ...keys) {
   return 0;
 }
 function extractOhMyPiProjectFromCwd(cwd) {
-  return getPathLeaf4(cwd);
+  return getPathLeaf3(cwd);
 }
 function extractOhMyPiProjectFromDir(filePath, sessionsDir = DEFAULT_SESSIONS_DIR2) {
   const normalizedFilePath = normalizeForPrefix2(filePath);
@@ -1811,7 +2192,7 @@ function extractOhMyPiProjectFromDir(filePath, sessionsDir = DEFAULT_SESSIONS_DI
   try {
     const decoded = decodeURIComponent(firstSegment);
     if (decoded.includes("/") || decoded.includes("\\")) {
-      return getPathLeaf4(decoded);
+      return getPathLeaf3(decoded);
     }
   } catch {
   }
@@ -1821,7 +2202,7 @@ function extractOhMyPiProjectFromDir(filePath, sessionsDir = DEFAULT_SESSIONS_DI
 var OhMyPiParser = class {
   constructor(sessionsDir = DEFAULT_SESSIONS_DIR2) {
     this.sessionsDir = sessionsDir;
-    this.tool = createToolDefinition4(sessionsDir);
+    this.tool = createToolDefinition3(sessionsDir);
   }
   sessionsDir;
   tool;
@@ -1910,29 +2291,45 @@ var OhMyPiParser = class {
     };
   }
   isInstalled() {
-    return existsSync10(this.sessionsDir);
+    return existsSync12(this.sessionsDir);
   }
 };
 registerParser(new OhMyPiParser());
 
 // src/parsers/opencode.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync11, readdirSync as readdirSync4, readFileSync as readFileSync4 } from "fs";
-import { homedir as homedir10 } from "os";
-import { basename as basename4, join as join11 } from "path";
-var DEFAULT_DATA_DIR2 = join11(homedir10(), ".local", "share", "opencode");
+import { existsSync as existsSync13, readdirSync as readdirSync4, readFileSync as readFileSync4 } from "fs";
+import { homedir as homedir11 } from "os";
+import { basename as basename5, join as join12 } from "path";
+var DEFAULT_DATA_DIR2 = join12(homedir11(), ".local", "share", "opencode");
 var TOOL4 = {
   id: "opencode",
   name: "OpenCode",
   dataDir: DEFAULT_DATA_DIR2
 };
+function hasTokens(tokens) {
+  return [
+    tokens.input,
+    tokens.output,
+    tokens.reasoning,
+    tokens.cache?.read,
+    tokens.cache?.write
+  ].some((value) => typeof value === "number" && value !== 0);
+}
+function seenMessage(seen, sessionId, messageId) {
+  if (!sessionId || !messageId) return false;
+  const key = JSON.stringify([sessionId, messageId]);
+  if (seen.has(key)) return true;
+  seen.add(key);
+  return false;
+}
 function getOpenCodeDataDirs(env = process.env) {
   const dirs = [
     env.TOKEN_ARENA_OPENCODE_DIR,
-    env.XDG_DATA_HOME ? join11(env.XDG_DATA_HOME, "opencode") : void 0,
+    env.XDG_DATA_HOME ? join12(env.XDG_DATA_HOME, "opencode") : void 0,
     DEFAULT_DATA_DIR2,
-    env.LOCALAPPDATA ? join11(env.LOCALAPPDATA, "opencode") : void 0,
-    env.APPDATA ? join11(env.APPDATA, "opencode") : void 0
+    env.LOCALAPPDATA ? join12(env.LOCALAPPDATA, "opencode") : void 0,
+    env.APPDATA ? join12(env.APPDATA, "opencode") : void 0
   ].filter((value) => Boolean(value));
   return Array.from(new Set(dirs));
 }
@@ -2006,16 +2403,21 @@ function readSqliteRowsWithCli2(dbPath, query) {
   );
 }
 var OpenCodeParser = class {
-  constructor(resolveRoots = getOpenCodeDataDirs) {
+  constructor(resolveRoots = getOpenCodeDataDirs, queryRows) {
     this.resolveRoots = resolveRoots;
+    this.queryRows = queryRows;
   }
   resolveRoots;
+  queryRows;
   tool = TOOL4;
   async parse() {
     const buckets = [];
     const sessions = [];
-    for (const rootDir of this.resolveRoots()) {
-      const result = await this.parseRoot(rootDir);
+    const seen = /* @__PURE__ */ new Set();
+    let incomplete = false;
+    for (const rootDir of new Set(this.resolveRoots())) {
+      const result = await this.parseRoot(rootDir, seen);
+      incomplete ||= Boolean(result.incomplete);
       if (result.buckets.length > 0) {
         buckets.push(...result.buckets);
       }
@@ -2023,28 +2425,30 @@ var OpenCodeParser = class {
         sessions.push(...result.sessions);
       }
     }
-    return { buckets, sessions };
+    return { buckets, sessions, ...incomplete ? { incomplete: true } : {} };
   }
   isInstalled() {
-    return this.resolveRoots().some((dir) => existsSync11(dir));
+    return this.resolveRoots().some((dir) => existsSync13(dir));
   }
-  async parseRoot(rootDir) {
-    const dbPath = join11(rootDir, "opencode.db");
-    const messagesDir = join11(rootDir, "storage", "message");
-    if (existsSync11(dbPath)) {
+  async parseRoot(rootDir, seen) {
+    const dbPath = join12(rootDir, "opencode.db");
+    const messagesDir = join12(rootDir, "storage", "message");
+    if (existsSync13(dbPath)) {
       try {
-        return await this.parseFromSqlite(dbPath);
+        return await this.parseFromSqlite(dbPath, seen);
       } catch (err) {
         process.stderr.write(
           `warn: opencode sqlite parse failed (${err.message}), trying legacy json...
 `
         );
+        return { ...this.parseFromJson(messagesDir, seen), incomplete: true };
       }
     }
-    return this.parseFromJson(messagesDir);
+    return this.parseFromJson(messagesDir, seen);
   }
-  async parseFromSqlite(dbPath) {
+  async parseFromSqlite(dbPath, seen) {
     const query = `SELECT
+      id as messageId,
       session_id as sessionID,
       json_extract(data, '$.role') as role,
       json_extract(data, '$.time.created') as created,
@@ -2052,7 +2456,7 @@ var OpenCodeParser = class {
       json_extract(data, '$.tokens') as tokens,
       json_extract(data, '$.path.root') as rootPath
       FROM message`;
-    const builtinRows = await readSqliteRowsWithBuiltin2(dbPath, query);
+    const builtinRows = this.queryRows ? await this.queryRows(dbPath, query) : await readSqliteRowsWithBuiltin2(dbPath, query);
     const rows = builtinRows ?? readSqliteRowsWithCli2(dbPath, query);
     if (rows.length === 0) {
       return { buckets: [], sessions: [] };
@@ -2062,9 +2466,10 @@ var OpenCodeParser = class {
     for (const row of rows) {
       const timestamp = new Date(row.created);
       if (Number.isNaN(timestamp.getTime())) continue;
-      const project = row.rootPath ? basename4(row.rootPath) : "unknown";
+      const project = row.rootPath ? basename5(row.rootPath) : "unknown";
       const sessionId = row.sessionID || "unknown";
       if (row.role !== "user" && row.role !== "assistant") continue;
+      if (seenMessage(seen, row.sessionID, row.messageId)) continue;
       sessionEvents.push({
         sessionId,
         source: "opencode",
@@ -2072,14 +2477,14 @@ var OpenCodeParser = class {
         timestamp,
         role: row.role === "user" ? "user" : "assistant"
       });
-      if (!row.modelID) continue;
+      if (row.role !== "assistant") continue;
       let tokens;
       try {
         tokens = typeof row.tokens === "string" ? JSON.parse(row.tokens) : row.tokens;
       } catch {
         continue;
       }
-      if (!tokens || !tokens.input && !tokens.output) continue;
+      if (!tokens || !hasTokens(tokens)) continue;
       entries.push({
         sessionId,
         source: "opencode",
@@ -2089,7 +2494,8 @@ var OpenCodeParser = class {
         inputTokens: tokens.input || 0,
         outputTokens: tokens.output || 0,
         reasoningTokens: tokens.reasoning || 0,
-        cachedTokens: tokens.cache?.read || 0
+        cachedTokens: tokens.cache?.read || 0,
+        cacheCreationTokens: tokens.cache?.write || 0
       });
     }
     return {
@@ -2097,8 +2503,8 @@ var OpenCodeParser = class {
       sessions: extractSessions(sessionEvents, entries)
     };
   }
-  parseFromJson(messagesDir) {
-    if (!existsSync11(messagesDir)) return { buckets: [], sessions: [] };
+  parseFromJson(messagesDir, seen) {
+    if (!existsSync13(messagesDir)) return { buckets: [], sessions: [] };
     const entries = [];
     const sessionEvents = [];
     let sessionDirs;
@@ -2110,7 +2516,7 @@ var OpenCodeParser = class {
       return { buckets: [], sessions: [] };
     }
     for (const sessionDir of sessionDirs) {
-      const sessionPath = join11(messagesDir, sessionDir.name);
+      const sessionPath = join12(messagesDir, sessionDir.name);
       let messageFiles;
       try {
         messageFiles = readdirSync4(sessionPath).filter(
@@ -2120,7 +2526,7 @@ var OpenCodeParser = class {
         continue;
       }
       for (const file of messageFiles) {
-        const filePath = join11(sessionPath, file);
+        const filePath = join12(sessionPath, file);
         let data;
         try {
           data = JSON.parse(readFileSync4(filePath, "utf-8"));
@@ -2132,8 +2538,10 @@ var OpenCodeParser = class {
         const timestamp = new Date(created);
         if (Number.isNaN(timestamp.getTime())) continue;
         const rootPath = data.path?.root;
-        const project = rootPath ? basename4(rootPath) : "unknown";
+        const project = rootPath ? basename5(rootPath) : "unknown";
         if (data.role !== "user" && data.role !== "assistant") continue;
+        if (seenMessage(seen, data.sessionID || sessionDir.name, data.id))
+          continue;
         sessionEvents.push({
           sessionId: sessionDir.name,
           source: "opencode",
@@ -2141,9 +2549,9 @@ var OpenCodeParser = class {
           timestamp,
           role: data.role === "user" ? "user" : "assistant"
         });
-        if (!data.modelID) continue;
+        if (data.role !== "assistant") continue;
         const tokens = data.tokens;
-        if (!tokens || !tokens.input && !tokens.output) continue;
+        if (!tokens || !hasTokens(tokens)) continue;
         entries.push({
           sessionId: sessionDir.name,
           source: "opencode",
@@ -2153,7 +2561,8 @@ var OpenCodeParser = class {
           inputTokens: tokens.input || 0,
           outputTokens: tokens.output || 0,
           reasoningTokens: tokens.reasoning || 0,
-          cachedTokens: tokens.cache?.read || 0
+          cachedTokens: tokens.cache?.read || 0,
+          cacheCreationTokens: tokens.cache?.write || 0
         });
       }
     }
@@ -2166,16 +2575,16 @@ var OpenCodeParser = class {
 registerParser(new OpenCodeParser());
 
 // src/parsers/openclaw.ts
-import { existsSync as existsSync12, readdirSync as readdirSync5, readFileSync as readFileSync5 } from "fs";
-import { homedir as homedir11 } from "os";
-import { join as join12 } from "path";
+import { existsSync as existsSync14, readdirSync as readdirSync5, readFileSync as readFileSync5 } from "fs";
+import { homedir as homedir12 } from "os";
+import { join as join13 } from "path";
 var TOOL_ID7 = "openclaw";
-var TOOL_NAME7 = "OpenClaw";
-var DEFAULT_DATA_DIR3 = join12(homedir11(), ".openclaw");
+var TOOL_NAME6 = "OpenClaw";
+var DEFAULT_DATA_DIR3 = join13(homedir12(), ".openclaw");
 var LEGACY_ROOT_NAMES = [".clawdbot", ".moltbot", ".moldbot"];
 var TOOL5 = {
   id: TOOL_ID7,
-  name: TOOL_NAME7,
+  name: TOOL_NAME6,
   dataDir: DEFAULT_DATA_DIR3
 };
 function getTokens(usage, ...keys) {
@@ -2185,16 +2594,16 @@ function getTokens(usage, ...keys) {
   }
   return 0;
 }
-function getOpenClawRoots(homeDir = homedir11()) {
-  const roots = [join12(homeDir, ".openclaw")];
+function getOpenClawRoots(homeDir = homedir12()) {
+  const roots = [join13(homeDir, ".openclaw")];
   try {
     const profileRoots = readdirSync5(homeDir, { withFileTypes: true }).filter(
       (entry) => entry.isDirectory() && /^\.openclaw-.+/.test(entry.name)
-    ).map((entry) => join12(homeDir, entry.name)).sort((left, right) => left.localeCompare(right));
+    ).map((entry) => join13(homeDir, entry.name)).sort((left, right) => left.localeCompare(right));
     roots.push(...profileRoots);
   } catch {
   }
-  roots.push(...LEGACY_ROOT_NAMES.map((name) => join12(homeDir, name)));
+  roots.push(...LEGACY_ROOT_NAMES.map((name) => join13(homeDir, name)));
   return Array.from(new Set(roots));
 }
 var OpenClawParser = class {
@@ -2207,8 +2616,8 @@ var OpenClawParser = class {
     const entries = [];
     const sessionEvents = [];
     for (const root of this.resolveRoots()) {
-      const agentsDir = join12(root, "agents");
-      if (!existsSync12(agentsDir)) continue;
+      const agentsDir = join13(root, "agents");
+      if (!existsSync14(agentsDir)) continue;
       let agentDirs;
       try {
         agentDirs = readdirSync5(agentsDir, { withFileTypes: true }).filter(
@@ -2219,8 +2628,8 @@ var OpenClawParser = class {
       }
       for (const agentDir of agentDirs) {
         const project = agentDir.name;
-        const sessionsDir = join12(agentsDir, agentDir.name, "sessions");
-        if (!existsSync12(sessionsDir)) continue;
+        const sessionsDir = join13(agentsDir, agentDir.name, "sessions");
+        if (!existsSync14(sessionsDir)) continue;
         let files;
         try {
           files = readdirSync5(sessionsDir).filter((f) => f.endsWith(".jsonl"));
@@ -2228,7 +2637,7 @@ var OpenClawParser = class {
           continue;
         }
         for (const file of files) {
-          const filePath = join12(sessionsDir, file);
+          const filePath = join13(sessionsDir, file);
           let content;
           try {
             content = readFileSync5(filePath, "utf-8");
@@ -2301,30 +2710,30 @@ var OpenClawParser = class {
     };
   }
   isInstalled() {
-    return this.resolveRoots().some((root) => existsSync12(join12(root, "agents")));
+    return this.resolveRoots().some((root) => existsSync14(join13(root, "agents")));
   }
 };
 registerParser(new OpenClawParser());
 
 // src/parsers/qwen-code.ts
-import { existsSync as existsSync13, readdirSync as readdirSync6 } from "fs";
-import { homedir as homedir12 } from "os";
-import { join as join13 } from "path";
+import { existsSync as existsSync15, readdirSync as readdirSync6 } from "fs";
+import { homedir as homedir13 } from "os";
+import { join as join14 } from "path";
 var TOOL_ID8 = "qwen-code";
-var TOOL_NAME8 = "Qwen Code";
-var DEFAULT_DATA_DIR4 = join13(homedir12(), ".qwen", "tmp");
-function createToolDefinition5(dataDir) {
+var TOOL_NAME7 = "Qwen Code";
+var DEFAULT_DATA_DIR4 = join14(homedir13(), ".qwen", "tmp");
+function createToolDefinition4(dataDir) {
   return {
     id: TOOL_ID8,
-    name: TOOL_NAME8,
+    name: TOOL_NAME7,
     dataDir
   };
 }
-function toSafeNumber6(value) {
+function toSafeNumber5(value) {
   const numberValue = Number(value);
   return Number.isFinite(numberValue) ? numberValue : 0;
 }
-function getPathLeaf5(value) {
+function getPathLeaf4(value) {
   const normalized = value.replace(/\\/g, "/").replace(/\/+$/, "");
   const leaf = normalized.split("/").filter(Boolean).pop();
   return leaf || "unknown";
@@ -2334,16 +2743,16 @@ function normalizeForPrefix3(value) {
 }
 function findSessionFiles2(baseDir) {
   const results = [];
-  if (!existsSync13(baseDir)) return results;
+  if (!existsSync15(baseDir)) return results;
   try {
     for (const entry of readdirSync6(baseDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      const chatsDir = join13(baseDir, entry.name, "chats");
-      if (!existsSync13(chatsDir)) continue;
+      const chatsDir = join14(baseDir, entry.name, "chats");
+      if (!existsSync15(chatsDir)) continue;
       try {
         for (const file of readdirSync6(chatsDir)) {
           if (file.endsWith(".jsonl")) {
-            results.push(join13(chatsDir, file));
+            results.push(join14(chatsDir, file));
           }
         }
       } catch {
@@ -2356,7 +2765,7 @@ function findSessionFiles2(baseDir) {
 }
 function resolveQwenProject(cwd, filePath, dataDir = DEFAULT_DATA_DIR4) {
   if (cwd) {
-    return getPathLeaf5(cwd);
+    return getPathLeaf4(cwd);
   }
   const normalizedFilePath = normalizeForPrefix3(filePath);
   const normalizedDataDir = normalizeForPrefix3(dataDir);
@@ -2371,7 +2780,7 @@ function resolveQwenProject(cwd, filePath, dataDir = DEFAULT_DATA_DIR4) {
 var QwenCodeParser = class {
   constructor(dataDir = DEFAULT_DATA_DIR4) {
     this.dataDir = dataDir;
-    this.tool = createToolDefinition5(dataDir);
+    this.tool = createToolDefinition4(dataDir);
   }
   dataDir;
   tool;
@@ -2407,10 +2816,10 @@ var QwenCodeParser = class {
           if (obj.type !== "assistant") continue;
           const usage = obj.usageMetadata || obj.usage;
           if (!usage) continue;
-          const totalInput = toSafeNumber6(usage.promptTokenCount) || toSafeNumber6(usage.input_tokens);
-          const totalOutput = toSafeNumber6(usage.candidatesTokenCount) || toSafeNumber6(usage.output_tokens);
-          const cachedTokens = toSafeNumber6(usage.cachedContentTokenCount);
-          const reasoningTokens = toSafeNumber6(usage.thoughtsTokenCount);
+          const totalInput = toSafeNumber5(usage.promptTokenCount) || toSafeNumber5(usage.input_tokens);
+          const totalOutput = toSafeNumber5(usage.candidatesTokenCount) || toSafeNumber5(usage.output_tokens);
+          const cachedTokens = toSafeNumber5(usage.cachedContentTokenCount);
+          const reasoningTokens = toSafeNumber5(usage.thoughtsTokenCount);
           if (totalInput === 0 && totalOutput === 0 && cachedTokens === 0 && reasoningTokens === 0) {
             continue;
           }
@@ -2439,19 +2848,19 @@ var QwenCodeParser = class {
     };
   }
   isInstalled() {
-    return existsSync13(this.dataDir);
+    return existsSync15(this.dataDir);
   }
 };
 registerParser(new QwenCodeParser());
 
 // src/parsers/kimi-code.ts
-import { existsSync as existsSync14, readdirSync as readdirSync7 } from "fs";
-import { homedir as homedir13 } from "os";
-import { join as join14 } from "path";
+import { existsSync as existsSync16, readdirSync as readdirSync7 } from "fs";
+import { homedir as homedir14 } from "os";
+import { join as join15 } from "path";
 var TOOL_ID9 = "kimi-code";
-var TOOL_NAME9 = "Kimi Code";
-var DEFAULT_SESSIONS_DIR3 = join14(homedir13(), ".kimi-code", "sessions");
-var DEFAULT_CONFIG_PATH = join14(homedir13(), ".kimi-code", "workspaces.json");
+var TOOL_NAME8 = "Kimi Code";
+var DEFAULT_SESSIONS_DIR3 = join15(homedir14(), ".kimi-code", "sessions");
+var DEFAULT_CONFIG_PATH = join15(homedir14(), ".kimi-code", "workspaces.json");
 var USER_EVENT_TYPES = /* @__PURE__ */ new Set([
   "UserMessage",
   "user_message",
@@ -2465,18 +2874,18 @@ var ASSISTANT_EVENT_TYPES = /* @__PURE__ */ new Set([
   "ModelOutput",
   "AssistantOutput"
 ]);
-function createToolDefinition6(dataDir) {
+function createToolDefinition5(dataDir) {
   return {
     id: TOOL_ID9,
-    name: TOOL_NAME9,
+    name: TOOL_NAME8,
     dataDir
   };
 }
-function toSafeNumber7(value) {
+function toSafeNumber6(value) {
   const numberValue = Number(value);
   return Number.isFinite(numberValue) ? numberValue : 0;
 }
-function getPathLeaf6(value) {
+function getPathLeaf5(value) {
   const normalized = value.replace(/\\/g, "/").replace(/\/+$/, "");
   const leaf = normalized.split("/").filter(Boolean).pop();
   return leaf || "unknown";
@@ -2486,29 +2895,29 @@ function isModelPlaceholder(value) {
 }
 function findWireFiles(baseDir) {
   const results = [];
-  if (!existsSync14(baseDir)) return results;
+  if (!existsSync16(baseDir)) return results;
   try {
     for (const workDir of readdirSync7(baseDir, { withFileTypes: true })) {
       if (!workDir.isDirectory()) continue;
-      const workDirPath = join14(baseDir, workDir.name);
+      const workDirPath = join15(baseDir, workDir.name);
       try {
         for (const session of readdirSync7(workDirPath, {
           withFileTypes: true
         })) {
           if (!session.isDirectory()) continue;
-          const newWireFile = join14(
+          const newWireFile = join15(
             workDirPath,
             session.name,
             "agents",
             "main",
             "wire.jsonl"
           );
-          if (existsSync14(newWireFile)) {
+          if (existsSync16(newWireFile)) {
             results.push({ filePath: newWireFile, workDirHash: workDir.name });
             continue;
           }
-          const legacyWireFile = join14(workDirPath, session.name, "wire.jsonl");
-          if (existsSync14(legacyWireFile)) {
+          const legacyWireFile = join15(workDirPath, session.name, "wire.jsonl");
+          if (existsSync16(legacyWireFile)) {
             results.push({
               filePath: legacyWireFile,
               workDirHash: workDir.name
@@ -2558,7 +2967,7 @@ function loadProjectMap(configPath) {
         pathValue = info.root || info.path || info.dir || void 0;
       }
       if (!pathValue) continue;
-      const name = typeof info === "object" && info.name ? info.name : getPathLeaf6(pathValue);
+      const name = typeof info === "object" && info.name ? info.name : getPathLeaf5(pathValue);
       projectMap.set(hash, name);
     }
   } catch {
@@ -2572,7 +2981,7 @@ var KimiCodeParser = class {
   constructor(options = {}) {
     this.sessionsDir = options.sessionsDir || DEFAULT_SESSIONS_DIR3;
     this.configPath = options.configPath || DEFAULT_CONFIG_PATH;
-    this.tool = createToolDefinition6(this.sessionsDir);
+    this.tool = createToolDefinition5(this.sessionsDir);
   }
   async parse() {
     const wireFiles = findWireFiles(this.sessionsDir);
@@ -2610,14 +3019,17 @@ var KimiCodeParser = class {
           if (!timestamp2 || Number.isNaN(timestamp2.getTime())) continue;
           const usage = obj.usage;
           if (!usage) continue;
-          const inputTokens2 = toSafeNumber7(
+          const inputTokens2 = toSafeNumber6(
             usage.input_other ?? usage.inputOther
           );
-          const outputTokens2 = toSafeNumber7(usage.output);
-          const cachedTokens2 = toSafeNumber7(
+          const outputTokens2 = toSafeNumber6(usage.output);
+          const cachedTokens2 = toSafeNumber6(
             usage.input_cache_read ?? usage.inputCacheRead
           );
-          if (inputTokens2 === 0 && outputTokens2 === 0 && cachedTokens2 === 0) {
+          const cacheCreationTokens2 = toSafeNumber6(
+            usage.input_cache_creation ?? usage.inputCacheCreation
+          );
+          if (inputTokens2 === 0 && outputTokens2 === 0 && cachedTokens2 === 0 && cacheCreationTokens2 === 0) {
             continue;
           }
           sessionEvents.push({
@@ -2637,7 +3049,8 @@ var KimiCodeParser = class {
             inputTokens: inputTokens2,
             outputTokens: outputTokens2,
             reasoningTokens: 0,
-            cachedTokens: cachedTokens2
+            cachedTokens: cachedTokens2,
+            cacheCreationTokens: cacheCreationTokens2
           });
           continue;
         }
@@ -2666,11 +3079,13 @@ var KimiCodeParser = class {
         if (obj.type !== "StatusUpdate") continue;
         const tokenUsage = payload.token_usage;
         if (!tokenUsage || !timestamp) continue;
-        const inputTokens = toSafeNumber7(tokenUsage.input_other);
-        const outputTokens = toSafeNumber7(tokenUsage.output);
-        const cachedTokens = toSafeNumber7(tokenUsage.input_cache_read);
-        const cacheCreateTokens = toSafeNumber7(tokenUsage.input_cache_creation);
-        if (inputTokens === 0 && outputTokens === 0 && cachedTokens === 0 && cacheCreateTokens === 0) {
+        const inputTokens = toSafeNumber6(tokenUsage.input_other);
+        const outputTokens = toSafeNumber6(tokenUsage.output);
+        const cachedTokens = toSafeNumber6(tokenUsage.input_cache_read);
+        const cacheCreationTokens = toSafeNumber6(
+          tokenUsage.input_cache_creation
+        );
+        if (inputTokens === 0 && outputTokens === 0 && cachedTokens === 0 && cacheCreationTokens === 0) {
           continue;
         }
         if (payload.message_id) {
@@ -2695,7 +3110,8 @@ var KimiCodeParser = class {
           inputTokens,
           outputTokens,
           reasoningTokens: 0,
-          cachedTokens
+          cachedTokens,
+          cacheCreationTokens
         });
       }
     }
@@ -2705,23 +3121,23 @@ var KimiCodeParser = class {
     };
   }
   isInstalled() {
-    return existsSync14(this.sessionsDir);
+    return existsSync16(this.sessionsDir);
   }
 };
 registerParser(new KimiCodeParser());
 
 // src/parsers/letcode.ts
-import { existsSync as existsSync15 } from "fs";
-import { homedir as homedir14 } from "os";
-import { basename as basename5, join as join15 } from "path";
+import { existsSync as existsSync17 } from "fs";
+import { homedir as homedir15 } from "os";
+import { basename as basename6, join as join16 } from "path";
 var TOOL_ID10 = "letcode";
-var TOOL_NAME10 = "LetCode";
-var DEFAULT_CONFIG_DIR = join15(homedir14(), ".config", "letcode");
-var DEFAULT_SESSIONS_DIR4 = join15(DEFAULT_CONFIG_DIR, "sessions");
+var TOOL_NAME9 = "LetCode";
+var DEFAULT_CONFIG_DIR = join16(homedir15(), ".config", "letcode");
+var DEFAULT_SESSIONS_DIR4 = join16(DEFAULT_CONFIG_DIR, "sessions");
 function getLetcodeSessionsDirs(env = process.env) {
   const dirs = [
     env.TOKEN_ARENA_LETCODE_DIR,
-    env.XDG_CONFIG_HOME ? join15(env.XDG_CONFIG_HOME, "letcode", "sessions") : void 0,
+    env.XDG_CONFIG_HOME ? join16(env.XDG_CONFIG_HOME, "letcode", "sessions") : void 0,
     DEFAULT_SESSIONS_DIR4
   ].filter((value) => Boolean(value));
   return Array.from(new Set(dirs));
@@ -2776,7 +3192,7 @@ var LetcodeParser = class {
     this.sessionsDirs = sessionsDir ? [sessionsDir] : getLetcodeSessionsDirs();
     this.tool = {
       id: TOOL_ID10,
-      name: TOOL_NAME10,
+      name: TOOL_NAME9,
       dataDir: this.sessionsDirs[0] ?? DEFAULT_SESSIONS_DIR4
     };
   }
@@ -2790,7 +3206,7 @@ var LetcodeParser = class {
         if (!content) continue;
         const rows = parseJsonl(content);
         if (rows.length === 0) continue;
-        const fallbackSessionId = extractSessionId(filePath) || basename5(filePath);
+        const fallbackSessionId = extractSessionId(filePath) || basename6(filePath);
         for (const row of rows) {
           const sessionId = typeof row.session_id === "string" && row.session_id ? row.session_id : fallbackSessionId;
           const timestamp = parseTimestamp2(row.timestamp_ms);
@@ -2851,31 +3267,31 @@ var LetcodeParser = class {
     };
   }
   isInstalled() {
-    return this.sessionsDirs.some((dir) => existsSync15(dir));
+    return this.sessionsDirs.some((dir) => existsSync17(dir));
   }
 };
 registerParser(new LetcodeParser());
 
 // src/parsers/droid.ts
-import { existsSync as existsSync16, readdirSync as readdirSync8 } from "fs";
-import { homedir as homedir15 } from "os";
-import { basename as basename6, dirname as dirname3, join as join16 } from "path";
+import { existsSync as existsSync18, readdirSync as readdirSync8 } from "fs";
+import { homedir as homedir16 } from "os";
+import { basename as basename7, dirname as dirname3, join as join17 } from "path";
 var TOOL_ID11 = "droid";
-var TOOL_NAME11 = "Droid";
-var DEFAULT_DATA_DIR5 = join16(homedir15(), ".factory", "sessions");
-function createToolDefinition7(dataDir) {
+var TOOL_NAME10 = "Droid";
+var DEFAULT_DATA_DIR5 = join17(homedir16(), ".factory", "sessions");
+function createToolDefinition6(dataDir) {
   return {
     id: TOOL_ID11,
-    name: TOOL_NAME11,
+    name: TOOL_NAME10,
     dataDir
   };
 }
 function findSessionFiles3(dir) {
   const results = [];
-  if (!existsSync16(dir)) return results;
+  if (!existsSync18(dir)) return results;
   try {
     for (const entry of readdirSync8(dir, { withFileTypes: true })) {
-      const fullPath = join16(dir, entry.name);
+      const fullPath = join17(dir, entry.name);
       if (entry.isDirectory()) {
         results.push(...findSessionFiles3(fullPath));
       } else if (entry.isFile() && entry.name.endsWith(".jsonl") && !entry.name.endsWith(".settings.json")) {
@@ -2890,14 +3306,14 @@ function extractDroidProject(slug) {
   const parts = slug.split("-").filter(Boolean);
   return parts.length > 0 ? parts[parts.length - 1] : "unknown";
 }
-function toSafeNumber8(value) {
+function toSafeNumber7(value) {
   const numberValue = Number(value);
   return Number.isFinite(numberValue) ? numberValue : 0;
 }
 var DroidParser = class {
   constructor(dataDir = DEFAULT_DATA_DIR5) {
     this.dataDir = dataDir;
-    this.tool = createToolDefinition7(dataDir);
+    this.tool = createToolDefinition6(dataDir);
   }
   dataDir;
   tool;
@@ -2910,7 +3326,7 @@ var DroidParser = class {
     const sessionEvents = [];
     for (const filePath of sessionFiles) {
       const sessionId = filePath;
-      const project = extractDroidProject(basename6(dirname3(filePath)));
+      const project = extractDroidProject(basename7(dirname3(filePath)));
       let firstMessageTimestamp = null;
       const content = readFileSafe(filePath);
       if (!content) continue;
@@ -2938,9 +3354,9 @@ var DroidParser = class {
           role
         });
       }
-      const settingsPath = join16(
+      const settingsPath = join17(
         dirname3(filePath),
-        `${basename6(filePath, ".jsonl")}.settings.json`
+        `${basename7(filePath, ".jsonl")}.settings.json`
       );
       const settingsContent = readFileSafe(settingsPath);
       if (!settingsContent || firstMessageTimestamp === null) continue;
@@ -2952,15 +3368,15 @@ var DroidParser = class {
       }
       const tokenUsage = settings.tokenUsage;
       if (!tokenUsage) continue;
-      const cachedTokens = toSafeNumber8(tokenUsage.cacheReadTokens);
-      const reasoningTokens = toSafeNumber8(tokenUsage.thinkingTokens);
+      const cachedTokens = toSafeNumber7(tokenUsage.cacheReadTokens);
+      const reasoningTokens = toSafeNumber7(tokenUsage.thinkingTokens);
       const inputTokens = Math.max(
         0,
-        toSafeNumber8(tokenUsage.inputTokens) - cachedTokens
+        toSafeNumber7(tokenUsage.inputTokens) - cachedTokens
       );
       const outputTokens = Math.max(
         0,
-        toSafeNumber8(tokenUsage.outputTokens) - reasoningTokens
+        toSafeNumber7(tokenUsage.outputTokens) - reasoningTokens
       );
       if (inputTokens === 0 && outputTokens === 0 && cachedTokens === 0 && reasoningTokens === 0) {
         continue;
@@ -2983,30 +3399,31 @@ var DroidParser = class {
     };
   }
   isInstalled() {
-    return existsSync16(this.dataDir);
+    return existsSync18(this.dataDir);
   }
 };
 registerParser(new DroidParser());
 
 // src/parsers/pi-coding-agent.ts
-import { existsSync as existsSync17 } from "fs";
-import { homedir as homedir16 } from "os";
-import { join as join17 } from "path";
+import { createHash as createHash4 } from "crypto";
+import { existsSync as existsSync19, statSync as statSync2 } from "fs";
+import { homedir as homedir17 } from "os";
+import { join as join18 } from "path";
 var TOOL_ID12 = "pi-coding-agent";
-var TOOL_NAME12 = "pi";
-var DEFAULT_SESSIONS_DIR5 = join17(homedir16(), ".pi", "agent", "sessions");
-function createToolDefinition8(dataDir) {
+var TOOL_NAME11 = "pi";
+var DEFAULT_SESSIONS_DIR5 = join18(homedir17(), ".pi", "agent", "sessions");
+function createToolDefinition7(dataDir) {
   return {
     id: TOOL_ID12,
-    name: TOOL_NAME12,
+    name: TOOL_NAME11,
     dataDir
   };
 }
-function toSafeNumber9(value) {
+function toSafeNumber8(value) {
   const numberValue = Number(value);
-  return Number.isFinite(numberValue) ? numberValue : 0;
+  return Number.isFinite(numberValue) && numberValue >= 0 ? Math.trunc(numberValue) : 0;
 }
-function getPathLeaf7(value) {
+function getPathLeaf6(value) {
   const normalized = value.replace(/\\/g, "/").replace(/\/+$/, "");
   const leaf = normalized.split("/").filter(Boolean).pop();
   return leaf || "unknown";
@@ -3017,15 +3434,55 @@ function normalizeForPrefix4(value) {
 function getUsageNumber3(usage, ...keys) {
   for (const key of keys) {
     const value = usage[key];
-    const numberValue = toSafeNumber9(value);
-    if (numberValue > 0) {
-      return numberValue;
+    if (value !== void 0 && value !== null) {
+      return toSafeNumber8(value);
     }
   }
   return 0;
 }
+function parseTimestamp3(value) {
+  if (value === void 0) return null;
+  const timestamp = new Date(
+    typeof value === "number" && Math.abs(value) <= 1e11 ? value * 1e3 : value
+  );
+  return Number.isNaN(timestamp.getTime()) ? null : timestamp;
+}
+function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+function usageIdentity(row, kind, usage) {
+  const message = row.message;
+  const semantic = createHash4("sha256").update(
+    canonicalJson({
+      kind,
+      timestamp: row.timestamp,
+      messageTimestamp: message?.timestamp,
+      provider: message?.provider,
+      model: message?.model,
+      responseModel: message?.responseModel,
+      responseId: message?.responseId,
+      api: message?.api,
+      toolCallId: message?.toolCallId,
+      toolName: message?.toolName,
+      stopReason: message?.stopReason,
+      errorMessage: message?.errorMessage,
+      content: message?.content,
+      summary: row.summary,
+      usage
+    })
+  ).digest("hex");
+  return {
+    semantic,
+    request: row.id ? JSON.stringify([kind, row.id, row.timestamp]) : semantic,
+    hasId: Boolean(row.id)
+  };
+}
 function extractPiProjectFromCwd(cwd) {
-  return getPathLeaf7(cwd);
+  return getPathLeaf6(cwd);
 }
 function extractPiProjectFromDir(filePath, sessionsDir = DEFAULT_SESSIONS_DIR5) {
   const normalizedFilePath = normalizeForPrefix4(filePath);
@@ -3042,7 +3499,7 @@ function extractPiProjectFromDir(filePath, sessionsDir = DEFAULT_SESSIONS_DIR5)
   try {
     const decoded = decodeURIComponent(firstSegment);
     if (decoded.includes("/") || decoded.includes("\\")) {
-      return getPathLeaf7(decoded);
+      return getPathLeaf6(decoded);
     }
   } catch {
   }
@@ -3052,7 +3509,7 @@ function extractPiProjectFromDir(filePath, sessionsDir = DEFAULT_SESSIONS_DIR5)
 var PiCodingAgentParser = class {
   constructor(sessionsDir = DEFAULT_SESSIONS_DIR5) {
     this.sessionsDir = sessionsDir;
-    this.tool = createToolDefinition8(sessionsDir);
+    this.tool = createToolDefinition7(sessionsDir);
   }
   sessionsDir;
   tool;
@@ -3063,7 +3520,9 @@ var PiCodingAgentParser = class {
     }
     const entries = [];
     const sessionEvents = [];
-    const seenEntryIds = /* @__PURE__ */ new Set();
+    const seenRequests = /* @__PURE__ */ new Set();
+    const seenSemantics = /* @__PURE__ */ new Set();
+    const legacySemantics = /* @__PURE__ */ new Set();
     for (const filePath of sessionFiles) {
       const content = readFileSafe(filePath);
       if (!content) continue;
@@ -3071,7 +3530,9 @@ var PiCodingAgentParser = class {
       if (rows.length === 0) continue;
       let sessionId = filePath;
       let project = extractPiProjectFromDir(filePath, this.sessionsDir);
+      let sessionTimestamp = null;
       for (const row of rows) {
+        if (!row || typeof row !== "object") continue;
         if (row.type !== "session") continue;
         if (row.id) {
           sessionId = row.id;
@@ -3079,59 +3540,107 @@ var PiCodingAgentParser = class {
         if (row.cwd) {
           project = extractPiProjectFromCwd(row.cwd);
         }
+        sessionTimestamp = parseTimestamp3(row.timestamp);
         break;
       }
+      let fallbackTimestamp = sessionTimestamp;
+      if (!fallbackTimestamp) {
+        try {
+          fallbackTimestamp = statSync2(filePath).mtime;
+        } catch {
+        }
+      }
       for (const row of rows) {
-        if (row.type !== "message") continue;
+        if (!row || typeof row !== "object") continue;
         const message = row.message;
-        if (!message) continue;
-        const rawTimestamp = row.timestamp || message.timestamp;
-        if (!rawTimestamp) continue;
-        const timestamp = new Date(rawTimestamp);
-        if (Number.isNaN(timestamp.getTime())) continue;
-        if (message.role === "user" || message.role === "assistant") {
+        const timestamp = parseTimestamp3(row.timestamp) ?? parseTimestamp3(message?.timestamp) ?? fallbackTimestamp;
+        if (!timestamp) continue;
+        if (row.type === "message" && message?.role === "user") {
           sessionEvents.push({
             sessionId,
             source: TOOL_ID12,
             project,
             timestamp,
-            role: message.role
+            role: "user"
           });
+          continue;
+        }
+        const kind = row.type === "message" ? message?.role : row.type;
+        if (kind !== "assistant" && kind !== "toolResult" && kind !== "compaction" && kind !== "branch_summary")
+          continue;
+        const usage = row.type === "message" ? message?.usage : row.usage;
+        if (!usage) {
+          if (kind === "assistant")
+            sessionEvents.push({
+              sessionId,
+              source: TOOL_ID12,
+              project,
+              timestamp,
+              role: "assistant"
+            });
+          continue;
         }
-        if (message.role !== "assistant") continue;
-        const usage = message.usage;
-        if (!usage) continue;
         const inputTokens = getUsageNumber3(usage, "input", "inputTokens");
-        const outputTokens = getUsageNumber3(usage, "output", "outputTokens");
+        const rawOutput = getUsageNumber3(usage, "output", "outputTokens");
         const cachedTokens = getUsageNumber3(
           usage,
           "cacheRead",
           "cacheReadTokens",
           "cache_read"
         );
-        const reasoningTokens = getUsageNumber3(
+        const cacheCreationTokens = getUsageNumber3(
           usage,
-          "reasoningOutputTokens",
-          "thinkingTokens",
-          "thoughts"
+          "cacheWrite",
+          "cacheWriteTokens",
+          "cache_write"
         );
-        if (inputTokens === 0 && outputTokens === 0 && cachedTokens === 0 && reasoningTokens === 0) {
+        const reasoningTokens = Math.min(
+          rawOutput,
+          getUsageNumber3(
+            usage,
+            "reasoningOutputTokens",
+            "thinkingTokens",
+            "thoughts"
+          )
+        );
+        const outputTokens = rawOutput - reasoningTokens;
+        if (inputTokens === 0 && outputTokens === 0 && cachedTokens === 0 && cacheCreationTokens === 0 && reasoningTokens === 0) {
+          if (kind === "assistant")
+            sessionEvents.push({
+              sessionId,
+              source: TOOL_ID12,
+              project,
+              timestamp,
+              role: "assistant"
+            });
           continue;
         }
-        if (row.id) {
-          if (seenEntryIds.has(row.id)) continue;
-          seenEntryIds.add(row.id);
-        }
+        const identity = usageIdentity(row, kind, usage);
+        if (seenRequests.has(identity.request) || (identity.hasId ? legacySemantics : seenSemantics).has(
+          identity.semantic
+        ))
+          continue;
+        seenRequests.add(identity.request);
+        seenSemantics.add(identity.semantic);
+        if (!identity.hasId) legacySemantics.add(identity.semantic);
+        sessionEvents.push({
+          sessionId,
+          source: TOOL_ID12,
+          project,
+          timestamp,
+          role: "assistant"
+        });
         entries.push({
           sessionId,
           source: TOOL_ID12,
-          model: message.model || "unknown",
+          model: kind === "assistant" ? message?.responseModel || message?.model || "unknown" : "unknown",
           project,
           timestamp,
           inputTokens,
           outputTokens,
           reasoningTokens,
-          cachedTokens
+          cachedTokens,
+          cacheCreationTokens
         });
       }
     }
@@ -3141,27 +3650,27 @@ var PiCodingAgentParser = class {
     };
   }
   isInstalled() {
-    return existsSync17(this.sessionsDir);
+    return existsSync19(this.sessionsDir);
   }
 };
 registerParser(new PiCodingAgentParser());
 
 // src/parsers/qwenpaw.ts
-import { existsSync as existsSync18, readdirSync as readdirSync9 } from "fs";
-import { homedir as homedir17, hostname as hostname4 } from "os";
-import { join as join18 } from "path";
+import { existsSync as existsSync20, readdirSync as readdirSync9 } from "fs";
+import { homedir as homedir18, hostname as hostname4 } from "os";
+import { join as join19 } from "path";
 var TOOL_ID13 = "qwenpaw";
-var TOOL_NAME13 = "QwenPaw";
-var DEFAULT_USAGE_PATH = join18(homedir17(), ".qwenpaw", "token_usage.json");
-var DEFAULT_WORKSPACE_PATH = join18(homedir17(), ".qwenpaw", "workspace");
-function createToolDefinition9(usagePath) {
+var TOOL_NAME12 = "QwenPaw";
+var DEFAULT_USAGE_PATH = join19(homedir18(), ".qwenpaw", "token_usage.json");
+var DEFAULT_WORKSPACE_PATH = join19(homedir18(), ".qwenpaw", "workspace");
+function createToolDefinition8(usagePath) {
   return {
     id: TOOL_ID13,
-    name: TOOL_NAME13,
+    name: TOOL_NAME12,
     dataDir: usagePath
   };
 }
-function toSafeNumber10(value) {
+function toSafeNumber9(value) {
   const numberValue = Number(value);
   return Number.isFinite(numberValue) && numberValue > 0 ? numberValue : 0;
 }
@@ -3190,7 +3699,7 @@ var QwenPawParser = class {
   constructor(options = {}) {
     this.usagePath = options.usagePath || DEFAULT_USAGE_PATH;
     this.workspacePath = options.workspacePath || DEFAULT_WORKSPACE_PATH;
-    this.tool = createToolDefinition9(this.usagePath);
+    this.tool = createToolDefinition8(this.usagePath);
   }
   async parse() {
     const entries = [];
@@ -3208,8 +3717,8 @@ var QwenPawParser = class {
             if (!record || typeof record !== "object") {
               continue;
             }
-            const inputTokens = toSafeNumber10(record.prompt_tokens);
-            const outputTokens = toSafeNumber10(record.completion_tokens);
+            const inputTokens = toSafeNumber9(record.prompt_tokens);
+            const outputTokens = toSafeNumber9(record.completion_tokens);
             if (inputTokens === 0 && outputTokens === 0) {
               continue;
             }
@@ -3237,15 +3746,15 @@ var QwenPawParser = class {
   }
   async parseWorkspaceSessions() {
     const events = [];
-    if (!existsSync18(this.workspacePath)) {
+    if (!existsSync20(this.workspacePath)) {
       return events;
     }
     try {
       const workspaceDirs = readdirSync9(this.workspacePath);
       for (const workspaceDir of workspaceDirs) {
-        const workspacePath = join18(this.workspacePath, workspaceDir);
-        const chatsPath = join18(workspacePath, "chats.json");
-        const sessionsPath = join18(workspacePath, "sessions");
+        const workspacePath = join19(this.workspacePath, workspaceDir);
+        const chatsPath = join19(workspacePath, "chats.json");
+        const sessionsPath = join19(workspacePath, "sessions");
         const chatsContent = readFileSafe(chatsPath);
         if (!chatsContent) {
           continue;
@@ -3289,7 +3798,7 @@ var QwenPawParser = class {
   }
   getSessionFiles(sessionsPath) {
     const files = /* @__PURE__ */ new Map();
-    if (!existsSync18(sessionsPath)) {
+    if (!existsSync20(sessionsPath)) {
       return files;
     }
     try {
@@ -3298,7 +3807,7 @@ var QwenPawParser = class {
         if (!fileName.endsWith(".json")) {
           continue;
         }
-        const filePath = join18(sessionsPath, fileName);
+        const filePath = join19(sessionsPath, fileName);
         const content = readFileSafe(filePath);
         if (content) {
           const sessionId = fileName.replace(/^[^_]+_/, "").replace(".json", "");
@@ -3396,15 +3905,15 @@ var QwenPawParser = class {
     });
   }
   isInstalled() {
-    return existsSync18(this.usagePath) || existsSync18(this.workspacePath);
+    return existsSync20(this.usagePath) || existsSync20(this.workspacePath);
   }
 };
 registerParser(new QwenPawParser());
 
 // src/parsers/cline.ts
-import { readFileSync as readFileSync6, statSync as statSync2 } from "fs";
-import { homedir as homedir18 } from "os";
-import { basename as basename7, join as join19 } from "path";
+import { readFileSync as readFileSync6, statSync as statSync3 } from "fs";
+import { homedir as homedir19 } from "os";
+import { basename as basename8, join as join20 } from "path";
 var EXTENSION_ID = "saoudrizwan.claude-dev";
 var HOSTS = [
   "Code",
@@ -3418,28 +3927,28 @@ var HOSTS = [
 var TOOL6 = {
   id: "cline",
   name: "Cline",
-  dataDir: join19(homedir18(), ".cline")
+  dataDir: join20(homedir19(), ".cline")
 };
 function getHostRoots() {
   const out = [];
   if (process.platform === "darwin") {
-    const base = join19(homedir18(), "Library", "Application Support");
-    for (const h of HOSTS) out.push(join19(base, h));
+    const base = join20(homedir19(), "Library", "Application Support");
+    for (const h of HOSTS) out.push(join20(base, h));
   } else if (process.platform === "win32") {
-    const appData = process.env.APPDATA?.trim() || join19(homedir18(), "AppData", "Roaming");
-    for (const h of HOSTS) out.push(join19(appData, h));
+    const appData = process.env.APPDATA?.trim() || join20(homedir19(), "AppData", "Roaming");
+    for (const h of HOSTS) out.push(join20(appData, h));
   } else {
-    const xdg = process.env.XDG_CONFIG_HOME?.trim() || join19(homedir18(), ".config");
-    for (const h of HOSTS) out.push(join19(xdg, h));
+    const xdg = process.env.XDG_CONFIG_HOME?.trim() || join20(homedir19(), ".config");
+    for (const h of HOSTS) out.push(join20(xdg, h));
   }
   return out;
 }
 function findClineExtensionDirs() {
   const dirs = [];
   for (const root of getHostRoots()) {
-    const ext = join19(root, "User", "globalStorage", EXTENSION_ID);
+    const ext = join20(root, "User", "globalStorage", EXTENSION_ID);
     try {
-      if (statSync2(ext).isDirectory()) dirs.push(ext);
+      if (statSync3(ext).isDirectory()) dirs.push(ext);
     } catch {
     }
   }
@@ -3455,7 +3964,7 @@ function readJsonSafe(path) {
 function projectFromPath(absPath) {
   if (!absPath || typeof absPath !== "string") return "unknown";
   const trimmed = absPath.replace(/[\\/]+$/, "");
-  const name = basename7(trimmed);
+  const name = basename8(trimmed);
   return name || "unknown";
 }
 var ClineParser = class {
@@ -3469,7 +3978,7 @@ var ClineParser = class {
     const entries = [];
     const sessionEvents = [];
     for (const extDir of extDirs) {
-      const history = readJsonSafe(join19(extDir, "state", "taskHistory.json"));
+      const history = readJsonSafe(join20(extDir, "state", "taskHistory.json"));
       if (!Array.isArray(history)) continue;
       for (const item of history) {
         try {
@@ -3480,7 +3989,7 @@ var ClineParser = class {
           );
           const fallbackModel = item.modelId && String(item.modelId).trim() || "cline-unknown";
           const messages = readJsonSafe(
-            join19(extDir, "tasks", taskId, "ui_messages.json")
+            join20(extDir, "tasks", taskId, "ui_messages.json")
           );
           if (!Array.isArray(messages)) continue;
           for (const msg of messages) {
@@ -3511,10 +4020,11 @@ var ClineParser = class {
                 model,
                 project,
                 timestamp,
-                inputTokens: inputTokens + cacheWrites,
+                inputTokens,
                 outputTokens,
                 reasoningTokens: 0,
-                cachedTokens: cacheReads
+                cachedTokens: cacheReads,
+                cacheCreationTokens: cacheWrites
               });
             }
             if (msgType === "ask" || msgType === "say" && msgSay === "user_feedback") {
@@ -3551,20 +4061,20 @@ registerParser(new ClineParser());
 import { execFileSync as execFileSync3 } from "child_process";
 import {
   copyFileSync,
-  existsSync as existsSync19,
+  existsSync as existsSync21,
   mkdtempSync,
   readdirSync as readdirSync10,
   readFileSync as readFileSync7,
   rmSync,
-  statSync as statSync3
+  statSync as statSync4
 } from "fs";
-import { homedir as homedir19, tmpdir } from "os";
-import { join as join20, resolve } from "path";
-var KIROAGENT_RELATIVE = join20("User", "globalStorage", "kiro.kiroagent");
+import { homedir as homedir20, tmpdir } from "os";
+import { join as join21, resolve } from "path";
+var KIROAGENT_RELATIVE = join21("User", "globalStorage", "kiro.kiroagent");
 function getDefaultBasePath() {
   if (process.platform === "darwin") {
-    return join20(
-      homedir19(),
+    return join21(
+      homedir20(),
       "Library",
       "Application Support",
       "Kiro",
@@ -3572,11 +4082,11 @@ function getDefaultBasePath() {
     );
   }
   if (process.platform === "win32") {
-    const appData = process.env.APPDATA?.trim() || join20(homedir19(), "AppData", "Roaming");
-    return join20(appData, "Kiro", KIROAGENT_RELATIVE);
+    const appData = process.env.APPDATA?.trim() || join21(homedir20(), "AppData", "Roaming");
+    return join21(appData, "Kiro", KIROAGENT_RELATIVE);
   }
-  const xdgConfigHome = process.env.XDG_CONFIG_HOME?.trim() || join20(homedir19(), ".config");
-  return join20(xdgConfigHome, "Kiro", KIROAGENT_RELATIVE);
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME?.trim() || join21(homedir20(), ".config");
+  return join21(xdgConfigHome, "Kiro", KIROAGENT_RELATIVE);
 }
 var TOOL7 = {
   id: "kiro",
@@ -3587,10 +4097,10 @@ function getKiroBasePath() {
   const explicit = process.env.KIRO_BASE_PATH?.trim();
   if (explicit) {
     const r = resolve(explicit);
-    return existsSync19(r) ? r : null;
+    return existsSync21(r) ? r : null;
   }
   const def = getDefaultBasePath();
-  return existsSync19(def) ? def : null;
+  return existsSync21(def) ? def : null;
 }
 function isLockError(err) {
   return err instanceof Error && typeof err.message === "string" && /database is locked/i.test(err.message);
@@ -3611,12 +4121,12 @@ function readDb(dbPath) {
     return queryDb(dbPath, TOKENS_SQL);
   } catch (err) {
     if (!isLockError(err)) throw err;
-    const snapshotDir = mkdtempSync(join20(tmpdir(), "vibe-usage-kiro-"));
-    const queryPath = join20(snapshotDir, "devdata.sqlite");
+    const snapshotDir = mkdtempSync(join21(tmpdir(), "vibe-usage-kiro-"));
+    const queryPath = join21(snapshotDir, "devdata.sqlite");
     copyFileSync(dbPath, queryPath);
     for (const suffix of ["-shm", "-wal"]) {
       const companion = `${dbPath}${suffix}`;
-      if (existsSync19(companion))
+      if (existsSync21(companion))
         copyFileSync(companion, `${queryPath}${suffix}`);
     }
     try {
@@ -3637,7 +4147,7 @@ function readJsonl(jsonlPath) {
   if (lines.length === 0) return [];
   let mtime;
   try {
-    mtime = statSync3(jsonlPath).mtime;
+    mtime = statSync4(jsonlPath).mtime;
   } catch {
     mtime = /* @__PURE__ */ new Date();
   }
@@ -3668,7 +4178,7 @@ function buildModelTimeline(base) {
   }
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.name === "dev_data") continue;
-    const dirPath = join20(base, entry.name);
+    const dirPath = join21(base, entry.name);
     let files;
     try {
       files = readdirSync10(dirPath).filter((f) => f.endsWith(".chat"));
@@ -3677,7 +4187,7 @@ function buildModelTimeline(base) {
     }
     for (const file of files) {
       try {
-        const data = JSON.parse(readFileSync7(join20(dirPath, file), "utf-8"));
+        const data = JSON.parse(readFileSync7(join21(dirPath, file), "utf-8"));
         const meta = data?.metadata;
         if (!meta?.modelId || !meta?.startTime) continue;
         const startMs = Number(meta.startTime);
@@ -3726,13 +4236,13 @@ var KiroParser = class {
   async parse() {
     const base = getKiroBasePath();
     if (!base) return { buckets: [], sessions: [] };
-    const dbPath = join20(base, "dev_data", "devdata.sqlite");
-    const jsonlPath = join20(base, "dev_data", "tokens_generated.jsonl");
+    const dbPath = join21(base, "dev_data", "devdata.sqlite");
+    const jsonlPath = join21(base, "dev_data", "tokens_generated.jsonl");
     let rows;
     try {
-      if (existsSync19(dbPath)) {
+      if (existsSync21(dbPath)) {
         rows = readDb(dbPath);
-      } else if (existsSync19(jsonlPath)) {
+      } else if (existsSync21(jsonlPath)) {
         rows = readJsonl(jsonlPath);
       } else {
         return { buckets: [], sessions: [] };
@@ -3782,9 +4292,9 @@ var KiroParser = class {
 registerParser(new KiroParser());
 
 // src/parsers/roo-code.ts
-import { readdirSync as readdirSync11, readFileSync as readFileSync8, statSync as statSync4 } from "fs";
-import { homedir as homedir20 } from "os";
-import { basename as basename8, join as join21 } from "path";
+import { readdirSync as readdirSync11, readFileSync as readFileSync8, statSync as statSync5 } from "fs";
+import { homedir as homedir21 } from "os";
+import { basename as basename9, join as join22 } from "path";
 var EXTENSION_ID2 = "rooveterinaryinc.roo-cline";
 var HOSTS2 = [
   "Code",
@@ -3799,17 +4309,17 @@ function getHostRoots2() {
   const out = [];
   let roots;
   if (process.platform === "darwin") {
-    roots = [join21(homedir20(), "Library", "Application Support")];
+    roots = [join22(homedir21(), "Library", "Application Support")];
   } else if (process.platform === "win32") {
     roots = [
-      process.env.APPDATA?.trim() || join21(homedir20(), "AppData", "Roaming")
+      process.env.APPDATA?.trim() || join22(homedir21(), "AppData", "Roaming")
     ];
   } else {
-    roots = [process.env.XDG_CONFIG_HOME?.trim() || join21(homedir20(), ".config")];
+    roots = [process.env.XDG_CONFIG_HOME?.trim() || join22(homedir21(), ".config")];
   }
   for (const root of roots) {
     for (const h of HOSTS2) {
-      out.push(join21(root, h));
+      out.push(join22(root, h));
     }
   }
   return out;
@@ -3817,9 +4327,9 @@ function getHostRoots2() {
 function findExtensionDirs() {
   const dirs = [];
   for (const root of getHostRoots2()) {
-    const ext = join21(root, "User", "globalStorage", EXTENSION_ID2);
+    const ext = join22(root, "User", "globalStorage", EXTENSION_ID2);
     try {
-      if (statSync4(ext).isDirectory()) dirs.push(ext);
+      if (statSync5(ext).isDirectory()) dirs.push(ext);
     } catch {
     }
   }
@@ -3835,13 +4345,13 @@ function readJsonSafe2(path) {
 function projectFromPath2(absPath) {
   if (!absPath || typeof absPath !== "string") return "unknown";
   const trimmed = absPath.replace(/[\\/]+$/, "");
-  const name = basename8(trimmed);
+  const name = basename9(trimmed);
   return name || "unknown";
 }
 function readHistoryItems(extDir) {
-  const tasksDir = join21(extDir, "tasks");
+  const tasksDir = join22(extDir, "tasks");
   const index = readJsonSafe2(
-    join21(tasksDir, "_index.json")
+    join22(tasksDir, "_index.json")
   );
   if (index?.entries && Array.isArray(index.entries)) return index.entries;
   const items = [];
@@ -3855,7 +4365,7 @@ function readHistoryItems(extDir) {
     if (!entry.isDirectory() || entry.name.startsWith("_") || entry.name.startsWith("."))
       continue;
     const item = readJsonSafe2(
-      join21(tasksDir, entry.name, "history_item.json")
+      join22(tasksDir, entry.name, "history_item.json")
     );
     if (item && typeof item === "object") items.push(item);
   }
@@ -3882,7 +4392,7 @@ var RooCodeParser = class {
         const project = projectFromPath2(item.workspace);
         const fallbackModel = item.apiConfigName && String(item.apiConfigName).trim() || "roo-unknown";
         const messages = readJsonSafe2(
-          join21(extDir, "tasks", taskId, "ui_messages.json")
+          join22(extDir, "tasks", taskId, "ui_messages.json")
         );
         if (!Array.isArray(messages)) continue;
         for (const msg of messages) {
@@ -3910,10 +4420,11 @@ var RooCodeParser = class {
               model,
               project,
               timestamp,
-              inputTokens: inputTokens + cacheWrites,
+              inputTokens,
               outputTokens,
               reasoningTokens: 0,
-              cachedTokens: cacheReads
+              cachedTokens: cacheReads,
+              cacheCreationTokens: cacheWrites
             });
             events.push({
               sessionId: taskId,
@@ -3946,10 +4457,10 @@ var RooCodeParser = class {
 registerParser(new RooCodeParser());
 
 // src/parsers/snow.ts
-import { existsSync as existsSync20 } from "fs";
-import { homedir as homedir21 } from "os";
-import { join as join22 } from "path";
-var DEFAULT_DATA_DIR6 = join22(homedir21(), ".snow", "usage");
+import { existsSync as existsSync22 } from "fs";
+import { homedir as homedir22 } from "os";
+import { join as join23 } from "path";
+var DEFAULT_DATA_DIR6 = join23(homedir22(), ".snow", "usage");
 function toNonNegativeNumber2(value) {
   const numberValue = Number(value);
   return Number.isFinite(numberValue) && numberValue >= 0 ? numberValue : 0;
@@ -3996,26 +4507,26 @@ var SnowParser = class {
     return { buckets: aggregateToBuckets(entries), sessions: [] };
   }
   isInstalled() {
-    return existsSync20(this.dataDir);
+    return existsSync22(this.dataDir);
   }
 };
 registerParser(new SnowParser());
 
 // src/parsers/cursor.ts
 import { execFileSync as execFileSync4 } from "child_process";
-import { copyFileSync as copyFileSync2, existsSync as existsSync21, mkdtempSync as mkdtempSync2, rmSync as rmSync2 } from "fs";
-import { homedir as homedir22, tmpdir as tmpdir2 } from "os";
-import { dirname as dirname4, join as join23, resolve as resolve2 } from "path";
+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";
-var TOOL_NAME14 = "Cursor";
-var STATE_DB_RELATIVE = join23("User", "globalStorage", "state.vscdb");
+var TOOL_NAME13 = "Cursor";
+var STATE_DB_RELATIVE = join24("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 join23(
-      homedir22(),
+    return join24(
+      homedir23(),
       "Library",
       "Application Support",
       "Cursor",
@@ -4023,25 +4534,25 @@ function getDefaultStateDbPath() {
     );
   }
   if (process.platform === "win32") {
-    const appData = process.env.APPDATA?.trim() || join23(homedir22(), "AppData", "Roaming");
-    return join23(appData, "Cursor", STATE_DB_RELATIVE);
+    const appData = process.env.APPDATA?.trim() || join24(homedir23(), "AppData", "Roaming");
+    return join24(appData, "Cursor", STATE_DB_RELATIVE);
   }
-  const xdgConfigHome = process.env.XDG_CONFIG_HOME?.trim() || join23(homedir22(), ".config");
-  return join23(xdgConfigHome, "Cursor", STATE_DB_RELATIVE);
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME?.trim() || join24(homedir23(), ".config");
+  return join24(xdgConfigHome, "Cursor", STATE_DB_RELATIVE);
 }
 function getCursorStateDbPath() {
   const explicit = process.env.CURSOR_STATE_DB_PATH?.trim();
   if (explicit) {
     const resolved = resolve2(explicit);
-    return existsSync21(resolved) ? resolved : null;
+    return existsSync23(resolved) ? resolved : null;
   }
   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 : join23(r, STATE_DB_RELATIVE);
+    return r.endsWith(".vscdb") ? r : join24(r, STATE_DB_RELATIVE);
   }) : [getDefaultStateDbPath()];
   for (const c of candidates) {
-    if (existsSync21(c)) return c;
+    if (existsSync23(c)) return c;
   }
   return null;
 }
@@ -4081,13 +4592,13 @@ function readAccessToken(dbPath) {
     return queryAccessToken(dbPath);
   } catch (err) {
     if (!isLockError2(err)) throw err;
-    const snapshotDir = mkdtempSync2(join23(tmpdir2(), "tokenarena-cursor-"));
-    const queryPath = join23(snapshotDir, "state.vscdb");
+    const snapshotDir = mkdtempSync2(join24(tmpdir2(), "tokenarena-cursor-"));
+    const queryPath = join24(snapshotDir, "state.vscdb");
     try {
       copyFileSync2(dbPath, queryPath);
       for (const suffix of ["-shm", "-wal"]) {
         const companion = `${dbPath}${suffix}`;
-        if (existsSync21(companion))
+        if (existsSync23(companion))
           copyFileSync2(companion, `${queryPath}${suffix}`);
       }
       return queryAccessToken(queryPath);
@@ -4213,10 +4724,10 @@ function parseInt0(value) {
   const n = Number(String(value).replace(/,/g, "").trim());
   return Number.isFinite(n) && n > 0 ? Math.round(n) : 0;
 }
-function createToolDefinition10(dbPath) {
+function createToolDefinition9(dbPath) {
   return {
     id: TOOL_ID14,
-    name: TOOL_NAME14,
+    name: TOOL_NAME13,
     dataDir: dirname4(dbPath)
   };
 }
@@ -4229,10 +4740,10 @@ var CursorParser = class {
     this.dbPath = options.dbPath || getCursorStateDbPath() || "";
     this.readToken = options.readToken || readAccessToken;
     this.fetchCsv = options.fetchCsv || fetchUsageCsv;
-    this.tool = createToolDefinition10(this.dbPath);
+    this.tool = createToolDefinition9(this.dbPath);
   }
   async parse() {
-    if (!this.dbPath || !existsSync21(this.dbPath)) {
+    if (!this.dbPath || !existsSync23(this.dbPath)) {
       return { buckets: [], sessions: [] };
     }
     let token;
@@ -4283,9 +4794,10 @@ var CursorParser = class {
         model,
         project: "unknown",
         timestamp,
-        inputTokens: inputCacheWrite + inputNoCache,
+        inputTokens: inputNoCache,
         outputTokens: output,
         cachedTokens: cacheRead,
+        cacheCreationTokens: inputCacheWrite,
         reasoningTokens: 0
       });
     }
@@ -4295,19 +4807,19 @@ var CursorParser = class {
     };
   }
   isInstalled() {
-    return existsSync21(this.dbPath);
+    return existsSync23(this.dbPath);
   }
 };
 registerParser(new CursorParser());
 
 // src/parsers/zcode.ts
-import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync22 } from "fs";
-import { homedir as homedir23, hostname as hostname5 } from "os";
-import { dirname as dirname5, join as join24 } from "path";
+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";
-var TOOL_NAME15 = "ZCode";
-var DEFAULT_DB_PATH3 = join24(homedir23(), ".zcode", "cli", "db", "db.sqlite");
+var TOOL_NAME14 = "ZCode";
+var DEFAULT_DB_PATH3 = join25(homedir24(), ".zcode", "cli", "db", "db.sqlite");
 var MODEL_USAGE_QUERY = `SELECT
   model_usage.session_id as sessionId,
   session.directory as directory,
@@ -4340,14 +4852,14 @@ var TURN_USAGE_QUERY = `SELECT
   duration_ms as durationMs
   FROM turn_usage
   WHERE duration_ms IS NOT NULL`;
-function createToolDefinition11(dbPath) {
+function createToolDefinition10(dbPath) {
   return {
     id: TOOL_ID15,
-    name: TOOL_NAME15,
+    name: TOOL_NAME14,
     dataDir: dirname5(dbPath)
   };
 }
-function toSafeNumber11(value) {
+function toSafeNumber10(value) {
   const numberValue = Number(value);
   return Number.isFinite(numberValue) && numberValue > 0 ? numberValue : 0;
 }
@@ -4362,7 +4874,7 @@ function parseUnixMillis(value) {
   const timestamp = new Date(numberValue);
   return Number.isNaN(timestamp.getTime()) ? null : timestamp;
 }
-function getPathLeaf8(value) {
+function getPathLeaf7(value) {
   if (!value) {
     return "unknown";
   }
@@ -4447,7 +4959,7 @@ function buildSessions2(input2) {
     const draft = getOrCreateDraft(
       drafts,
       sessionId,
-      getPathLeaf8(getString3(row.directory))
+      getPathLeaf7(getString3(row.directory))
     );
     draft.fallbackFirstAt = parseUnixMillis(row.timeCreated);
     draft.fallbackLastAt = parseUnixMillis(row.timeUpdated);
@@ -4485,7 +4997,7 @@ function buildSessions2(input2) {
       continue;
     }
     const draft = getOrCreateDraft(drafts, sessionId, "unknown");
-    draft.activeSeconds += Math.round(toSafeNumber11(row.durationMs) / 1e3);
+    draft.activeSeconds += Math.round(toSafeNumber10(row.durationMs) / 1e3);
   }
   const usageBySession = buildSessionUsage3(input2.entries);
   const host = hostname5().replace(/\.local$/, "");
@@ -4530,7 +5042,7 @@ function buildSessions2(input2) {
     return {
       source: draft.source,
       project: draft.project,
-      sessionHash: createHash3("sha256").update(draft.sessionId).digest("hex").slice(0, 16),
+      sessionHash: createHash5("sha256").update(draft.sessionId).digest("hex").slice(0, 16),
       hostname: host,
       firstMessageAt: firstMessageAt.toISOString(),
       lastMessageAt: lastMessageAt.toISOString(),
@@ -4558,10 +5070,10 @@ var ZCodeParser = class {
   constructor(options = {}) {
     this.dbPath = options.dbPath || DEFAULT_DB_PATH3;
     this.queryRows = options.queryRows || readSqliteRows;
-    this.tool = createToolDefinition11(this.dbPath);
+    this.tool = createToolDefinition10(this.dbPath);
   }
   async parse() {
-    if (!existsSync22(this.dbPath)) {
+    if (!existsSync24(this.dbPath)) {
       return { buckets: [], sessions: [] };
     }
     const usageRows = await this.queryRows(
@@ -4574,10 +5086,10 @@ var ZCodeParser = class {
       if (!timestamp) {
         continue;
       }
-      const inputTokens = toSafeNumber11(row.inputTokens);
-      const outputTokens = toSafeNumber11(row.outputTokens);
-      const reasoningTokens = toSafeNumber11(row.reasoningTokens);
-      const cachedTokens = toSafeNumber11(row.cacheReadInputTokens);
+      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) {
         continue;
       }
@@ -4585,7 +5097,7 @@ var ZCodeParser = class {
         sessionId: getString3(row.sessionId) ?? void 0,
         source: TOOL_ID15,
         model: getString3(row.model) ?? "unknown",
-        project: getPathLeaf8(getString3(row.directory)),
+        project: getPathLeaf7(getString3(row.directory)),
         timestamp,
         inputTokens,
         outputTokens,
@@ -4619,31 +5131,31 @@ var ZCodeParser = class {
     };
   }
   isInstalled() {
-    return existsSync22(this.dbPath);
+    return existsSync24(this.dbPath);
   }
 };
 registerParser(new ZCodeParser());
 
 // src/parsers/qodercli.ts
-import { existsSync as existsSync23, readdirSync as readdirSync12 } from "fs";
-import { homedir as homedir24 } from "os";
-import { basename as basename9, join as join25 } from "path";
+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";
-var TOOL_NAME16 = "Qoder CLI";
-var DEFAULT_PROJECTS_DIR = join25(homedir24(), ".qoder", "projects");
-var DEFAULT_LOGS_DIR = join25(homedir24(), ".qoder", "logs", "sessions");
-var DEFAULT_RUNS_DIR = join25(homedir24(), ".qoder", "logs", "runs");
+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 CLI_ENTRYPOINT = "cli";
 var IDE_ENTRYPOINT = "acp";
 var CREDIT_MODEL_FALLBACK = "credits";
-function createToolDefinition12(projectsDir) {
+function createToolDefinition11(projectsDir) {
   return {
     id: TOOL_ID16,
-    name: TOOL_NAME16,
+    name: TOOL_NAME15,
     dataDir: projectsDir
   };
 }
-function toSafeNumber12(value) {
+function toSafeNumber11(value) {
   const numberValue = Number(value);
   return Number.isFinite(numberValue) ? numberValue : 0;
 }
@@ -4678,13 +5190,13 @@ function classifyQoderEntrypoint(content) {
   return "unknown";
 }
 function isQodercliBinaryPresent() {
-  const home = homedir24();
+  const home = homedir25();
   const candidates = [
-    join25(home, ".local", "bin", "qodercli"),
-    join25(home, ".qoder", "bin", "qodercli"),
-    join25(home, ".qoder-cli")
+    join26(home, ".local", "bin", "qodercli"),
+    join26(home, ".qoder", "bin", "qodercli"),
+    join26(home, ".qoder-cli")
   ];
-  return candidates.some((path) => existsSync23(path));
+  return candidates.some((path) => existsSync25(path));
 }
 function projectFromEncodedSlug(slug) {
   const parts = slug.split("-").filter(Boolean);
@@ -4692,11 +5204,11 @@ function projectFromEncodedSlug(slug) {
 }
 function projectFromCwd(cwd) {
   if (!cwd) return "unknown";
-  const leaf = basename9(cwd.replace(/[\\/]+$/, ""));
+  const leaf = basename10(cwd.replace(/[\\/]+$/, ""));
   return leaf || "unknown";
 }
 function totalCreditsUsed(quota) {
-  return toSafeNumber12(quota.userQuota?.used) + toSafeNumber12(quota.orgResourcePackage?.used) + toSafeNumber12(quota.addOnQuota?.used);
+  return toSafeNumber11(quota.userQuota?.used) + toSafeNumber11(quota.orgResourcePackage?.used) + toSafeNumber11(quota.addOnQuota?.used);
 }
 function parseRunManifest(content) {
   if (!content) return null;
@@ -4776,7 +5288,7 @@ var QoderCliParser = class {
     this.projectsDir = projectsDir;
     this.logsDir = logsDir;
     this.runsDir = runsDir;
-    this.tool = createToolDefinition12(projectsDir);
+    this.tool = createToolDefinition11(projectsDir);
   }
   projectsDir;
   logsDir;
@@ -4793,9 +5305,9 @@ var QoderCliParser = class {
     };
   }
   parseProjectSessions(sessionEvents) {
-    if (!existsSync23(this.projectsDir)) return;
+    if (!existsSync25(this.projectsDir)) return;
     for (const filePath of findJsonlFiles(this.projectsDir)) {
-      if (basename9(filePath).startsWith("verified-")) continue;
+      if (basename10(filePath).startsWith("verified-")) continue;
       const content = readFileSafe(filePath);
       if (!content) continue;
       if (classifyQoderEntrypoint(content) !== CLI_ENTRYPOINT) continue;
@@ -4830,7 +5342,7 @@ var QoderCliParser = class {
    * There is no token data here — only quota/usage credit totals.
    */
   parseCreditDeltas() {
-    if (!existsSync23(this.runsDir)) return [];
+    if (!existsSync25(this.runsDir)) return [];
     let runDirs;
     try {
       runDirs = readdirSync12(this.runsDir, { withFileTypes: true }).filter(
@@ -4841,15 +5353,15 @@ var QoderCliParser = class {
     }
     const allSnapshots = [];
     for (const dir of runDirs) {
-      const runPath = join25(this.runsDir, dir.name);
-      const logPath = join25(runPath, "qodercli.log");
-      if (!existsSync23(logPath)) continue;
+      const runPath = join26(this.runsDir, dir.name);
+      const logPath = join26(runPath, "qodercli.log");
+      if (!existsSync25(logPath)) continue;
       const logContent = readFileSafe(logPath);
       if (!logContent?.includes("quota/usage response:")) {
         continue;
       }
       const manifest = parseRunManifest(
-        readFileSafe(join25(runPath, "manifest.json"))
+        readFileSafe(join26(runPath, "manifest.json"))
       );
       const project = manifest?.project_id ? projectFromEncodedSlug(manifest.project_id) : projectFromCwd(manifest?.cwd);
       const snapshots = extractCreditSnapshotsFromLog(logContent, {
@@ -4861,67 +5373,72 @@ var QoderCliParser = class {
     return creditSnapshotsToEntries(allSnapshots);
   }
   isInstalled() {
-    return isQodercliBinaryPresent() || existsSync23(this.runsDir) || existsSync23(this.logsDir) || existsSync23(this.projectsDir);
+    return isQodercliBinaryPresent() || existsSync25(this.runsDir) || existsSync25(this.logsDir) || existsSync25(this.projectsDir);
   }
 };
 registerParser(new QoderCliParser());
 
 // src/parsers/grok-build.ts
-import { existsSync as existsSync24, readdirSync as readdirSync13 } from "fs";
-import { homedir as homedir25 } from "os";
-import { basename as basename10, join as join26 } from "path";
+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";
-var TOOL_NAME17 = "Grok Build";
-var DEFAULT_DATA_DIR7 = join26(homedir25(), ".grok", "sessions");
-function createToolDefinition13(dataDir) {
+var TOOL_NAME16 = "Grok Build";
+var DEFAULT_DATA_DIR7 = join27(homedir26(), ".grok", "sessions");
+var DEFAULT_ARCHIVE_DIR2 = join27(homedir26(), ".grok", "archived_sessions");
+function createToolDefinition12(dataDir) {
   return {
     id: TOOL_ID17,
-    name: TOOL_NAME17,
+    name: TOOL_NAME16,
     dataDir
   };
 }
-function toSafeNumber13(value) {
+function toSafeNumber12(value) {
   const numberValue = Number(value);
-  return Number.isFinite(numberValue) ? numberValue : 0;
+  return Number.isFinite(numberValue) && numberValue >= 0 ? Math.trunc(numberValue) : 0;
 }
 function projectFromEncodedCwd(encoded) {
   try {
     const decoded = decodeURIComponent(encoded);
-    const leaf = basename10(decoded.replace(/[\\/]+$/, ""));
+    const leaf = basename11(decoded.replace(/[\\/]+$/, ""));
     return leaf || "unknown";
   } catch {
-    const leaf = basename10(encoded);
+    const leaf = basename11(encoded);
     return leaf || "unknown";
   }
 }
 function resolveTimestamp(obj) {
   const ms = obj._meta?.agentTimestampMs ?? obj.params?.update?._meta?.agentTimestampMs;
   if (typeof ms === "number" && Number.isFinite(ms)) {
-    return new Date(ms);
+    const timestamp = new Date(ms);
+    return Number.isNaN(timestamp.getTime()) ? null : timestamp;
   }
   const raw = obj.timestamp;
   if (raw == null) return null;
   if (typeof raw === "number") {
-    return new Date(raw < 1e12 ? raw * 1e3 : raw);
+    const timestamp = new Date(raw < 1e12 ? raw * 1e3 : raw);
+    return Number.isNaN(timestamp.getTime()) ? null : timestamp;
   }
   const ts = new Date(raw);
   return Number.isNaN(ts.getTime()) ? null : ts;
 }
 function pushUsageEntries(entries, args) {
-  const { sessionId, project, timestamp, usage, fallbackModel } = args;
+  const { eventKey, sessionId, project, timestamp, usage, fallbackModel } = args;
   const modelUsage = usage.modelUsage;
   const models = modelUsage && Object.keys(modelUsage).length > 0 ? Object.entries(modelUsage) : [[fallbackModel, usage]];
+  const modelEntries = [];
   for (const [model, mu] of models) {
-    const cached = toSafeNumber13(mu.cachedReadTokens);
-    const reasoning = toSafeNumber13(mu.reasoningTokens);
-    const rawInput = toSafeNumber13(mu.inputTokens);
-    const rawOutput = toSafeNumber13(mu.outputTokens);
+    if (!mu || typeof mu !== "object") continue;
+    const cached = toSafeNumber12(mu.cachedReadTokens);
+    const rawInput = toSafeNumber12(mu.inputTokens);
+    const rawOutput = toSafeNumber12(mu.outputTokens);
+    const reasoning = Math.min(rawOutput, toSafeNumber12(mu.reasoningTokens));
     const inputTokens = Math.max(0, rawInput - cached);
     const outputTokens = Math.max(0, rawOutput - reasoning);
     if (inputTokens === 0 && outputTokens === 0 && cached === 0 && reasoning === 0) {
       continue;
     }
-    entries.push({
+    modelEntries.push({
       sessionId,
       source: TOOL_ID17,
       model: model || fallbackModel || "unknown",
@@ -4933,10 +5450,11 @@ function pushUsageEntries(entries, args) {
       cachedTokens: cached
     });
   }
+  entries.set(eventKey, modelEntries);
 }
 function findSessionDirs(dataDir) {
   const results = [];
-  if (!existsSync24(dataDir)) return results;
+  if (!existsSync26(dataDir)) return results;
   let projectDirs;
   try {
     projectDirs = readdirSync13(dataDir, { withFileTypes: true });
@@ -4946,7 +5464,7 @@ function findSessionDirs(dataDir) {
   for (const projectEntry of projectDirs) {
     if (!projectEntry.isDirectory()) continue;
     if (projectEntry.name.endsWith(".sqlite")) continue;
-    const projectDir = join26(dataDir, projectEntry.name);
+    const projectDir = join27(dataDir, projectEntry.name);
     const project = projectFromEncodedCwd(projectEntry.name);
     let sessionEntries;
     try {
@@ -4956,8 +5474,8 @@ function findSessionDirs(dataDir) {
     }
     for (const sessionEntry of sessionEntries) {
       if (!sessionEntry.isDirectory()) continue;
-      const sessionDir = join26(projectDir, sessionEntry.name);
-      if (!existsSync24(join26(sessionDir, "updates.jsonl"))) continue;
+      const sessionDir = join27(projectDir, sessionEntry.name);
+      if (!existsSync26(join27(sessionDir, "updates.jsonl"))) continue;
       results.push({
         sessionDir,
         project,
@@ -4968,7 +5486,7 @@ function findSessionDirs(dataDir) {
   return results;
 }
 function readFallbackModel(sessionDir) {
-  const summaryPath = join26(sessionDir, "summary.json");
+  const summaryPath = join27(sessionDir, "summary.json");
   const content = readFileSafe(summaryPath);
   if (!content) return "unknown";
   try {
@@ -4979,24 +5497,29 @@ function readFallbackModel(sessionDir) {
   }
 }
 var GrokBuildParser = class {
-  constructor(dataDir = DEFAULT_DATA_DIR7) {
+  constructor(dataDir = DEFAULT_DATA_DIR7, archiveDir = dataDir === DEFAULT_DATA_DIR7 ? DEFAULT_ARCHIVE_DIR2 : void 0) {
     this.dataDir = dataDir;
-    this.tool = createToolDefinition13(dataDir);
+    this.archiveDir = archiveDir;
+    this.tool = createToolDefinition12(dataDir);
   }
   dataDir;
+  archiveDir;
   tool;
   async parse() {
-    const entries = [];
-    const sessionEvents = [];
-    const sessions = findSessionDirs(this.dataDir);
+    const entries = /* @__PURE__ */ new Map();
+    const sessionEvents = /* @__PURE__ */ new Map();
+    const sessions = [
+      ...this.archiveDir ? findSessionDirs(this.archiveDir) : [],
+      ...findSessionDirs(this.dataDir)
+    ];
     for (const { sessionDir, project, sessionId } of sessions) {
-      const updatesPath = join26(sessionDir, "updates.jsonl");
+      const updatesPath = join27(sessionDir, "updates.jsonl");
       const content = readFileSafe(updatesPath);
       if (!content) continue;
       const fallbackModel = readFallbackModel(sessionDir);
       const seenUserPrompts = /* @__PURE__ */ new Set();
       const ANON_USER_OPEN = "__anon_user_open";
-      for (const line of content.split("\n")) {
+      for (const [lineNumber, line] of content.split("\n").entries()) {
         if (!line.trim()) continue;
         let obj;
         try {
@@ -5004,8 +5527,11 @@ var GrokBuildParser = class {
         } catch {
           continue;
         }
+        if (!obj || typeof obj !== "object") continue;
+        if (obj.method !== "session/update" && obj.method !== "_x.ai/session/update")
+          continue;
         const update = obj.params?.update;
-        if (!update?.sessionUpdate) continue;
+        if (!update) continue;
         const ts = resolveTimestamp(obj);
         if (!ts) continue;
         const sid = obj.params?.sessionId || sessionId;
@@ -5015,18 +5541,30 @@ var GrokBuildParser = class {
           const key = promptId ?? ANON_USER_OPEN;
           if (seenUserPrompts.has(key)) continue;
           seenUserPrompts.add(key);
-          sessionEvents.push({
-            sessionId: sid,
-            source: TOOL_ID17,
-            project,
-            timestamp: ts,
-            role: "user"
-          });
+          sessionEvents.set(
+            JSON.stringify([
+              sid,
+              "user",
+              key,
+              promptId ? null : ts.toISOString()
+            ]),
+            {
+              sessionId: sid,
+              source: TOOL_ID17,
+              project,
+              timestamp: ts,
+              role: "user"
+            }
+          );
           continue;
         }
-        if (updateType !== "turn_completed") continue;
+        if (updateType && updateType !== "turn_completed") continue;
+        if (!updateType && !update.usage) continue;
         seenUserPrompts.delete(ANON_USER_OPEN);
-        sessionEvents.push({
+        const eventKey = promptId ? JSON.stringify([sid, promptId]) : JSON.stringify([sid, "anonymous", updatesPath, lineNumber]);
+        if ((sessionEvents.get(eventKey)?.timestamp.getTime() ?? -Infinity) > ts.getTime())
+          continue;
+        sessionEvents.set(eventKey, {
           sessionId: sid,
           source: TOOL_ID17,
           project,
@@ -5036,6 +5574,7 @@ var GrokBuildParser = class {
         const usage = update.usage;
         if (!usage) continue;
         pushUsageEntries(entries, {
+          eventKey,
           sessionId: sid,
           project,
           timestamp: ts,
@@ -5044,28 +5583,29 @@ var GrokBuildParser = class {
         });
       }
     }
+    const usageEntries = [...entries.values()].flat();
     return {
-      buckets: aggregateToBuckets(entries),
-      sessions: extractSessions(sessionEvents, entries)
+      buckets: aggregateToBuckets(usageEntries),
+      sessions: extractSessions([...sessionEvents.values()], usageEntries)
     };
   }
   isInstalled() {
-    return existsSync24(this.dataDir) || existsSync24(join26(homedir25(), ".grok")) || existsSync24(join26(homedir25(), ".local", "bin", "grok"));
+    return existsSync26(this.dataDir) || Boolean(this.archiveDir && existsSync26(this.archiveDir)) || existsSync26(join27(homedir26(), ".grok")) || existsSync26(join27(homedir26(), ".local", "bin", "grok"));
   }
 };
 registerParser(new GrokBuildParser());
 
 // src/parsers/atomcode.ts
-import { existsSync as existsSync25 } from "fs";
-import { homedir as homedir26 } from "os";
-import { basename as basename11, join as join27 } from "path";
+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";
-var TOOL_NAME18 = "AtomCode";
-var DEFAULT_SESSIONS_DIR6 = join27(homedir26(), ".atomcode", "sessions");
+var TOOL_NAME17 = "AtomCode";
+var DEFAULT_SESSIONS_DIR6 = join28(homedir27(), ".atomcode", "sessions");
 function getAtomCodeSessionsDirs(env = process.env) {
   const dirs = [
     env.TOKEN_ARENA_ATOMCODE_DIR,
-    env.ATOMCODE_HOME ? join27(env.ATOMCODE_HOME, "sessions") : void 0,
+    env.ATOMCODE_HOME ? join28(env.ATOMCODE_HOME, "sessions") : void 0,
     DEFAULT_SESSIONS_DIR6
   ].filter((value) => Boolean(value));
   return Array.from(new Set(dirs));
@@ -5074,7 +5614,7 @@ function toNonNegativeNumber3(value) {
   const numberValue = Number(value);
   return Number.isFinite(numberValue) && numberValue >= 0 ? numberValue : 0;
 }
-function parseTimestamp3(value) {
+function parseTimestamp4(value) {
   if (typeof value === "number" && Number.isFinite(value)) {
     const timestamp = new Date(value);
     return Number.isNaN(timestamp.getTime()) ? null : timestamp;
@@ -5113,7 +5653,7 @@ function getMetaModel(meta) {
 }
 function getMetaProject(meta) {
   if (typeof meta?.working_dir === "string" && meta.working_dir) {
-    return basename11(meta.working_dir) || "unknown";
+    return basename12(meta.working_dir) || "unknown";
   }
   return "unknown";
 }
@@ -5124,7 +5664,7 @@ var AtomCodeParser = class {
     this.sessionsDirs = sessionsDir ? [sessionsDir] : getAtomCodeSessionsDirs();
     this.tool = {
       id: TOOL_ID18,
-      name: TOOL_NAME18,
+      name: TOOL_NAME17,
       dataDir: this.sessionsDirs[0] ?? DEFAULT_SESSIONS_DIR6
     };
   }
@@ -5146,7 +5686,7 @@ 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 = parseTimestamp3(row.ts);
+          const timestamp = parseTimestamp4(row.ts);
           if (!timestamp) continue;
           if (row.user !== void 0 || row.assistant !== void 0) {
             sessionEvents.push({
@@ -5198,24 +5738,24 @@ var AtomCodeParser = class {
     };
   }
   isInstalled() {
-    return this.sessionsDirs.some((dir) => existsSync25(dir));
+    return this.sessionsDirs.some((dir) => existsSync27(dir));
   }
 };
 registerParser(new AtomCodeParser());
 
 // src/parsers/dsh.ts
-import { existsSync as existsSync26, readdirSync as readdirSync14, readFileSync as readFileSync9 } from "fs";
-import { homedir as homedir27 } from "os";
-import { basename as basename12, join as join28 } from "path";
+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 * as zlib from "zlib";
 var TOOL_ID19 = "dsh";
-var TOOL_NAME19 = "DeepSeek Harness";
-var DEFAULT_SESSIONS_DIR7 = join28(homedir27(), ".dsh", "sessions");
+var TOOL_NAME18 = "DeepSeek Harness";
+var DEFAULT_SESSIONS_DIR7 = join29(homedir28(), ".dsh", "sessions");
 var LOG_BASENAME = "session";
 function getDshSessionsDirs(env = process.env) {
   const dirs = [
     env.TOKEN_ARENA_DSH_DIR,
-    env.DSH_HOME ? join28(env.DSH_HOME, "sessions") : void 0,
+    env.DSH_HOME ? join29(env.DSH_HOME, "sessions") : void 0,
     DEFAULT_SESSIONS_DIR7
   ].filter((value) => Boolean(value));
   return Array.from(new Set(dirs));
@@ -5304,10 +5844,10 @@ function readSessionLog(filePath) {
 }
 function findSessionLogs(dir) {
   const results = [];
-  if (!existsSync26(dir)) return results;
+  if (!existsSync28(dir)) return results;
   try {
     for (const entry of readdirSync14(dir, { withFileTypes: true })) {
-      const fullPath = join28(dir, entry.name);
+      const fullPath = join29(dir, entry.name);
       if (entry.isDirectory()) {
         results.push(...findSessionLogs(fullPath));
       } else if (entry.name === `${LOG_BASENAME}.jsonl` || entry.name === `${LOG_BASENAME}.jsonl.zstd`) {
@@ -5339,7 +5879,7 @@ var DshParser = class {
     this.sessionsDirs = sessionsDir ? [sessionsDir] : getDshSessionsDirs();
     this.tool = {
       id: TOOL_ID19,
-      name: TOOL_NAME19,
+      name: TOOL_NAME18,
       dataDir: this.sessionsDirs[0] ?? DEFAULT_SESSIONS_DIR7
     };
   }
@@ -5356,7 +5896,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 ? basename12(header.cwd) || "unknown" : projectFromDirName(relativeParts[0] ?? "");
+        const project = typeof header?.cwd === "string" && header.cwd ? basename13(header.cwd) || "unknown" : projectFromDirName(relativeParts[0] ?? "");
         let currentModel = "unknown";
         for (const row of rows) {
           if (row.type === "request/context") {
@@ -5399,13 +5939,16 @@ var DshParser = class {
           if (!usage || timestamp === null) continue;
           const model = (isCompaction && typeof row.data?.model === "string" ? row.data.model : "") || currentModel;
           const inputTokens = toNonNegativeNumber4(usage.inputTokens);
-          const cachedTokens = toNonNegativeNumber4(usage.cacheReadTokens) + toNonNegativeNumber4(usage.cacheWriteTokens);
+          const cachedTokens = toNonNegativeNumber4(usage.cacheReadTokens);
+          const cacheCreationTokens = toNonNegativeNumber4(
+            usage.cacheWriteTokens
+          );
           const reasoningTokens = toNonNegativeNumber4(usage.reasoningTokens);
           const outputTokens = Math.max(
             0,
             toNonNegativeNumber4(usage.outputTokens) - reasoningTokens
           );
-          if (inputTokens + outputTokens + cachedTokens + reasoningTokens === 0)
+          if (inputTokens + outputTokens + cachedTokens + cacheCreationTokens + reasoningTokens === 0)
             continue;
           const entryKey = [
             sessionId,
@@ -5414,6 +5957,7 @@ var DshParser = class {
             inputTokens,
             outputTokens,
             cachedTokens,
+            cacheCreationTokens,
             reasoningTokens
           ].join("|");
           if (seenEntryKeys.has(entryKey)) continue;
@@ -5427,7 +5971,8 @@ var DshParser = class {
             inputTokens,
             outputTokens,
             reasoningTokens,
-            cachedTokens
+            cachedTokens,
+            cacheCreationTokens
           });
         }
       }
@@ -5438,18 +5983,18 @@ var DshParser = class {
     };
   }
   isInstalled() {
-    return this.sessionsDirs.some((dir) => existsSync26(dir));
+    return this.sessionsDirs.some((dir) => existsSync28(dir));
   }
 };
 registerParser(new DshParser());
 
 // src/parsers/cherry-studio.ts
-import { existsSync as existsSync27 } from "fs";
-import { homedir as homedir28 } from "os";
-import { dirname as dirname6, join as join29, resolve as resolve3 } from "path";
+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";
-var TOOL_NAME20 = "Cherry Studio";
-var DB_RELATIVE = join29("Data", "cherrystudio.sqlite");
+var TOOL_NAME19 = "Cherry Studio";
+var DB_RELATIVE = join30("Data", "cherrystudio.sqlite");
 var USAGE_QUERY = `SELECT
   u.model_id as modelId,
   u.no_cache_tokens as noCacheTokens,
@@ -5472,14 +6017,14 @@ var MESSAGES_QUERY3 = `SELECT
   ORDER BY created_at`;
 function getDefaultUserDataDir(env = process.env) {
   if (process.platform === "darwin") {
-    return join29(homedir28(), "Library", "Application Support", "CherryStudio");
+    return join30(homedir29(), "Library", "Application Support", "CherryStudio");
   }
   if (process.platform === "win32") {
-    const appData = env.APPDATA?.trim() || join29(homedir28(), "AppData", "Roaming");
-    return join29(appData, "CherryStudio");
+    const appData = env.APPDATA?.trim() || join30(homedir29(), "AppData", "Roaming");
+    return join30(appData, "CherryStudio");
   }
-  const xdgConfigHome = env.XDG_CONFIG_HOME?.trim() || join29(homedir28(), ".config");
-  return join29(xdgConfigHome, "CherryStudio");
+  const xdgConfigHome = env.XDG_CONFIG_HOME?.trim() || join30(homedir29(), ".config");
+  return join30(xdgConfigHome, "CherryStudio");
 }
 function getCherryStudioDbPaths(env = process.env) {
   const paths = [];
@@ -5487,21 +6032,21 @@ function getCherryStudioDbPaths(env = process.env) {
   if (explicit) {
     const resolved = resolve3(explicit);
     paths.push(
-      resolved.endsWith(".sqlite") ? resolved : join29(resolved, DB_RELATIVE)
+      resolved.endsWith(".sqlite") ? resolved : join30(resolved, DB_RELATIVE)
     );
   }
-  paths.push(join29(getDefaultUserDataDir(env), DB_RELATIVE));
+  paths.push(join30(getDefaultUserDataDir(env), DB_RELATIVE));
   return Array.from(new Set(paths));
 }
 function resolveCherryStudioDbPath() {
   const candidates = getCherryStudioDbPaths();
-  return candidates.find((candidate) => existsSync27(candidate)) ?? "";
+  return candidates.find((candidate) => existsSync29(candidate)) ?? "";
 }
-function createToolDefinition14(dbPath) {
+function createToolDefinition13(dbPath) {
   return {
     id: TOOL_ID20,
-    name: TOOL_NAME20,
-    dataDir: dbPath ? dirname6(dbPath) : join29(getDefaultUserDataDir(), "Data")
+    name: TOOL_NAME19,
+    dataDir: dbPath ? dirname6(dbPath) : join30(getDefaultUserDataDir(), "Data")
   };
 }
 function toSafeCount(value) {
@@ -5533,10 +6078,10 @@ var CherryStudioParser = class {
   constructor(options = {}) {
     this.dbPath = options.dbPath || resolveCherryStudioDbPath();
     this.queryRows = options.queryRows || readSqliteRows;
-    this.tool = createToolDefinition14(this.dbPath);
+    this.tool = createToolDefinition13(this.dbPath);
   }
   async parse() {
-    if (!this.dbPath || !existsSync27(this.dbPath)) {
+    if (!this.dbPath || !existsSync29(this.dbPath)) {
       return { buckets: [], sessions: [] };
     }
     const usageRows = await this.queryRows(
@@ -5547,15 +6092,19 @@ var CherryStudioParser = class {
     for (const row of usageRows) {
       const timestamp = parseEpochMillis(row.createdAt);
       if (!timestamp) continue;
-      const cachedTokens = toSafeCount(row.cacheReadTokens) + toSafeCount(row.cacheWriteTokens);
+      const cachedTokens = toSafeCount(row.cacheReadTokens);
+      const cacheCreationTokens = toSafeCount(row.cacheWriteTokens);
       const noCacheTokens = toOptionalCount(row.noCacheTokens);
-      const inputTokens = noCacheTokens ?? Math.max(0, toSafeCount(row.inputTokens) - cachedTokens);
+      const inputTokens = noCacheTokens ?? Math.max(
+        0,
+        toSafeCount(row.inputTokens) - cachedTokens - cacheCreationTokens
+      );
       const reasoningTokens = toSafeCount(row.reasoningTokens);
       const outputTokens = Math.max(
         0,
         toSafeCount(row.outputTokens) - reasoningTokens
       );
-      if (inputTokens + outputTokens + reasoningTokens + cachedTokens === 0) {
+      if (inputTokens + outputTokens + reasoningTokens + cachedTokens + cacheCreationTokens === 0) {
         continue;
       }
       entries.push({
@@ -5569,7 +6118,8 @@ var CherryStudioParser = class {
         inputTokens,
         outputTokens,
         reasoningTokens,
-        cachedTokens
+        cachedTokens,
+        cacheCreationTokens
       });
     }
     let messageRows;
@@ -5606,7 +6156,7 @@ var CherryStudioParser = class {
     };
   }
   isInstalled() {
-    return Boolean(this.dbPath) && existsSync27(this.dbPath);
+    return Boolean(this.dbPath) && existsSync29(this.dbPath);
   }
 };
 registerParser(new CherryStudioParser());
@@ -5617,31 +6167,31 @@ import { Command, Option } from "commander";
 // src/infrastructure/config/manager.ts
 import { randomUUID } from "crypto";
 import {
-  existsSync as existsSync28,
+  existsSync as existsSync30,
   mkdirSync,
   readFileSync as readFileSync10,
   unlinkSync,
   writeFileSync
 } from "fs";
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 
 // src/infrastructure/xdg.ts
-import { homedir as homedir29 } from "os";
-import { join as join30 } from "path";
+import { homedir as homedir30 } from "os";
+import { join as join31 } from "path";
 function getConfigHome() {
-  return process.env.XDG_CONFIG_HOME || join30(homedir29(), ".config");
+  return process.env.XDG_CONFIG_HOME || join31(homedir30(), ".config");
 }
 function getStateHome() {
-  return process.env.XDG_STATE_HOME || join30(homedir29(), ".local", "state");
+  return process.env.XDG_STATE_HOME || join31(homedir30(), ".local", "state");
 }
 function getRuntimeDir() {
   return process.env.XDG_RUNTIME_DIR || getStateHome();
 }
 
 // src/infrastructure/config/manager.ts
-var CONFIG_DIR = join31(getConfigHome(), "tokenarena");
+var CONFIG_DIR = join32(getConfigHome(), "tokenarena");
 var isDev = process.env.TOKEN_ARENA_DEV === "1";
-var CONFIG_FILE = join31(CONFIG_DIR, isDev ? "config.dev.json" : "config.json");
+var CONFIG_FILE = join32(CONFIG_DIR, isDev ? "config.dev.json" : "config.json");
 var DEFAULT_API_URL = "https://token.guji.uno";
 var VALID_CONFIG_KEYS = [
   "apiKey",
@@ -5657,7 +6207,7 @@ function getConfigDir() {
   return CONFIG_DIR;
 }
 function loadConfig() {
-  if (!existsSync28(CONFIG_FILE)) return null;
+  if (!existsSync30(CONFIG_FILE)) return null;
   try {
     const raw = readFileSync10(CONFIG_FILE, "utf-8");
     const config = JSON.parse(raw);
@@ -5675,7 +6225,7 @@ function saveConfig(config) {
 `, "utf-8");
 }
 function deleteConfig() {
-  if (existsSync28(CONFIG_FILE)) {
+  if (existsSync30(CONFIG_FILE)) {
     unlinkSync(CONFIG_FILE);
   }
 }
@@ -6109,11 +6659,11 @@ function toProjectIdentity(input2) {
 }
 
 // src/domain/upload-manifest.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 var MANIFEST_VERSION = 1;
 var SNAPSHOT_PROTOCOL_VERSION = 1;
 function fingerprint(value) {
-  return createHash4("sha256").update(value).digest("hex").slice(0, 16);
+  return createHash6("sha256").update(value).digest("hex").slice(0, 16);
 }
 function normalizeApiUrl(apiUrl) {
   let end = apiUrl.length;
@@ -6162,6 +6712,7 @@ function getUploadBucketContentHash(bucket) {
   return fingerprint(
     JSON.stringify({
       cachedTokens: bucket.cachedTokens,
+      cacheCreationTokens: bucket.cacheCreationTokens ?? 0,
       hostname: bucket.hostname,
       inputTokens: bucket.inputTokens,
       outputTokens: bucket.outputTokens,
@@ -6176,6 +6727,7 @@ function getUploadSessionContentHash(session) {
     JSON.stringify({
       activeSeconds: session.activeSeconds,
       cachedTokens: session.cachedTokens,
+      cacheCreationTokens: session.cacheCreationTokens ?? 0,
       durationSeconds: session.durationSeconds,
       firstMessageAt: session.firstMessageAt,
       hostname: session.hostname,
@@ -6492,7 +7044,7 @@ var ApiClient = class {
 // src/infrastructure/runtime/lock.ts
 import {
   closeSync,
-  existsSync as existsSync29,
+  existsSync as existsSync31,
   openSync,
   readFileSync as readFileSync11,
   rmSync as rmSync3,
@@ -6501,22 +7053,22 @@ import {
 
 // src/infrastructure/runtime/paths.ts
 import { mkdirSync as mkdirSync2 } from "fs";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 var APP_NAME = "tokenarena";
 function getRuntimeDirPath() {
-  return join32(getRuntimeDir(), APP_NAME);
+  return join33(getRuntimeDir(), APP_NAME);
 }
 function getStateDir() {
-  return join32(getStateHome(), APP_NAME);
+  return join33(getStateHome(), APP_NAME);
 }
 function getSyncLockPath() {
-  return join32(getRuntimeDirPath(), "sync.lock");
+  return join33(getRuntimeDirPath(), "sync.lock");
 }
 function getSyncStatePath() {
-  return join32(getStateDir(), "status.json");
+  return join33(getStateDir(), "status.json");
 }
 function getUploadManifestPath() {
-  return join32(getStateDir(), "upload-manifest.json");
+  return join33(getStateDir(), "upload-manifest.json");
 }
 function ensureAppDirs() {
   mkdirSync2(getRuntimeDirPath(), { recursive: true });
@@ -6534,7 +7086,7 @@ function isProcessAlive(pid) {
   }
 }
 function readLockMetadata(lockPath) {
-  if (!existsSync29(lockPath)) {
+  if (!existsSync31(lockPath)) {
     return null;
   }
   try {
@@ -6608,13 +7160,13 @@ function describeExistingSyncLock() {
 }
 
 // src/infrastructure/runtime/state.ts
-import { existsSync as existsSync30, readFileSync as readFileSync12, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync32, readFileSync as readFileSync12, writeFileSync as writeFileSync3 } from "fs";
 function getDefaultState() {
   return { status: "idle" };
 }
 function loadSyncState() {
   const path = getSyncStatePath();
-  if (!existsSync30(path)) {
+  if (!existsSync32(path)) {
     return getDefaultState();
   }
   try {
@@ -6675,7 +7227,7 @@ function markSyncFailed(source, error, status) {
 }
 
 // src/infrastructure/runtime/upload-manifest.ts
-import { existsSync as existsSync31, readFileSync as readFileSync13, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync33, readFileSync as readFileSync13, writeFileSync as writeFileSync4 } from "fs";
 function isRecordOfStrings(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return false;
@@ -6691,7 +7243,7 @@ function isUploadManifest(value) {
 }
 function loadUploadManifest() {
   const path = getUploadManifestPath();
-  if (!existsSync31(path)) {
+  if (!existsSync33(path)) {
     return null;
   }
   try {
@@ -6725,11 +7277,19 @@ async function runAllParsers() {
   const allBuckets = [];
   const allSessions = [];
   const parserResults = [];
+  const failedSources = /* @__PURE__ */ new Set();
   for (const parser of getAllParsers()) {
     try {
       const result = await parser.parse();
       const buckets = result.buckets;
       const sessions = result.sessions;
+      if (result.incomplete) {
+        failedSources.add(parser.tool.id);
+        logger.warn(
+          `${parser.tool.id} parser reported an incomplete scan; preserving its remote history.`
+        );
+        continue;
+      }
       if (buckets.length > 0) allBuckets.push(...buckets);
       if (sessions.length > 0) allSessions.push(...sessions);
       if (buckets.length > 0 || sessions.length > 0) {
@@ -6740,10 +7300,18 @@ async function runAllParsers() {
         });
       }
     } catch (err) {
-      logger.warn(`${parser.tool.id} parser failed: ${err.message}`);
+      failedSources.add(parser.tool.id);
+      logger.warn(
+        `${parser.tool.id} parser failed: ${err instanceof Error ? err.message : String(err)}`
+      );
     }
   }
-  return { buckets: allBuckets, sessions: allSessions, parserResults };
+  return {
+    buckets: allBuckets,
+    sessions: allSessions,
+    parserResults,
+    failedSources: Array.from(failedSources)
+  };
 }
 function getDetectedTools() {
   return detectInstalledTools();
@@ -6788,10 +7356,7 @@ function formatScopeChangeReason(reason) {
   }
 }
 function resolveSnapshotResetDeviceId(input2) {
-  if (!input2.previous) {
-    return null;
-  }
-  if (input2.scopeChangedReasons.includes("server_or_api_key")) {
+  if (!input2.previous || input2.scopeChangedReasons.includes("server_or_api_key")) {
     return null;
   }
   if (input2.scopeChangedReasons.includes("project_identity") || input2.scopeChangedReasons.includes("snapshot_protocol")) {
@@ -6837,6 +7402,7 @@ function toUploadBuckets(buckets, settings, device) {
       existing.outputTokens += bucket.outputTokens;
       existing.reasoningTokens += bucket.reasoningTokens || 0;
       existing.cachedTokens += bucket.cachedTokens || 0;
+      existing.cacheCreationTokens = (existing.cacheCreationTokens ?? 0) + (bucket.cacheCreationTokens ?? 0);
       existing.totalTokens += bucket.totalTokens;
       continue;
     }
@@ -6852,6 +7418,7 @@ function toUploadBuckets(buckets, settings, device) {
       outputTokens: bucket.outputTokens,
       reasoningTokens: bucket.reasoningTokens || 0,
       cachedTokens: bucket.cachedTokens || 0,
+      cacheCreationTokens: bucket.cacheCreationTokens ?? 0,
       totalTokens: bucket.totalTokens
     });
   }
@@ -6881,6 +7448,7 @@ function toUploadSessions(sessions, settings, device) {
       outputTokens: session.outputTokens,
       reasoningTokens: session.reasoningTokens,
       cachedTokens: session.cachedTokens,
+      cacheCreationTokens: session.cacheCreationTokens ?? 0,
       totalTokens: session.totalTokens,
       primaryModel: session.primaryModel,
       modelUsages: session.modelUsages
@@ -6955,7 +7523,12 @@ function buildUploadBatches(device, buckets, sessions) {
   return batches;
 }
 async function runSync(config, opts = {}) {
-  const { quiet = false, source = "manual", throws = false } = opts;
+  const {
+    quiet = false,
+    source = "manual",
+    throws = false,
+    rebuild = false
+  } = opts;
   const lock = tryAcquireSyncLock(source);
   if (!lock) {
     const detail = describeExistingSyncLock();
@@ -6972,13 +7545,27 @@ async function runSync(config, opts = {}) {
   let totalIngested = 0;
   let totalSessionsSynced = 0;
   let caughtError = null;
+  let snapshotResetAttempted = false;
   try {
     const {
       buckets: allBuckets,
       sessions: allSessions,
-      parserResults
+      parserResults,
+      failedSources = []
     } = await runAllParsers();
+    if (rebuild && failedSources.length > 0) {
+      throw new SyncFailure(
+        `Cannot rebuild: incomplete or failed parsers (${failedSources.join(", ")}). Remote history has not been changed.`,
+        "error"
+      );
+    }
     if (allBuckets.length === 0 && allSessions.length === 0) {
+      if (rebuild) {
+        throw new SyncFailure(
+          "Cannot rebuild from an empty scan. Restore complete local logs first. Remote history has not been changed.",
+          "error"
+        );
+      }
       if (!quiet) {
         logger.info("No new usage data found.");
       }
@@ -7030,25 +7617,25 @@ async function runSync(config, opts = {}) {
       scope: manifestScope,
       sessions: uploadSessions
     });
-    const changedBuckets = uploadDiff.bucketsToUpload;
-    const changedSessions = uploadDiff.sessionsToUpload;
-    const snapshotResetDeviceId = resolveSnapshotResetDeviceId({
+    const snapshotResetDeviceId = rebuild ? device.deviceId : resolveSnapshotResetDeviceId({
       previous: previousManifest,
       scopeChangedReasons: uploadDiff.scopeChangedReasons
     });
-    if (!quiet && uploadDiff.scopeChangedReasons.length > 0) {
+    if (snapshotResetDeviceId && failedSources.length > 0) {
+      throw new SyncFailure(
+        "Cannot replace the device snapshot: incomplete or failed parsers (" + failedSources.join(", ") + "). Remote history has not been changed.",
+        "error"
+      );
+    }
+    const changedBuckets = snapshotResetDeviceId ? uploadBuckets : uploadDiff.bucketsToUpload;
+    const changedSessions = snapshotResetDeviceId ? uploadSessions : uploadDiff.sessionsToUpload;
+    if (!rebuild && !quiet && uploadDiff.scopeChangedReasons.length > 0) {
       const scopeReasons = uploadDiff.scopeChangedReasons.map(formatScopeChangeReason).join(", ");
-      if (snapshotResetDeviceId) {
-        logger.warn(
-          `Upload scope changed (${scopeReasons}). TokenArena will replace the previous remote snapshot for this device before uploading the current snapshot again.`
-        );
-      } else {
-        logger.warn(
-          `Upload scope changed (${scopeReasons}). TokenArena will upload the current snapshot again, but existing remote records from the previous scope will not be deleted automatically.`
-        );
-      }
+      logger.warn(
+        snapshotResetDeviceId ? `Upload scope changed (${scopeReasons}). The previous device snapshot will be replaced to apply the new privacy or protocol settings.` : `Upload scope changed (${scopeReasons}). Current records will be uploaded again; remote records from the previous server, account or device are preserved.`
+      );
     }
-    if (!quiet && (uploadDiff.removedBuckets > 0 || uploadDiff.removedSessions > 0)) {
+    if (!rebuild && !quiet && (uploadDiff.removedBuckets > 0 || uploadDiff.removedSessions > 0)) {
       const parts = [];
       if (uploadDiff.removedBuckets > 0) {
         parts.push(`${uploadDiff.removedBuckets} buckets`);
@@ -7057,24 +7644,9 @@ async function runSync(config, opts = {}) {
         parts.push(`${uploadDiff.removedSessions} sessions`);
       }
       logger.warn(
-        `Detected ${parts.join(" + ")} that were present in the previous local snapshot but are missing now. Remote deletions are not supported yet, so renamed projects or removed local logs may leave stale data online.`
+        `Detected ${parts.join(" + ")} that were present in the previous local snapshot but are missing now. Remote history is preserved. Use tokenarena sync --rebuild to replace it only when complete local logs are available.`
       );
     }
-    if (snapshotResetDeviceId) {
-      const deleted = await apiClient.deleteDeviceData(snapshotResetDeviceId);
-      if (!quiet) {
-        const deletedParts = [];
-        if (deleted.deletedBuckets > 0) {
-          deletedParts.push(`${deleted.deletedBuckets} buckets`);
-        }
-        if (deleted.deletedSessions > 0) {
-          deletedParts.push(`${deleted.deletedSessions} sessions`);
-        }
-        logger.info(
-          deletedParts.length > 0 ? `Cleared ${deletedParts.join(" + ")} from the previous remote snapshot before re-uploading.` : "Previous remote snapshot was already empty before re-uploading."
-        );
-      }
-    }
     if (changedBuckets.length === 0 && changedSessions.length === 0) {
       if (!quiet) {
         const skippedParts = [];
@@ -7112,6 +7684,22 @@ async function runSync(config, opts = {}) {
       (sum, size) => sum + size,
       0
     );
+    if (snapshotResetDeviceId) {
+      saveUploadManifest({
+        ...uploadDiff.nextManifest,
+        // 自动隐私迁移保留旧 scope；清理中断后，下次同步仍会重试删除旧快照。
+        scope: !rebuild && previousManifest ? previousManifest.scope : manifestScope,
+        buckets: {},
+        sessions: {}
+      });
+      snapshotResetAttempted = true;
+      const deleted = await apiClient.deleteDeviceData(snapshotResetDeviceId);
+      if (!quiet) {
+        logger.info(
+          `Replacing the device snapshot (${deleted.deletedBuckets} buckets and ${deleted.deletedSessions} sessions cleared).`
+        );
+      }
+    }
     let uploadedBytesBeforeBatch = 0;
     if (!quiet) {
       const parts = [];
@@ -7122,10 +7710,10 @@ async function runSync(config, opts = {}) {
         parts.push(`${changedSessions.length} sessions`);
       }
       const skippedParts = [];
-      if (uploadDiff.unchangedBuckets > 0) {
+      if (!snapshotResetDeviceId && uploadDiff.unchangedBuckets > 0) {
         skippedParts.push(`${uploadDiff.unchangedBuckets} unchanged buckets`);
       }
-      if (uploadDiff.unchangedSessions > 0) {
+      if (!snapshotResetDeviceId && uploadDiff.unchangedSessions > 0) {
         skippedParts.push(`${uploadDiff.unchangedSessions} unchanged sessions`);
       }
       logger.info(
@@ -7199,9 +7787,9 @@ View your dashboard at: ${apiUrl}/usage`);
       );
     } else if (error instanceof SyncFailure) {
       caughtError = error;
-    } else if (totalIngested > 0) {
+    } else if (totalIngested > 0 || totalSessionsSynced > 0) {
       caughtError = new SyncFailure(
-        `Sync partially completed (${totalIngested} buckets uploaded). ${httpErr.message}`,
+        `Sync partially completed (${totalIngested} buckets and ${totalSessionsSynced} sessions uploaded). ${httpErr.message}`,
         "error",
         error
       );
@@ -7212,6 +7800,13 @@ View your dashboard at: ${apiUrl}/usage`);
         error
       );
     }
+    if (snapshotResetAttempted) {
+      caughtError = new SyncFailure(
+        (rebuild ? "Rebuild" : "Snapshot replacement") + " did not finish. Run tokenarena sync to retry. " + caughtError.message,
+        caughtError.kind,
+        caughtError.causeError
+      );
+    }
     markSyncFailed(source, caughtError.message, caughtError.kind);
   } finally {
     lock.release();
@@ -7231,18 +7826,18 @@ View your dashboard at: ${apiUrl}/usage`);
 
 // src/commands/init.ts
 import { execFileSync as execFileSync7, spawn } from "child_process";
-import { existsSync as existsSync34 } from "fs";
+import { existsSync as existsSync36 } from "fs";
 import { appendFile, mkdir, readFile } from "fs/promises";
-import { homedir as homedir32, platform as platform5 } from "os";
-import { dirname as dirname7, join as join33, posix as posix3, win32 } from "path";
+import { homedir as homedir33, platform as platform5 } from "os";
+import { dirname as dirname7, join as join34, posix as posix3, win32 } from "path";
 
 // src/infrastructure/service/index.ts
 import { platform as platform4 } from "os";
 
 // src/infrastructure/service/linux-systemd.ts
 import { execFileSync as execFileSync5 } from "child_process";
-import { existsSync as existsSync32, mkdirSync as mkdirSync3, rmSync as rmSync4, writeFileSync as writeFileSync5 } from "fs";
-import { homedir as homedir30, platform as platform2 } from "os";
+import { existsSync as existsSync34, mkdirSync as mkdirSync3, rmSync as rmSync4, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir31, platform as platform2 } from "os";
 import { posix } from "path";
 
 // src/utils/command.ts
@@ -7292,11 +7887,17 @@ function getManagedServiceEnvironment(env = process.env) {
   }
   return next;
 }
+var TYPESCRIPT_ENTRY_PATTERN = /\.[cm]?tsx?$/i;
 function resolveManagedDaemonCommand(execPath = process.execPath, argv = process.argv) {
   const scriptPath = argv[1];
   if (!scriptPath) {
     throw new Error("\u65E0\u6CD5\u89E3\u6790 CLI \u5165\u53E3\u8DEF\u5F84\uFF0C\u8BF7\u901A\u8FC7 tokenarena \u547D\u4EE4\u91CD\u65B0\u6267\u884C\u3002");
   }
+  if (TYPESCRIPT_ENTRY_PATTERN.test(scriptPath)) {
+    throw new Error(
+      "\u65E0\u6CD5\u901A\u8FC7\u672A\u6253\u5305\u7684 TypeScript \u5165\u53E3\u5B89\u88C5\u670D\u52A1\uFF0C\u8BF7\u5148\u6267\u884C pnpm build:cli\uFF0C\u518D\u4F7F\u7528\u6253\u5305\u540E\u7684 tokenarena \u547D\u4EE4\u3002"
+    );
+  }
   return {
     execPath,
     args: [scriptPath, "daemon", "--service"]
@@ -7311,10 +7912,10 @@ function escapeXml(value) {
 
 // src/infrastructure/service/linux-systemd.ts
 var SYSTEMD_SERVICE_NAME = "tokenarena";
-function getLinuxSystemdServiceDir(homePath = homedir30()) {
+function getLinuxSystemdServiceDir(homePath = homedir31()) {
   return posix.join(homePath, ".config", "systemd", "user");
 }
-function getLinuxSystemdServiceFile(homePath = homedir30()) {
+function getLinuxSystemdServiceFile(homePath = homedir31()) {
   return posix.join(
     getLinuxSystemdServiceDir(homePath),
     `${SYSTEMD_SERVICE_NAME}.service`
@@ -7371,7 +7972,7 @@ function ensureSystemdAvailable() {
 }
 function createLinuxSystemdServiceBackend() {
   function isInstalled() {
-    return existsSync32(getLinuxSystemdServiceFile());
+    return existsSync34(getLinuxSystemdServiceFile());
   }
   async function setup(skipPrompt = false) {
     if (!ensureSystemdAvailable()) {
@@ -7496,7 +8097,7 @@ function createLinuxSystemdServiceBackend() {
   }
   async function uninstall(skipPrompt = false) {
     const serviceFile = getLinuxSystemdServiceFile();
-    if (!existsSync32(serviceFile)) {
+    if (!existsSync34(serviceFile)) {
       logger.info(formatBullet("\u670D\u52A1\u6587\u4EF6\u4E0D\u5B58\u5728\u3002", "warning"));
       return;
     }
@@ -7557,17 +8158,17 @@ function createLinuxSystemdServiceBackend() {
 
 // src/infrastructure/service/macos-launchd.ts
 import { execFileSync as execFileSync6 } from "child_process";
-import { existsSync as existsSync33, mkdirSync as mkdirSync4, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "fs";
-import { homedir as homedir31, platform as platform3 } from "os";
+import { existsSync as existsSync35, mkdirSync as mkdirSync4, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "fs";
+import { homedir as homedir32, 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 = homedir31()) {
+function getMacosLaunchAgentDir(homePath = homedir32()) {
   return posix2.join(homePath, "Library", "LaunchAgents");
 }
-function getMacosLaunchAgentFile(homePath = homedir31()) {
+function getMacosLaunchAgentFile(homePath = homedir32()) {
   return posix2.join(
     getMacosLaunchAgentDir(homePath),
     `${MACOS_LAUNCHD_LABEL}.plist`
@@ -7694,7 +8295,7 @@ function writeLaunchAgentPlist() {
     label: MACOS_LAUNCHD_LABEL,
     programArguments: [command.execPath, ...command.args],
     environment: getManagedServiceEnvironment(),
-    workingDirectory: homedir31(),
+    workingDirectory: homedir32(),
     standardOutPath: stdoutPath,
     standardErrorPath: stderrPath
   });
@@ -7719,7 +8320,7 @@ function bootstrapLaunchAgent() {
 }
 function createMacosLaunchdServiceBackend() {
   function isInstalled() {
-    return existsSync33(getMacosLaunchAgentFile());
+    return existsSync35(getMacosLaunchAgentFile());
   }
   async function setup(skipPrompt = false) {
     if (!ensureLaunchctlAvailable()) {
@@ -7860,7 +8461,7 @@ function createMacosLaunchdServiceBackend() {
   }
   async function uninstall(skipPrompt = false) {
     const plistFile = getMacosLaunchAgentFile();
-    if (!existsSync33(plistFile)) {
+    if (!existsSync35(plistFile)) {
       logger.info(formatBullet("\u670D\u52A1\u6587\u4EF6\u4E0D\u5B58\u5728\u3002", "warning"));
       return;
     }
@@ -7971,7 +8572,7 @@ function resolvePowerShellProfilePath() {
   const systemRoot = process.env.SYSTEMROOT || "C:\\Windows";
   const candidates = [
     "pwsh.exe",
-    join33(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
+    join34(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
   ];
   for (const command of candidates) {
     try {
@@ -8000,8 +8601,8 @@ function resolvePowerShellProfilePath() {
 function resolveShellAliasSetup(options = {}) {
   const currentPlatform = options.currentPlatform ?? platform5();
   const env = options.env ?? process.env;
-  const homeDir = options.homeDir ?? homedir32();
-  const pathExists = options.exists ?? existsSync34;
+  const homeDir = options.homeDir ?? homedir33();
+  const pathExists = options.exists ?? existsSync36;
   const shellFromEnv = env.SHELL ? basenameLikeShell(env.SHELL).toLowerCase() : "";
   const shellName = shellFromEnv || (currentPlatform === "win32" ? "powershell" : "");
   const aliasName = "ta";
@@ -8198,7 +8799,7 @@ async function setupShellAlias() {
   try {
     await mkdir(dirname7(setup.configFile), { recursive: true });
     let existingContent = "";
-    if (existsSync34(setup.configFile)) {
+    if (existsSync36(setup.configFile)) {
       existingContent = await readFile(setup.configFile, "utf-8");
     }
     const normalizedContent = existingContent.toLowerCase();
@@ -8300,6 +8901,7 @@ function createTotals() {
     inputTokens: 0,
     outputTokens: 0,
     cachedTokens: 0,
+    cacheCreationTokens: 0,
     reasoningTokens: 0,
     totalTokens: 0,
     buckets: 0,
@@ -8312,6 +8914,7 @@ function addBucketToTotals(totals, bucket) {
   totals.inputTokens += bucket.inputTokens || 0;
   totals.outputTokens += bucket.outputTokens || 0;
   totals.cachedTokens += bucket.cachedTokens || 0;
+  totals.cacheCreationTokens += bucket.cacheCreationTokens || 0;
   totals.reasoningTokens += bucket.reasoningTokens || 0;
   totals.totalTokens += bucket.totalTokens || 0;
   totals.buckets += 1;
@@ -8323,6 +8926,7 @@ function addBucketToRank(map, key, bucket) {
     inputTokens: 0,
     outputTokens: 0,
     cachedTokens: 0,
+    cacheCreationTokens: 0,
     reasoningTokens: 0,
     totalTokens: 0,
     sessions: 0
@@ -8330,6 +8934,7 @@ function addBucketToRank(map, key, bucket) {
   current.inputTokens += bucket.inputTokens || 0;
   current.outputTokens += bucket.outputTokens || 0;
   current.cachedTokens += bucket.cachedTokens || 0;
+  current.cacheCreationTokens += bucket.cacheCreationTokens || 0;
   current.reasoningTokens += bucket.reasoningTokens || 0;
   current.totalTokens += bucket.totalTokens || 0;
   map.set(name, current);
@@ -8369,6 +8974,7 @@ function buildToolSummary(input2) {
         inputTokens: 0,
         outputTokens: 0,
         cachedTokens: 0,
+        cacheCreationTokens: 0,
         reasoningTokens: 0,
         totalTokens: 0,
         sessions: 1
@@ -8383,6 +8989,7 @@ function buildToolSummary(input2) {
         inputTokens: 0,
         outputTokens: 0,
         cachedTokens: 0,
+        cacheCreationTokens: 0,
         reasoningTokens: 0,
         totalTokens: 0,
         sessions: 1
@@ -8456,27 +9063,38 @@ function buildLocalUsageDashboardData(input2) {
 }
 
 // src/infrastructure/runtime/cli-version.ts
-import { readFileSync as readFileSync14 } from "fs";
-import { dirname as dirname8, 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 cachedVersion;
-function getCliVersion(metaUrl = import.meta.url) {
-  if (cachedVersion) {
-    return cachedVersion;
+var versionCache = /* @__PURE__ */ new Map();
+function readPackageVersion(startDir) {
+  let dir = startDir;
+  while (true) {
+    const contents = readFileSafe(join35(dir, "package.json"));
+    if (contents !== null) {
+      try {
+        const { version } = JSON.parse(contents);
+        return typeof version === "string" && version.length > 0 ? version : void 0;
+      } catch {
+        return void 0;
+      }
+    }
+    const parent = dirname8(dir);
+    if (parent === dir) {
+      return void 0;
+    }
+    dir = parent;
   }
-  const packageJsonPath = join34(
-    dirname8(fileURLToPath(metaUrl)),
-    "..",
-    "package.json"
-  );
-  try {
-    const packageJson = JSON.parse(readFileSync14(packageJsonPath, "utf-8"));
-    cachedVersion = typeof packageJson.version === "string" ? packageJson.version : FALLBACK_VERSION;
-  } catch {
-    cachedVersion = FALLBACK_VERSION;
+}
+function getCliVersion(metaUrl = import.meta.url) {
+  const startDir = dirname8(fileURLToPath(metaUrl));
+  const cached = versionCache.get(startDir);
+  if (cached !== void 0) {
+    return cached;
   }
-  return cachedVersion;
+  const version = readPackageVersion(startDir) ?? FALLBACK_VERSION;
+  versionCache.set(startDir, version);
+  return version;
 }
 
 // src/infrastructure/ui/local-usage-dashboard.ts
@@ -8599,7 +9217,7 @@ function renderOverview(tool) {
   return [
     `${bold("Overview")} ${dim(tool.source)}`,
     `  Tokens   ${formatCompactNumber(tool.totals.totalTokens)} total \xB7 ${formatCompactNumber(tool.totals.inputTokens)} input \xB7 ${formatCompactNumber(tool.totals.outputTokens)} output`,
-    `  Details  ${formatCompactNumber(tool.totals.cachedTokens)} cached \xB7 ${formatCompactNumber(tool.totals.reasoningTokens)} reasoning`,
+    `  Details  ${formatCompactNumber(tool.totals.cachedTokens)} cache read \xB7 ${formatCompactNumber(tool.totals.cacheCreationTokens)} cache write \xB7 ${formatCompactNumber(tool.totals.reasoningTokens)} reasoning`,
     `  Scope    ${tool.totals.sessions} sessions \xB7 ${tool.totals.buckets} buckets \xB7 ${tool.totals.projects} projects \xB7 ${tool.totals.models} models`
   ];
 }
@@ -8871,13 +9489,14 @@ async function runSyncCommand(opts = {}) {
   }
   await runSync(config, {
     quiet: opts.quiet,
+    rebuild: opts.rebuild,
     source: "manual"
   });
 }
 
 // src/commands/uninstall.ts
-import { existsSync as existsSync35, readFileSync as readFileSync15, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "fs";
-import { homedir as homedir33, platform as platform6 } from "os";
+import { existsSync as existsSync37, readFileSync as readFileSync14, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "fs";
+import { homedir as homedir34, platform as platform6 } from "os";
 function removeShellAlias() {
   const shell = process.env.SHELL;
   if (!shell) return;
@@ -8886,24 +9505,24 @@ function removeShellAlias() {
   let configFile;
   switch (shellName) {
     case "zsh":
-      configFile = `${homedir33()}/.zshrc`;
+      configFile = `${homedir34()}/.zshrc`;
       break;
     case "bash":
-      if (platform6() === "darwin" && existsSync35(`${homedir33()}/.bash_profile`)) {
-        configFile = `${homedir33()}/.bash_profile`;
+      if (platform6() === "darwin" && existsSync37(`${homedir34()}/.bash_profile`)) {
+        configFile = `${homedir34()}/.bash_profile`;
       } else {
-        configFile = `${homedir33()}/.bashrc`;
+        configFile = `${homedir34()}/.bashrc`;
       }
       break;
     case "fish":
-      configFile = `${homedir33()}/.config/fish/config.fish`;
+      configFile = `${homedir34()}/.config/fish/config.fish`;
       break;
     default:
       return;
   }
-  if (!existsSync35(configFile)) return;
+  if (!existsSync37(configFile)) return;
   try {
-    let content = readFileSync15(configFile, "utf-8");
+    let content = readFileSync14(configFile, "utf-8");
     const aliasPatterns = [
       // zsh / bash format: alias ta="tokenarena"
       new RegExp(
@@ -8940,7 +9559,7 @@ async function runUninstall() {
   const runtimeDir = getRuntimeDirPath();
   const serviceBackend = getServiceBackend();
   const hasInstalledService = serviceBackend?.isInstalled() ?? false;
-  const hasLocalArtifacts = existsSync35(configPath) || existsSync35(configDir) || existsSync35(stateDir) || existsSync35(runtimeDir) || hasInstalledService;
+  const hasLocalArtifacts = existsSync37(configPath) || existsSync37(configDir) || existsSync37(stateDir) || existsSync37(runtimeDir) || hasInstalledService;
   if (!hasLocalArtifacts) {
     logger.info(formatHeader("\u5378\u8F7D TokenArena"));
     logger.info(formatBullet("\u672A\u53D1\u73B0\u672C\u5730\u914D\u7F6E\uFF0C\u65E0\u9700\u5378\u8F7D\u3002"));
@@ -8984,22 +9603,22 @@ async function runUninstall() {
     }
   }
   logger.info(formatSection("\u6267\u884C\u7ED3\u679C"));
-  if (existsSync35(configPath)) {
+  if (existsSync37(configPath)) {
     deleteConfig();
     logger.info(formatBullet("\u5DF2\u5220\u9664\u914D\u7F6E\u6587\u4EF6\u3002", "success"));
   }
-  if (existsSync35(configDir)) {
+  if (existsSync37(configDir)) {
     try {
       rmSync6(configDir, { recursive: false, force: true });
       logger.info(formatBullet("\u5DF2\u5220\u9664\u914D\u7F6E\u76EE\u5F55\u3002", "success"));
     } catch {
     }
   }
-  if (existsSync35(stateDir)) {
+  if (existsSync37(stateDir)) {
     rmSync6(stateDir, { recursive: true, force: true });
     logger.info(formatBullet("\u5DF2\u5220\u9664\u72B6\u6001\u6570\u636E\u3002", "success"));
   }
-  if (existsSync35(runtimeDir)) {
+  if (existsSync37(runtimeDir)) {
     rmSync6(runtimeDir, { recursive: true, force: true });
     logger.info(formatBullet("\u5DF2\u5220\u9664\u8FD0\u884C\u65F6\u6570\u636E\u3002", "success"));
   }
@@ -9202,7 +9821,10 @@ function createCli() {
   program.command("init").description("Initialize configuration with API key").option("--api-url <url>", "Custom API server URL").action(async (opts) => {
     await runInit(opts);
   });
-  program.command("sync").description("Manually sync usage data to server").addOption(new Option("--quiet").hideHelp()).action(async (opts) => {
+  program.command("sync").description("Manually sync usage data to server").option(
+    "--rebuild",
+    "Replace this device's remote history; requires complete local logs"
+  ).addOption(new Option("--quiet").hideHelp()).action(async (opts) => {
     await runSyncCommand(opts);
   });
   program.command("daemon").description("Run continuous sync (every 30 minutes by default)").option("--interval <ms>", "Sync interval in milliseconds", parseInt).addOption(new Option("--service").hideHelp()).action(async (opts) => {
@@ -9230,10 +9852,10 @@ function createCli() {
 }
 
 // src/infrastructure/runtime/main-module.ts
-import { existsSync as existsSync36, realpathSync as realpathSync2 } from "fs";
+import { existsSync as existsSync38, realpathSync as realpathSync2 } from "fs";
 import { resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-function isMainModule(argvEntry = process.argv[1], metaUrl = import.meta.url) {
+function isMainModule(metaUrl, argvEntry = process.argv[1]) {
   if (!argvEntry) {
     return false;
   }
@@ -9241,7 +9863,7 @@ function isMainModule(argvEntry = process.argv[1], metaUrl = import.meta.url) {
   try {
     return realpathSync2(argvEntry) === realpathSync2(currentModulePath);
   } catch {
-    if (!existsSync36(argvEntry)) {
+    if (!existsSync38(argvEntry)) {
       return false;
     }
     return resolve4(argvEntry) === resolve4(currentModulePath);
@@ -9249,6 +9871,7 @@ function isMainModule(argvEntry = process.argv[1], metaUrl = import.meta.url) {
 }
 
 // src/index.ts
+var EXIT_CANCELLED = 130;
 function normalizeArgv(argv) {
   return argv.filter((arg, index) => index < 2 || arg !== "--");
 }
@@ -9256,11 +9879,20 @@ async function run(argv = process.argv) {
   const program = createCli();
   await program.parseAsync(normalizeArgv(argv));
 }
-if (isMainModule()) {
-  void run();
+function reportFatalError(error) {
+  if (error instanceof Error && error.name === "ExitPromptError") {
+    process.exitCode = EXIT_CANCELLED;
+    return;
+  }
+  logger.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+}
+if (isMainModule(import.meta.url)) {
+  run().catch(reportFatalError);
 }
 export {
   normalizeArgv,
+  reportFatalError,
   run
 };
 //# sourceMappingURL=index.js.map