repospend 0.0.6 → 0.0.8

package/dist/cli.js

@@ -71,6 +71,8 @@ function groupBy(sessions, keyFn, labelFn) {
       id,
       label: labelFn(session),
       estimatedCostUsd: void 0,
+      knownCostSessions: 0,
+      unknownCostSessions: 0,
       inputTokens: 0,
       cachedInputTokens: 0,
       outputTokens: 0,
@@ -90,6 +92,9 @@ function groupBy(sessions, keyFn, labelFn) {
     group.warnings = unique([...group.warnings, ...session.warnings]);
     if (session.estimatedCostUsd !== void 0) {
       group.estimatedCostUsd = roundCurrency((group.estimatedCostUsd ?? 0) + session.estimatedCostUsd);
+      group.knownCostSessions += 1;
+    } else {
+      group.unknownCostSessions += 1;
     }
     groups.set(id, group);
   }
@@ -852,7 +857,7 @@ function buildDashboardSnapshot(input) {
   };
 }
 function isDashboardVisibleSession(session) {
-  return session.totalTokens > 0 || session.sourceClient === "claude";
+  return session.totalTokens > 0 || session.sourceClient === "claude" || session.sourceClient === "cursor";
 }
 
 // packages/core/src/repo.ts
@@ -1273,7 +1278,8 @@ function finalizeTokenAccumulator(accumulator) {
   }
   const direct = accumulator.directTokenUsages.filter((usage) => isValidTokenUsage(usage));
   if (direct.length > 0) {
-    const total = direct.reduce(
+    const filteredDirect = filterDuplicateDirectUsages(direct);
+    const total = filteredDirect.reduce(
       (sum2, usage) => ({
         inputTokens: sum2.inputTokens + usage.inputTokens,
         cachedInputTokens: sum2.cachedInputTokens + usage.cachedInputTokens,
@@ -1286,6 +1292,8 @@ function finalizeTokenAccumulator(accumulator) {
     applyFinalUsage(accumulator, total);
     accumulator.tokenAggregationMethod = "delta_sum";
     accumulator.tokenConfidence = "high";
+    const skipped = direct.length - filteredDirect.length;
+    if (skipped > 0) accumulator.warnings.push("duplicate_or_stale_token_snapshots_skipped");
     return;
   }
   accumulator.tokenAggregationMethod = "unknown";
@@ -1298,7 +1306,10 @@ function extractRecordTokens(record) {
   const payloadInfo = firstObject2(payload?.info);
   const codexLastUsage = firstObject2(payloadInfo?.last_token_usage);
   if (codexLastUsage) {
-    return tokenUsageFromObject(codexLastUsage, false);
+    const usage2 = tokenUsageFromObject(codexLastUsage, false);
+    const cumulativeSnapshot = firstObject2(payloadInfo?.total_token_usage);
+    const cumulativeUsage = cumulativeSnapshot ? tokenUsageFromObject(cumulativeSnapshot, true) : void 0;
+    return usage2 ? { ...usage2, cumulativeSnapshot: cumulativeUsage ? stripSnapshot(cumulativeUsage) : void 0 } : void 0;
   }
   const codexTotalUsage = firstObject2(payloadInfo?.total_token_usage);
   if (codexTotalUsage) {
@@ -1308,6 +1319,45 @@ function extractRecordTokens(record) {
   const usage = firstObject2(object.usage, object.token_usage, object.tokens, response?.usage, payload?.usage, payload?.token_usage, payload?.tokens);
   return tokenUsageFromObject(usage ?? object, false);
 }
+function filterDuplicateDirectUsages(usages) {
+  const filtered = [];
+  let previous;
+  for (const usage of usages) {
+    const snapshot = usage.cumulativeSnapshot;
+    if (snapshot && previous) {
+      if (sameTokenUsage(snapshot, previous)) continue;
+      if (!isMonotonicFrom(snapshot, previous) && looksLikeStaleRegression(snapshot, previous, usage)) continue;
+    }
+    filtered.push(usage);
+    if (snapshot) previous = snapshot;
+  }
+  return filtered;
+}
+function sameTokenUsage(a, b) {
+  return a.inputTokens === b.inputTokens && a.cachedInputTokens === b.cachedInputTokens && a.outputTokens === b.outputTokens && a.reasoningTokens === b.reasoningTokens && a.totalTokens === b.totalTokens;
+}
+function isMonotonicFrom(current, previous) {
+  return current.inputTokens >= previous.inputTokens && current.cachedInputTokens >= previous.cachedInputTokens && current.outputTokens >= previous.outputTokens && current.reasoningTokens >= previous.reasoningTokens;
+}
+function looksLikeStaleRegression(current, previous, last) {
+  const previousTotal = tokenBucketTotal(previous);
+  const currentTotal = tokenBucketTotal(current);
+  const lastTotal = tokenBucketTotal(last);
+  if (previousTotal <= 0 || currentTotal <= 0 || lastTotal <= 0) return false;
+  return currentTotal * 100 >= previousTotal * 98 || currentTotal * 4 >= previousTotal * 3 && currentTotal + lastTotal * 2 >= previousTotal;
+}
+function tokenBucketTotal(usage) {
+  return usage.inputTokens + usage.cachedInputTokens + usage.outputTokens + usage.reasoningTokens;
+}
+function stripSnapshot(usage) {
+  return {
+    inputTokens: usage.inputTokens,
+    cachedInputTokens: usage.cachedInputTokens,
+    outputTokens: usage.outputTokens,
+    reasoningTokens: usage.reasoningTokens,
+    totalTokens: usage.totalTokens
+  };
+}
 function tokenUsageFromObject(target, cumulative) {
   const input = numberFromKeys(target, ["input_tokens", "inputTokens", "prompt_tokens", "promptTokens"]);
   const cached = numberFromKeys(target, ["cached_input_tokens", "cachedInputTokens", "cached_tokens", "cachedTokens", "cache_read_input_tokens"]);
@@ -2116,9 +2166,9 @@ function scanClaude(options) {
   const warnings = [];
   const discovery = discoverClaudeSessionFiles(claudeHome, warnings, Boolean(options.claudeHome));
   const historyExists = fs5.existsSync(historyPath);
-  const seenUsageKeys = /* @__PURE__ */ new Set();
   const orderedFiles = discovery.files.map((file) => ({ file, mtimeMs: safeMtimeMs(file.filePath) })).sort((a, b) => a.mtimeMs - b.mtimeMs);
-  const sessions = orderedFiles.map(({ file }, index) => claudeFileToUsage(file, index, options, seenUsageKeys));
+  const usageSelection = selectClaudeUsageOccurrences(orderedFiles.map(({ file }) => file));
+  const sessions = orderedFiles.flatMap(({ file }, index) => claudeFileToUsages(file, index, options, usageSelection));
   const historyEntryCount = countHistoryEntries(historyPath);
   const parseFailureCount = sessions.filter((session) => session.parseStatus === "failed" || (session.parseErrors?.length ?? 0) > 0).length;
   const unreadableFileCount = sessions.filter((session) => session.parseErrors?.some((error) => error.startsWith("unable_to_read_session_file:"))).length;
@@ -2224,8 +2274,12 @@ function walk2(root, maxDepth, onFile, depth = 0) {
     }
   }
 }
-function claudeFileToUsage(file, index, options, seenUsageKeys) {
-  const breakdown = readClaudeBreakdown(file.filePath, seenUsageKeys);
+function claudeFileToUsages(file, index, options, usageSelection) {
+  const breakdown = readClaudeBreakdown(file.filePath, usageSelection);
+  const segments = segmentClaudeBreakdownByDayAndModel(breakdown);
+  return segments.map(({ breakdown: segment, suffix }) => claudeBreakdownToUsage(file, index, options, segment, suffix));
+}
+function claudeBreakdownToUsage(file, index, options, breakdown, idSuffix = "") {
   const id = breakdown.id ?? (path5.basename(file.filePath).replace(/\.jsonl$/i, "") || `claude-session-${index}`);
   const fallbackCwd = inferProjectPath(file.projectDir, file.projectsPath);
   const cwd = breakdown.cwd ?? fallbackCwd;
@@ -2235,7 +2289,7 @@ function claudeFileToUsage(file, index, options, seenUsageKeys) {
   if (!breakdown.cwd) warnings.push("repo_inferred_from_claude_project_dir");
   const hasTokenBreakdown = breakdown.totalTokens > 0 && breakdown.usageCount > 0;
   const usage = {
-    id,
+    id: `${id}${idSuffix}`,
     sourceClient: "claude",
     sourceApp: claudeSourceAppLabel(entrypoint),
     sourceAppRaw: entrypoint,
@@ -2300,7 +2354,7 @@ function claudeFileToUsage(file, index, options, seenUsageKeys) {
 function inferClaudeEntrypointFromPath(filePath) {
   return filePath.split(path5.sep).includes("local-agent-mode-sessions") ? "local-agent" : void 0;
 }
-function readClaudeBreakdown(filePath, seenUsageKeys) {
+function readClaudeBreakdown(filePath, usageSelection) {
   const breakdown = emptyBreakdown2();
   try {
     const text = fs5.readFileSync(filePath, "utf8");
@@ -2308,8 +2362,8 @@ function readClaudeBreakdown(filePath, seenUsageKeys) {
     breakdown.rawEventCount = parse.records.length;
     breakdown.parseErrors = parse.errors;
     breakdown.parseStatus = parse.errors.length ? parse.records.length ? "partial" : "failed" : "ok";
-    for (const record of parse.records) {
-      applyClaudeRecord(breakdown, record, seenUsageKeys);
+    for (const [recordIndex, record] of parse.records.entries()) {
+      applyClaudeRecord(breakdown, record, usageSelection, occurrenceKey(filePath, recordIndex));
     }
     breakdown.totalTokens = breakdown.inputTokens + breakdown.outputTokens;
   } catch (error) {
@@ -2320,7 +2374,7 @@ function readClaudeBreakdown(filePath, seenUsageKeys) {
   }
   return breakdown;
 }
-function applyClaudeRecord(breakdown, record, seenUsageKeys) {
+function applyClaudeRecord(breakdown, record, usageSelection, usageOccurrenceKey) {
   const timestamp3 = dateValue3(record.timestamp);
   if (timestamp3) {
     breakdown.startedAt = minDate(breakdown.startedAt, timestamp3);
@@ -2343,21 +2397,70 @@ function applyClaudeRecord(breakdown, record, seenUsageKeys) {
     const usageTokens = usage ? usageTotal(usage) : 0;
     const model = normalizeClaudeModel(message.model);
     if (model && (usageTokens > 0 || !breakdown.model)) breakdown.model = model;
-    if (usage && usageTokens > 0 && !alreadySeenUsage(record, message, seenUsageKeys)) {
-      applyUsage(breakdown, usage);
+    const selectedUsage = usageTokens > 0 ? usageSelection.usageByOccurrence.get(usageOccurrenceKey) : void 0;
+    if (selectedUsage) {
+      applyUsage(breakdown, selectedUsage);
+      breakdown.usageEvents.push({ timestamp: timestamp3, model, usage: selectedUsage });
     }
     applyContentSignals(breakdown, message.content);
   }
   if (looksFailedToolResult(record.toolUseResult)) breakdown.failedToolCallCount += 1;
 }
-function alreadySeenUsage(record, message, seenUsageKeys) {
+function selectClaudeUsageOccurrences(files) {
+  const usageByOccurrence = /* @__PURE__ */ new Map();
+  const selectedByDedupKey = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    let parse;
+    try {
+      parse = parseJsonLines2(fs5.readFileSync(file.filePath, "utf8"));
+    } catch {
+      continue;
+    }
+    for (const [recordIndex, record] of parse.records.entries()) {
+      const message = firstObject4(record.message);
+      const usage = firstObject4(message?.usage);
+      if (!message || !usage || usageTotal(usage) <= 0) continue;
+      const occurrence = occurrenceKey(file.filePath, recordIndex);
+      const dedupKey = usageDedupKey(record, message);
+      if (!dedupKey) {
+        usageByOccurrence.set(occurrence, usage);
+        continue;
+      }
+      const selected = selectedByDedupKey.get(dedupKey);
+      if (selected) {
+        mergeUsageMax(selected.usage, usage);
+      } else {
+        selectedByDedupKey.set(dedupKey, { occurrence, usage: cloneUsage(usage) });
+      }
+    }
+  }
+  for (const selected of selectedByDedupKey.values()) {
+    usageByOccurrence.set(selected.occurrence, selected.usage);
+  }
+  return { usageByOccurrence };
+}
+function usageDedupKey(record, message) {
   const messageId = stringValue3(message.id);
   const requestId = stringValue3(record.requestId);
-  if (!messageId || !requestId) return false;
-  const key = `${requestId}:${messageId}`;
-  if (seenUsageKeys.has(key)) return true;
-  seenUsageKeys.add(key);
-  return false;
+  if (!messageId || !requestId) return void 0;
+  return `${requestId}:${messageId}`;
+}
+function occurrenceKey(filePath, recordIndex) {
+  return `${path5.resolve(filePath)}:${recordIndex}`;
+}
+function cloneUsage(usage) {
+  return {
+    input_tokens: numberValue(usage.input_tokens),
+    cache_read_input_tokens: numberValue(usage.cache_read_input_tokens),
+    cache_creation_input_tokens: numberValue(usage.cache_creation_input_tokens),
+    output_tokens: numberValue(usage.output_tokens)
+  };
+}
+function mergeUsageMax(target, usage) {
+  target.input_tokens = Math.max(numberValue(target.input_tokens), numberValue(usage.input_tokens));
+  target.cache_read_input_tokens = Math.max(numberValue(target.cache_read_input_tokens), numberValue(usage.cache_read_input_tokens));
+  target.cache_creation_input_tokens = Math.max(numberValue(target.cache_creation_input_tokens), numberValue(usage.cache_creation_input_tokens));
+  target.output_tokens = Math.max(numberValue(target.output_tokens), numberValue(usage.output_tokens));
 }
 function applyUsage(breakdown, usage) {
   const input = numberValue(usage.input_tokens);
@@ -2370,6 +2473,54 @@ function applyUsage(breakdown, usage) {
   breakdown.outputTokens += output;
   breakdown.usageCount += 1;
 }
+function segmentClaudeBreakdownByDayAndModel(breakdown) {
+  const events = breakdown.usageEvents.filter((event) => event.timestamp);
+  const keys = new Set(events.map((event) => segmentKey(event.timestamp, event.model)));
+  if (keys.size <= 1) return [{ breakdown, suffix: "" }];
+  const groups = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const key = segmentKey(event.timestamp, event.model);
+    const day = dateKey2(event.timestamp);
+    const existing = groups.get(key) ?? { day, model: event.model, events: [] };
+    existing.events.push(event);
+    groups.set(key, existing);
+  }
+  return [...groups.values()].sort((a, b) => a.day.localeCompare(b.day) || (a.model ?? "").localeCompare(b.model ?? "")).map((group) => {
+    const segment = cloneBreakdownMetadata(breakdown);
+    segment.model = group.model ?? breakdown.model;
+    segment.startedAt = group.events.map((event) => event.timestamp).filter(Boolean).sort()[0];
+    segment.endedAt = group.events.map((event) => event.timestamp).filter(Boolean).sort().at(-1);
+    segment.assistantMessageCount = group.events.length;
+    segment.messageCount = group.events.length;
+    segment.rawEventCount = group.events.length;
+    for (const event of group.events) {
+      applyUsage(segment, event.usage);
+      segment.usageEvents.push(event);
+    }
+    segment.totalTokens = segment.inputTokens + segment.outputTokens;
+    return { breakdown: segment, suffix: `#${group.day}${group.model ? `#${group.model}` : ""}` };
+  });
+}
+function cloneBreakdownMetadata(breakdown) {
+  return {
+    ...emptyBreakdown2(),
+    id: breakdown.id,
+    title: breakdown.title,
+    cwd: breakdown.cwd,
+    gitBranch: breakdown.gitBranch,
+    entrypoint: breakdown.entrypoint,
+    version: breakdown.version,
+    parseStatus: breakdown.parseStatus,
+    parseErrors: [...breakdown.parseErrors],
+    warnings: [...breakdown.warnings, "claude_session_split_by_activity_day"]
+  };
+}
+function segmentKey(timestamp3, model) {
+  return `${dateKey2(timestamp3)}\0${model ?? ""}`;
+}
+function dateKey2(timestamp3) {
+  return timestamp3?.slice(0, 10) ?? "unknown-date";
+}
 function usageTotal(usage) {
   return numberValue(usage.input_tokens) + numberValue(usage.cache_read_input_tokens) + numberValue(usage.cache_creation_input_tokens) + numberValue(usage.output_tokens);
 }
@@ -2429,7 +2580,8 @@ function emptyBreakdown2() {
     parseStatus: "ok",
     parseErrors: [],
     promptTimeline: [],
-    warnings: []
+    warnings: [],
+    usageEvents: []
   };
 }
 function applyPromptTimeline2(breakdown, role, content, timestamp3) {
@@ -2579,6 +2731,738 @@ function safeMtimeMs(filePath) {
   }
 }
 
+// packages/core/src/sources/cursor.ts
+import fs6 from "node:fs";
+import os4 from "node:os";
+import path6 from "node:path";
+import Database2 from "better-sqlite3";
+var parserVersion = "cursor-v1";
+var maxJsonlBytes = 20 * 1024 * 1024;
+var maxDatabaseBytes = 100 * 1024 * 1024;
+var cursorStoragePrefixes = ["cursor.", "anysphere."];
+var interestingTerms = ["cursor", "composer", "aichat", "ai_chat", "aiservice", "agent-transcript", "prompttokenbreakdown"];
+function scanCursor(options) {
+  const cursorHome = options.cursorHome ?? path6.join(os4.homedir(), ".cursor");
+  const discovery = discoverCursorFiles(cursorHome, Boolean(options.cursorHome));
+  const jsonlCandidates = discovery.jsonlFiles.map((filePath) => cursorJsonlToCandidate(filePath, cursorHome));
+  const databaseCandidates = discovery.databaseFiles.flatMap((filePath) => cursorDatabaseToCandidates(filePath, cursorHome, discovery.warnings));
+  const candidates = dedupeCandidates([...jsonlCandidates, ...databaseCandidates]);
+  const sessions = candidates.map((candidate, index) => candidateToUsage(candidate, index, options));
+  const parseFailureCount = sessions.filter((session) => session.parseStatus === "failed" || (session.parseErrors?.length ?? 0) > 0).length;
+  const unreadableFileCount = sessions.filter((session) => session.parseErrors?.some((error) => error.startsWith("unable_to_read_"))).length;
+  const malformedFileCount = sessions.filter((session) => session.parseErrors?.some((error) => error.startsWith("jsonl_line_") || error.startsWith("sqlite_json_parse:"))).length;
+  if (!fs6.existsSync(cursorHome)) {
+    discovery.warnings.push(`Cursor home directory not found at ${cursorHome}`);
+  }
+  if (!fs6.existsSync(discovery.statePath)) {
+    discovery.warnings.push(`Cursor global state database not found at ${discovery.statePath}`);
+  }
+  return {
+    source: {
+      id: "cursor",
+      label: "Cursor",
+      available: discovery.jsonlFiles.length > 0 || discovery.databaseFiles.length > 0,
+      paths: unique4([cursorHome, discovery.projectsPath, discovery.statePath, discovery.workspaceStoragePath, ...discovery.roots]),
+      warnings: discovery.warnings
+    },
+    sessions,
+    stats: {
+      sourceId: "cursor",
+      sourceLabel: "Cursor",
+      homePath: cursorHome,
+      cursorHome,
+      globalStoragePath: discovery.globalStoragePath,
+      workspaceStoragePath: discovery.workspaceStoragePath,
+      projectsPath: discovery.projectsPath,
+      statePath: discovery.statePath,
+      projectsExists: fs6.existsSync(discovery.projectsPath),
+      stateExists: fs6.existsSync(discovery.statePath),
+      sessionsExists: discovery.jsonlFiles.length > 0,
+      sessionFileCount: discovery.jsonlFiles.length,
+      databaseFileCount: discovery.databaseFiles.length,
+      skippedFileCount: discovery.skippedFileCount,
+      sessionsImported: sessions.length,
+      parseFailureCount,
+      unreadableFileCount,
+      malformedFileCount,
+      lastScannedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function discoverCursorFiles(cursorHome, explicitHome) {
+  const warnings = [];
+  const appPaths = defaultCursorAppPaths();
+  const roots = explicitHome ? [cursorHome] : unique4([cursorHome, appPaths.statePath, ...cursorOwnedGlobalStorageRoots(appPaths.globalStoragePath), ...cursorOwnedWorkspaceStorageRoots(appPaths.workspaceStoragePath)]);
+  const jsonlFiles = [];
+  const databaseFiles = [];
+  let skippedFileCount = 0;
+  for (const root of roots) {
+    if (!fs6.existsSync(root)) continue;
+    try {
+      if (isReadableRegularFile(root, maxDatabaseBytes)) {
+        databaseFiles.push(root);
+        continue;
+      }
+      walk3(root, 10, (filePath) => {
+        const lower = filePath.toLowerCase();
+        if (lower.endsWith(".jsonl")) {
+          if (isReadableRegularFile(filePath, maxJsonlBytes)) jsonlFiles.push(filePath);
+          else skippedFileCount += 1;
+          return;
+        }
+        if (/\.(sqlite|db|vscdb)$/i.test(filePath)) {
+          if (isReadableRegularFile(filePath, maxDatabaseBytes)) databaseFiles.push(filePath);
+          else skippedFileCount += 1;
+        }
+      });
+    } catch (error) {
+      warnings.push(`Unable to inspect Cursor path ${root}: ${errorMessage3(error)}`);
+    }
+  }
+  return {
+    roots,
+    projectsPath: path6.join(cursorHome, "projects"),
+    globalStoragePath: appPaths.globalStoragePath,
+    workspaceStoragePath: appPaths.workspaceStoragePath,
+    statePath: appPaths.statePath,
+    jsonlFiles: unique4(jsonlFiles).sort(cursorJsonlSort),
+    databaseFiles: unique4(databaseFiles).sort(),
+    skippedFileCount,
+    warnings
+  };
+}
+function cursorOwnedGlobalStorageRoots(globalStoragePath) {
+  return cursorOwnedChildDirs(globalStoragePath);
+}
+function cursorOwnedWorkspaceStorageRoots(workspaceStoragePath) {
+  if (!fs6.existsSync(workspaceStoragePath)) return [];
+  const roots = [];
+  try {
+    for (const workspace of fs6.readdirSync(workspaceStoragePath, { withFileTypes: true })) {
+      if (!workspace.isDirectory()) continue;
+      roots.push(...cursorOwnedChildDirs(path6.join(workspaceStoragePath, workspace.name)));
+    }
+  } catch {
+    return [];
+  }
+  return roots;
+}
+function cursorOwnedChildDirs(root) {
+  if (!fs6.existsSync(root)) return [];
+  try {
+    return fs6.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && cursorStoragePrefixes.some((prefix) => entry.name.toLowerCase().startsWith(prefix))).map((entry) => path6.join(root, entry.name));
+  } catch {
+    return [];
+  }
+}
+function defaultCursorAppPaths() {
+  const home = os4.homedir();
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA ?? path6.join(home, "AppData", "Roaming");
+    const globalStoragePath2 = path6.join(appData, "Cursor", "User", "globalStorage");
+    return {
+      globalStoragePath: globalStoragePath2,
+      workspaceStoragePath: path6.join(appData, "Cursor", "User", "workspaceStorage"),
+      statePath: path6.join(globalStoragePath2, "state.vscdb")
+    };
+  }
+  if (process.platform === "darwin") {
+    const globalStoragePath2 = path6.join(home, "Library", "Application Support", "Cursor", "User", "globalStorage");
+    return {
+      globalStoragePath: globalStoragePath2,
+      workspaceStoragePath: path6.join(home, "Library", "Application Support", "Cursor", "User", "workspaceStorage"),
+      statePath: path6.join(globalStoragePath2, "state.vscdb")
+    };
+  }
+  const xdg = process.env.XDG_CONFIG_HOME || path6.join(home, ".config");
+  const globalStoragePath = path6.join(xdg, "Cursor", "User", "globalStorage");
+  return {
+    globalStoragePath,
+    workspaceStoragePath: path6.join(xdg, "Cursor", "User", "workspaceStorage"),
+    statePath: path6.join(globalStoragePath, "state.vscdb")
+  };
+}
+function walk3(root, maxDepth, onFile, depth = 0) {
+  if (depth > maxDepth) return;
+  for (const entry of fs6.readdirSync(root, { withFileTypes: true })) {
+    if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "CachedData" || entry.name === "Cache") continue;
+    const fullPath = path6.join(root, entry.name);
+    if (entry.isDirectory()) {
+      walk3(fullPath, maxDepth, onFile, depth + 1);
+    } else if (entry.isFile()) {
+      onFile(fullPath);
+    }
+  }
+}
+function isReadableRegularFile(filePath, maxBytes) {
+  try {
+    fs6.accessSync(filePath, fs6.constants.R_OK);
+    const stat = fs6.statSync(filePath);
+    return stat.isFile() && stat.size <= maxBytes;
+  } catch {
+    return false;
+  }
+}
+function cursorJsonlSort(a, b) {
+  const aTranscript = a.includes(`${path6.sep}agent-transcripts${path6.sep}`) ? 0 : 1;
+  const bTranscript = b.includes(`${path6.sep}agent-transcripts${path6.sep}`) ? 0 : 1;
+  return aTranscript - bTranscript || a.localeCompare(b);
+}
+function cursorJsonlToCandidate(filePath, cursorHome) {
+  const breakdown = emptyBreakdown3();
+  try {
+    const parse = parseJsonLines3(fs6.readFileSync(filePath, "utf8"));
+    breakdown.rawEventCount = parse.records.length;
+    breakdown.parseErrors = parse.errors;
+    breakdown.parseStatus = parse.errors.length ? parse.records.length ? "partial" : "failed" : "ok";
+    for (const record of parse.records) applyCursorRecord(breakdown, record);
+    finalizeBreakdown(breakdown);
+  } catch (error) {
+    const message = `unable_to_read_cursor_jsonl:${errorMessage3(error)}`;
+    breakdown.parseStatus = "failed";
+    breakdown.parseErrors.push(message);
+    breakdown.warnings.push(message);
+  }
+  if (!breakdown.id) breakdown.id = path6.basename(filePath).replace(/\.jsonl$/i, "") || void 0;
+  return {
+    sourcePath: filePath,
+    surface: inferSurfaceFromPath(filePath),
+    fallbackCwd: inferProjectPathFromCursorPath(filePath, cursorHome),
+    breakdown
+  };
+}
+function cursorDatabaseToCandidates(filePath, cursorHome, warnings) {
+  const candidates = [];
+  let db;
+  try {
+    db = new Database2(filePath, { readonly: true, fileMustExist: true });
+    const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all();
+    for (const table of tables) {
+      const columns = safeColumns(db, table.name, warnings);
+      if (!columns.length) continue;
+      const selectedColumns = columns.filter((column) => isLikelyTextColumn(column.name, column.type));
+      if (!selectedColumns.length) continue;
+      const rows = safeRows(db, table.name, selectedColumns.map((column) => column.name), warnings);
+      for (const row of rows) {
+        const match = candidateFromDatabaseRow(filePath, cursorHome, table.name, row);
+        if (match) candidates.push(match);
+      }
+    }
+  } catch (error) {
+    warnings.push(`Unable to read Cursor SQLite database at ${filePath}: ${errorMessage3(error)}`);
+  } finally {
+    db?.close();
+  }
+  return candidates;
+}
+function safeColumns(db, table, warnings) {
+  try {
+    return db.prepare(`PRAGMA table_info(${quoteIdentifier(table)})`).all();
+  } catch (error) {
+    warnings.push(`Unable to inspect Cursor SQLite table ${table}: ${errorMessage3(error)}`);
+    return [];
+  }
+}
+function safeRows(db, table, columns, warnings) {
+  try {
+    const select = columns.map(quoteIdentifier).join(", ");
+    return db.prepare(`SELECT ${select} FROM ${quoteIdentifier(table)} LIMIT 500`).all();
+  } catch (error) {
+    warnings.push(`Unable to scan Cursor SQLite table ${table}: ${errorMessage3(error)}`);
+    return [];
+  }
+}
+function quoteIdentifier(value) {
+  return `"${value.replaceAll('"', '""')}"`;
+}
+function isLikelyTextColumn(name, type) {
+  const normalized = `${name} ${type}`.toLowerCase();
+  return type === "" || normalized.includes("text") || normalized.includes("char") || normalized.includes("json") || normalized.includes("blob") || interestingTerms.some((term) => normalized.includes(term));
+}
+function candidateFromDatabaseRow(filePath, cursorHome, table, row) {
+  const records = [];
+  const matchedKeys = [];
+  const parseErrors = [];
+  const textEntries = Object.entries(row).map(([key, value]) => ({ key, text: textValue(value) })).filter((entry) => Boolean(entry.text));
+  const rowLooksInteresting = textEntries.some(({ key, text }) => looksCursorInteresting(key, text));
+  if (!rowLooksInteresting) return void 0;
+  for (const { key, text } of textEntries) {
+    if (!looksCursorInteresting(key, text) && !text.trim().startsWith("{") && !text.trim().startsWith("[")) continue;
+    matchedKeys.push(`${table}.${key}`);
+    const parsed = parseJsonBlob(text);
+    if (parsed.ok && Array.isArray(parsed.value)) records.push(...parsed.value);
+    else if (parsed.ok) records.push(parsed.value);
+    else records.push({ key, value: text.slice(0, 2e3) });
+    if (!parsed.ok && text.trim().startsWith("{")) parseErrors.push(`sqlite_json_parse:${table}.${key}:${parsed.error}`);
+  }
+  if (!records.length) return void 0;
+  const breakdown = emptyBreakdown3();
+  breakdown.parseErrors = parseErrors;
+  breakdown.parseStatus = parseErrors.length ? "partial" : "ok";
+  breakdown.rawEventCount = records.length;
+  breakdown.matchedKeys = unique4(matchedKeys);
+  for (const record of records) applyCursorRecord(breakdown, record);
+  finalizeBreakdown(breakdown);
+  if (isCursorMetadataOnlyBreakdown(breakdown)) return void 0;
+  return {
+    sourcePath: `${filePath}#${table}`,
+    surface: inferSurfaceFromPath(filePath),
+    fallbackCwd: inferProjectPathFromCursorPath(filePath, cursorHome),
+    breakdown
+  };
+}
+function isCursorMetadataOnlyBreakdown(breakdown) {
+  return breakdown.messageCount === 0 && breakdown.usageCount === 0 && !breakdown.hasEstimatedPromptTokens && breakdown.costCount === 0;
+}
+function looksCursorInteresting(key, text) {
+  const haystack = `${key}
+${text.slice(0, 4e3)}`.toLowerCase();
+  return interestingTerms.some((term) => haystack.includes(term));
+}
+function parseJsonBlob(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return { ok: false, error: "not_json" };
+  try {
+    return { ok: true, value: JSON.parse(trimmed) };
+  } catch (error) {
+    return { ok: false, error: errorMessage3(error) };
+  }
+}
+function parseJsonLines3(text) {
+  const records = [];
+  const errors = [];
+  text.split(/\r?\n/).map((line, index) => ({ line: line.trim(), index })).filter(({ line }) => Boolean(line)).forEach(({ line, index }) => {
+    try {
+      records.push(JSON.parse(line));
+    } catch (error) {
+      errors.push(`jsonl_line_${index + 1}:${errorMessage3(error)}`);
+    }
+  });
+  return { records, errors };
+}
+function applyCursorRecord(breakdown, record) {
+  const objects = collectObjects(record, 6, 150);
+  const root = firstObject5(record);
+  const timestamp3 = firstValueByKeys(objects, ["timestamp", "createdAt", "created_at", "lastUpdatedAt", "conversationCheckpointLastUpdatedAt", "time", "date"]);
+  const date = dateValue4(timestamp3);
+  if (date) {
+    breakdown.startedAt = minDate2(breakdown.startedAt, date);
+    breakdown.endedAt = maxDate2(breakdown.endedAt, date);
+  }
+  breakdown.id ??= firstStringByKeys(objects, ["sessionId", "session_id", "conversationId", "conversation_id", "composerId", "composer_id", "chatId", "chat_id"]);
+  breakdown.title ??= firstStringByKeys(objects, ["title", "name", "summary"]);
+  breakdown.cwd ??= firstPathByKeys(objects, ["cwd", "workspacePath", "workspace_path", "projectPath", "project_path", "repoPath", "repo_path", "rootPath", "root_path"]);
+  breakdown.model ??= firstStringByKeys(objects, ["model", "modelName", "model_name", "modelId", "model_id"]);
+  const role = inferRole(objects, root);
+  const text = extractMessageText3(objects, role);
+  if (role === "user") breakdown.userPromptCount += 1;
+  if (role === "assistant") breakdown.assistantMessageCount += 1;
+  if (role === "user" || role === "assistant") {
+    breakdown.messageCount += 1;
+    if (text && breakdown.promptTimeline.length < 80) {
+      breakdown.promptTimeline.push({ role, text: normalizeTimelineText3(text), timestamp: date });
+    }
+  }
+  const usage = extractUsage(objects);
+  if (usage.inputTokens + usage.cachedInputTokens + usage.outputTokens + usage.reasoningTokens + usage.totalTokens > 0) {
+    breakdown.inputTokens += usage.inputTokens;
+    breakdown.cachedInputTokens += usage.cachedInputTokens;
+    breakdown.outputTokens += usage.outputTokens;
+    breakdown.reasoningTokens += usage.reasoningTokens;
+    breakdown.totalTokens += usage.totalTokens;
+    breakdown.usageCount += 1;
+    if (usage.estimatedPromptTokens) breakdown.hasEstimatedPromptTokens = true;
+  }
+  const cost = firstNumberByKeys(objects, ["costUsd", "cost_usd", "estimatedCostUsd", "estimated_cost_usd", "cost"]);
+  if (cost !== void 0 && cost >= 0) {
+    breakdown.estimatedCostUsd = roundCurrency2((breakdown.estimatedCostUsd ?? 0) + cost);
+    breakdown.costCount += 1;
+  }
+  applyToolSignals(breakdown, objects);
+}
+function collectObjects(value, maxDepth, maxObjects, objects = []) {
+  if (objects.length >= maxObjects || maxDepth < 0) return objects;
+  if (!value || typeof value !== "object") return objects;
+  if (Array.isArray(value)) {
+    for (const item of value.slice(0, 80)) collectObjects(item, maxDepth - 1, maxObjects, objects);
+    return objects;
+  }
+  const object = value;
+  objects.push(object);
+  for (const child of Object.values(object)) collectObjects(child, maxDepth - 1, maxObjects, objects);
+  return objects;
+}
+function firstObject5(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function firstStringByKeys(objects, keys) {
+  for (const object of objects) {
+    for (const key of keys) {
+      const value = stringValue4(object[key]);
+      if (value) return value;
+    }
+  }
+  return void 0;
+}
+function firstValueByKeys(objects, keys) {
+  for (const object of objects) {
+    for (const key of keys) {
+      if (object[key] !== void 0 && object[key] !== null && object[key] !== "") return object[key];
+    }
+  }
+  return void 0;
+}
+function firstPathByKeys(objects, keys) {
+  const value = firstStringByKeys(objects, keys);
+  if (!value) return void 0;
+  if (value.startsWith("file://")) return value.replace(/^file:\/\//, "");
+  return value;
+}
+function firstNumberByKeys(objects, keys) {
+  for (const object of objects) {
+    for (const key of keys) {
+      const value = numberValue2(object[key]);
+      if (value !== void 0) return value;
+    }
+  }
+  return void 0;
+}
+function inferRole(objects, root) {
+  const role = firstStringByKeys(objects, ["role", "author", "speaker", "from"])?.toLowerCase();
+  if (role === "user" || role === "human") return "user";
+  if (role === "assistant" || role === "ai" || role === "agent") return "assistant";
+  const type = (stringValue4(root?.type) ?? stringValue4(root?.event) ?? "").toLowerCase();
+  if (type.includes("user") || type.includes("prompt")) return "user";
+  if (type.includes("assistant") || type.includes("response") || type.includes("completion")) return "assistant";
+  return void 0;
+}
+function extractMessageText3(objects, role) {
+  if (!role) return void 0;
+  for (const object of objects) {
+    for (const key of ["text", "content", "message", "prompt", "response", "answer"]) {
+      const text = textFromUnknown(object[key]);
+      if (text) return text;
+    }
+  }
+  return void 0;
+}
+function textFromUnknown(value) {
+  if (typeof value === "string" && value.trim()) return value;
+  if (Array.isArray(value)) {
+    const parts = value.map(textFromUnknown).filter((item) => Boolean(item));
+    return parts.length ? parts.join("\n") : void 0;
+  }
+  const object = firstObject5(value);
+  if (!object) return void 0;
+  return stringValue4(object.text) ?? stringValue4(object.content) ?? stringValue4(object.value);
+}
+function extractUsage(objects) {
+  const usageObjects = objects.filter((object) => Object.keys(object).some((key) => key.toLowerCase().includes("token") || key.toLowerCase() === "usage"));
+  const candidates = usageObjects.length ? usageObjects : objects;
+  return {
+    inputTokens: firstNumberByKeys(candidates, ["inputTokens", "input_tokens", "promptTokens", "prompt_tokens", "totalUsedTokens"]) ?? 0,
+    cachedInputTokens: firstNumberByKeys(candidates, ["cachedInputTokens", "cached_input_tokens", "cacheReadInputTokens", "cache_read_input_tokens"]) ?? 0,
+    outputTokens: firstNumberByKeys(candidates, ["outputTokens", "output_tokens", "completionTokens", "completion_tokens"]) ?? 0,
+    reasoningTokens: firstNumberByKeys(candidates, ["reasoningTokens", "reasoning_tokens", "reasoningOutputTokens", "reasoning_output_tokens"]) ?? 0,
+    totalTokens: firstNumberByKeys(candidates, ["totalTokens", "total_tokens", "tokens", "tokenCount", "token_count"]) ?? 0,
+    estimatedPromptTokens: firstNumberByKeys(candidates, ["totalUsedTokens"]) !== void 0
+  };
+}
+function applyToolSignals(breakdown, objects) {
+  const typeText = objects.flatMap((object) => [stringValue4(object.type), stringValue4(object.event), stringValue4(object.toolName), stringValue4(object.tool_name), stringValue4(object.name)]).filter((item) => Boolean(item)).join(" ").toLowerCase();
+  if (typeText.includes("tool")) breakdown.toolCallCount += 1;
+  if (typeText.includes("terminal") || typeText.includes("shell") || typeText.includes("command")) breakdown.shellCommandCount += 1;
+  if (typeText.includes("read")) breakdown.fileReadCount += 1;
+  if (typeText.includes("edit") || typeText.includes("write") || typeText.includes("apply")) breakdown.fileEditCount += 1;
+  if (objects.some(looksFailed)) breakdown.failedToolCallCount += 1;
+}
+function looksFailed(object) {
+  if (object.isError === true || object.is_error === true || object.error === true) return true;
+  const status = stringValue4(object.status)?.toLowerCase();
+  if (status === "failed" || status === "error") return true;
+  const exitCode = numberValue2(object.exitCode ?? object.exit_code ?? object.statusCode ?? object.status_code);
+  return exitCode !== void 0 && exitCode !== 0;
+}
+function finalizeBreakdown(breakdown) {
+  if (breakdown.totalTokens === 0) {
+    breakdown.totalTokens = breakdown.inputTokens + breakdown.outputTokens + breakdown.reasoningTokens;
+  }
+  if (breakdown.messageCount === 0) {
+    breakdown.messageCount = breakdown.userPromptCount + breakdown.assistantMessageCount;
+  }
+}
+function candidateToUsage(candidate, index, options) {
+  const breakdown = candidate.breakdown;
+  const id = breakdown.id ?? `${path6.basename(candidate.sourcePath).replace(/\.(jsonl|sqlite|db|vscdb)$/i, "") || "cursor-session"}-${index}`;
+  const cwd = breakdown.cwd ?? candidate.fallbackCwd ?? process.cwd();
+  const repo = resolveRepoInfo(cwd, options.config);
+  const hasTokenBreakdown = breakdown.inputTokens + breakdown.cachedInputTokens + breakdown.outputTokens + breakdown.reasoningTokens > 0;
+  const tokenAggregationMethod = hasTokenBreakdown ? breakdown.hasEstimatedPromptTokens ? "estimated" : "direct_usage" : "unknown";
+  const tokenWarnings = breakdown.hasEstimatedPromptTokens ? ["cursor_prompt_token_breakdown_estimate"] : [];
+  const usage = {
+    id,
+    sourceClient: "cursor",
+    sourceApp: cursorSourceAppLabel(candidate.surface),
+    sourceAppRaw: candidate.surface,
+    sourcePath: candidate.sourcePath,
+    repoRoot: repo.repoRoot,
+    repoName: repo.repoName,
+    cwd,
+    gitRemoteUrl: repo.gitRemoteUrl,
+    gitBranch: repo.gitBranch,
+    title: breakdown.title,
+    startedAt: breakdown.startedAt,
+    endedAt: breakdown.endedAt,
+    model: breakdown.model,
+    provider: providerForModel2(breakdown.model ?? ""),
+    inputTokens: breakdown.inputTokens,
+    cachedInputTokens: breakdown.cachedInputTokens,
+    outputTokens: breakdown.outputTokens,
+    reasoningTokens: breakdown.reasoningTokens,
+    reasoningOutputTokens: breakdown.reasoningTokens,
+    totalTokens: breakdown.totalTokens,
+    tokenAggregationMethod,
+    tokenConfidence: breakdown.hasEstimatedPromptTokens ? "low" : hasTokenBreakdown ? "medium" : "low",
+    tokenSnapshotCount: breakdown.usageCount,
+    estimatedCostUsd: void 0,
+    messageCount: breakdown.messageCount,
+    rawTokenTotal: breakdown.totalTokens || void 0,
+    warnings: [...repo.warnings, ...breakdown.warnings, ...tokenWarnings, ...hasTokenBreakdown ? [] : ["missing_token_breakdown"]],
+    durationMs: durationMs3(breakdown.startedAt, breakdown.endedAt),
+    rawEventCount: breakdown.rawEventCount,
+    parseStatus: breakdown.parseStatus,
+    parseErrors: breakdown.parseErrors,
+    detectedSurface: detectedSurface(candidate.surface),
+    surfaceConfidence: candidate.surface === "unknown" ? "low" : "medium",
+    surfaceReason: cursorSurfaceReason(candidate.surface),
+    userPromptCount: breakdown.userPromptCount,
+    assistantMessageCount: breakdown.assistantMessageCount,
+    toolCallCount: breakdown.toolCallCount,
+    shellCommandCount: breakdown.shellCommandCount,
+    failedToolCallCount: breakdown.failedToolCallCount,
+    nonZeroCommandEvents: 0,
+    importantCommandFailures: breakdown.failedToolCallCount,
+    harmlessNonZeroEvents: 0,
+    exploratoryMisses: 0,
+    repeatedFailureClusters: 0,
+    commandIssueSeverity: breakdown.failedToolCallCount > 0 ? "warning" : "none",
+    commandIssueImpact: breakdown.failedToolCallCount > 0 ? "medium" : "none",
+    topFailureType: breakdown.failedToolCallCount > 0 ? "unknown" : void 0,
+    commandIssueSamples: [],
+    fileReadCount: breakdown.fileReadCount,
+    fileEditCount: breakdown.fileEditCount,
+    promptTimeline: breakdown.promptTimeline,
+    sessionOutcome: inferOutcome3(breakdown),
+    sourceMetadata: {
+      parserVersion,
+      cursor: {
+        surface: candidate.surface,
+        matchedKeys: breakdown.matchedKeys,
+        costRecords: breakdown.costCount,
+        estimatedPromptTokens: breakdown.hasEstimatedPromptTokens
+      }
+    }
+  };
+  const pricedCost = hasTokenBreakdown ? calculateCostUsd(usage, options.pricing) : void 0;
+  const estimatedCostUsd = pricedCost ?? breakdown.estimatedCostUsd;
+  return {
+    ...usage,
+    estimatedCostUsd,
+    warnings: estimatedCostUsd === void 0 ? [...usage.warnings, breakdown.hasEstimatedPromptTokens ? "cursor_cost_not_estimated_from_prompt_tokens" : hasTokenBreakdown ? "unknown_pricing" : "unknown_cost"] : usage.warnings
+  };
+}
+function inferProjectPathFromCursorPath(filePath, cursorHome) {
+  const parts = filePath.split(path6.sep);
+  const projectsIndex = parts.lastIndexOf("projects");
+  if (projectsIndex >= 0 && projectsIndex < parts.length - 1) {
+    const projectId = parts[projectsIndex + 1];
+    if (projectId?.startsWith("-")) {
+      return `${path6.sep}${projectId.slice(1).split("-").filter(Boolean).join(path6.sep)}`;
+    }
+    if (projectId) return path6.join(cursorHome, "projects", projectId);
+  }
+  return void 0;
+}
+function inferSurfaceFromPath(filePath) {
+  const lower = filePath.toLowerCase();
+  if (lower.includes(`${path6.sep}agent-transcripts${path6.sep}`) || lower.endsWith(".jsonl")) return "cli";
+  if (lower.includes(`${path6.sep}workspaceStorage${path6.sep}`.toLowerCase()) || lower.includes(`${path6.sep}globalStorage${path6.sep}`.toLowerCase()) || lower.endsWith(".vscdb")) return "desktop";
+  return "unknown";
+}
+function cursorSourceAppLabel(surface) {
+  if (surface === "cli") return "Cursor CLI";
+  if (surface === "desktop") return "Cursor Desktop";
+  return "Cursor";
+}
+function detectedSurface(surface) {
+  if (surface === "cli") return "terminal_cli";
+  if (surface === "desktop") return "vscode_extension";
+  return "unknown";
+}
+function cursorSurfaceReason(surface) {
+  if (surface === "cli") return "Cursor local JSONL transcript";
+  if (surface === "desktop") return "Cursor local SQLite/vscdb storage";
+  return "Cursor local data";
+}
+function inferOutcome3(breakdown) {
+  if (breakdown.parseStatus === "failed") return "failed";
+  if (breakdown.failedToolCallCount > 0) return "partial";
+  if (breakdown.fileEditCount > 0) return "completed";
+  if (breakdown.shellCommandCount > 0) return "setup_debugging";
+  if (breakdown.userPromptCount > 0 || breakdown.assistantMessageCount > 0) return "research_only";
+  return "unknown";
+}
+function emptyBreakdown3() {
+  return {
+    id: void 0,
+    title: void 0,
+    cwd: void 0,
+    startedAt: void 0,
+    endedAt: void 0,
+    model: void 0,
+    inputTokens: 0,
+    cachedInputTokens: 0,
+    outputTokens: 0,
+    reasoningTokens: 0,
+    totalTokens: 0,
+    usageCount: 0,
+    estimatedCostUsd: void 0,
+    costCount: 0,
+    hasEstimatedPromptTokens: false,
+    messageCount: 0,
+    userPromptCount: 0,
+    assistantMessageCount: 0,
+    toolCallCount: 0,
+    shellCommandCount: 0,
+    failedToolCallCount: 0,
+    fileReadCount: 0,
+    fileEditCount: 0,
+    rawEventCount: 0,
+    parseStatus: "ok",
+    parseErrors: [],
+    promptTimeline: [],
+    warnings: [],
+    matchedKeys: []
+  };
+}
+function dedupeCandidates(candidates) {
+  const byId = /* @__PURE__ */ new Map();
+  const pathOnly = [];
+  for (const candidate of candidates) {
+    const id = candidate.breakdown.id;
+    if (!id) {
+      pathOnly.push(candidate);
+      continue;
+    }
+    const existing = byId.get(id);
+    byId.set(id, existing ? mergeCursorCandidates(existing, candidate) : candidate);
+  }
+  return [...byId.values(), ...pathOnly];
+}
+function mergeCursorCandidates(a, b) {
+  const primary = cursorCandidateScore(b) > cursorCandidateScore(a) ? b : a;
+  const secondary = primary === a ? b : a;
+  return {
+    ...primary,
+    surface: primary.surface === "unknown" ? secondary.surface : primary.surface,
+    fallbackCwd: primary.fallbackCwd ?? secondary.fallbackCwd,
+    breakdown: mergeCursorBreakdowns(primary.breakdown, secondary.breakdown)
+  };
+}
+function cursorCandidateScore(candidate) {
+  const breakdown = candidate.breakdown;
+  const hasTokenBreakdown = breakdown.inputTokens + breakdown.cachedInputTokens + breakdown.outputTokens + breakdown.reasoningTokens > 0;
+  return (hasTokenBreakdown ? 1e9 : 0) + breakdown.totalTokens + breakdown.messageCount * 1e3 + breakdown.rawEventCount;
+}
+function mergeCursorBreakdowns(primary, secondary) {
+  return {
+    ...primary,
+    title: primary.title ?? secondary.title,
+    cwd: primary.cwd ?? secondary.cwd,
+    startedAt: optionalMinDate(primary.startedAt, secondary.startedAt),
+    endedAt: optionalMaxDate(primary.endedAt, secondary.endedAt),
+    model: primary.model ?? secondary.model,
+    estimatedCostUsd: primary.estimatedCostUsd ?? secondary.estimatedCostUsd,
+    costCount: Math.max(primary.costCount, secondary.costCount),
+    hasEstimatedPromptTokens: primary.hasEstimatedPromptTokens || secondary.hasEstimatedPromptTokens,
+    messageCount: Math.max(primary.messageCount, secondary.messageCount),
+    userPromptCount: Math.max(primary.userPromptCount, secondary.userPromptCount),
+    assistantMessageCount: Math.max(primary.assistantMessageCount, secondary.assistantMessageCount),
+    toolCallCount: Math.max(primary.toolCallCount, secondary.toolCallCount),
+    shellCommandCount: Math.max(primary.shellCommandCount, secondary.shellCommandCount),
+    failedToolCallCount: Math.max(primary.failedToolCallCount, secondary.failedToolCallCount),
+    fileReadCount: Math.max(primary.fileReadCount, secondary.fileReadCount),
+    fileEditCount: Math.max(primary.fileEditCount, secondary.fileEditCount),
+    rawEventCount: Math.max(primary.rawEventCount, secondary.rawEventCount),
+    parseStatus: mergeParseStatus(primary.parseStatus, secondary.parseStatus),
+    parseErrors: unique4([...primary.parseErrors, ...secondary.parseErrors]),
+    promptTimeline: primary.promptTimeline.length >= secondary.promptTimeline.length ? primary.promptTimeline : secondary.promptTimeline,
+    warnings: unique4([...primary.warnings, ...secondary.warnings, "cursor_duplicate_session_merged"]),
+    matchedKeys: unique4([...primary.matchedKeys, ...secondary.matchedKeys])
+  };
+}
+function mergeParseStatus(a, b) {
+  if (a === "failed" || b === "failed") return "failed";
+  if (a === "partial" || b === "partial") return "partial";
+  return "ok";
+}
+function optionalMinDate(current, candidate) {
+  return candidate ? minDate2(current, candidate) : current;
+}
+function optionalMaxDate(current, candidate) {
+  return candidate ? maxDate2(current, candidate) : current;
+}
+function providerForModel2(model) {
+  const normalized = model.toLowerCase();
+  if (!normalized) return void 0;
+  if (normalized.includes("claude")) return "anthropic";
+  if (normalized.startsWith("gpt") || normalized.startsWith("o")) return "openai";
+  return void 0;
+}
+function stringValue4(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function textValue(value) {
+  if (typeof value === "string") return value;
+  if (Buffer.isBuffer(value)) return value.toString("utf8");
+  return void 0;
+}
+function numberValue2(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim() && Number.isFinite(Number(value))) return Number(value);
+  return void 0;
+}
+function dateValue4(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return new Date(value < 1e10 ? value * 1e3 : value).toISOString();
+  if (typeof value !== "string") return void 0;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
+}
+function minDate2(current, candidate) {
+  return !current || candidate < current ? candidate : current;
+}
+function maxDate2(current, candidate) {
+  return !current || candidate > current ? candidate : current;
+}
+function durationMs3(startedAt, endedAt) {
+  if (!startedAt || !endedAt) return void 0;
+  const start = new Date(startedAt).getTime();
+  const end = new Date(endedAt).getTime();
+  return Number.isFinite(start) && Number.isFinite(end) && end >= start ? end - start : void 0;
+}
+function normalizeTimelineText3(text) {
+  return text.replace(/\s+/g, " ").trim().slice(0, 1e3);
+}
+function roundCurrency2(value) {
+  return Number(value.toFixed(6));
+}
+function unique4(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+function errorMessage3(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
 // packages/core/src/sources/index.ts
 function scanUsageSources(options) {
   const codex = scanCodex({
@@ -2591,15 +3475,20 @@ function scanUsageSources(options) {
     ...options.config ? { config: options.config } : {},
     pricing: options.pricing
   });
+  const cursor = scanCursor({
+    ...options.cursorHome ? { cursorHome: options.cursorHome } : {},
+    ...options.config ? { config: options.config } : {},
+    pricing: options.pricing
+  });
   return {
-    sources: [codex.source, claude.source],
-    sourceStats: [codex.stats, claude.stats],
-    sessions: [...codex.sessions, ...claude.sessions]
+    sources: [codex.source, claude.source, cursor.source],
+    sourceStats: [codex.stats, claude.stats, cursor.stats],
+    sessions: [...codex.sessions, ...claude.sessions, ...cursor.sessions]
   };
 }
 
 // apps/server/src/data.ts
-import fs6 from "node:fs";
+import fs7 from "node:fs";
 var scanCacheTtlMs = 1e4;
 var scanCache;
 function readDashboardData(filters = {}, options = {}) {
@@ -2666,8 +3555,8 @@ function writePricingData(models) {
 }
 function clearRepoSpendLocalData() {
   const target = repospendHome();
-  const removed = fs6.existsSync(target);
-  fs6.rmSync(target, { recursive: true, force: true });
+  const removed = fs7.existsSync(target);
+  fs7.rmSync(target, { recursive: true, force: true });
   clearScanCache();
   return { path: target, removed };
 }
@@ -2723,8 +3612,8 @@ function runtimeCwd() {
 }
 
 // apps/server/src/server.ts
-import fs7 from "node:fs";
-import path6 from "node:path";
+import fs8 from "node:fs";
+import path7 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import fastifyStatic from "@fastify/static";
 import Fastify from "fastify";
@@ -3564,9 +4453,9 @@ function createServer(options = {}) {
     return exportCsv();
   });
   if (options.serveWeb !== false) {
-    const serverDist = path6.dirname(fileURLToPath2(import.meta.url));
-    const packagedWebDist = path6.resolve(serverDist, "../web-dist");
-    const workspaceWebDist = path6.resolve(serverDist, "../../web/dist");
+    const serverDist = path7.dirname(fileURLToPath2(import.meta.url));
+    const packagedWebDist = path7.resolve(serverDist, "../web-dist");
+    const workspaceWebDist = path7.resolve(serverDist, "../../web/dist");
     const webDist = fsExists(packagedWebDist) ? packagedWebDist : workspaceWebDist;
     if (!fsExists(webDist)) {
       throw new Error(`RepoSpend web assets are missing. Expected ${packagedWebDist} in the published package, or ${workspaceWebDist} during local development. Run "pnpm pack:prepare" before packaging.`);
@@ -3587,13 +4476,13 @@ function createServer(options = {}) {
   return app;
 }
 function fsExists(inputPath) {
-  return Boolean(inputPath) && path6.isAbsolute(inputPath) && fs7.existsSync(inputPath);
+  return Boolean(inputPath) && path7.isAbsolute(inputPath) && fs8.existsSync(inputPath);
 }
 function readPackageVersion() {
-  const serverDist = path6.dirname(fileURLToPath2(import.meta.url));
-  const packagePath = path6.resolve(serverDist, "../package.json");
+  const serverDist = path7.dirname(fileURLToPath2(import.meta.url));
+  const packagePath = path7.resolve(serverDist, "../package.json");
   try {
-    const parsed = JSON.parse(fs7.readFileSync(packagePath, "utf8"));
+    const parsed = JSON.parse(fs8.readFileSync(packagePath, "utf8"));
     return typeof parsed.version === "string" ? parsed.version : "unknown";
   } catch {
     return "unknown";
@@ -3602,9 +4491,28 @@ function readPackageVersion() {
 async function startServer(options = {}) {
   const port = options.port ?? Number(process.env.REPOSPEND_PORT ?? 2005);
   const host = options.host ?? "127.0.0.1";
-  const app = createServer(options);
-  await app.listen({ host, port });
-  return { app, url: `http://localhost:${port}` };
+  const candidatePorts = portCandidates(port, options.portFallbackCount ?? 20);
+  let lastError;
+  for (const candidatePort of candidatePorts) {
+    const app = createServer(options);
+    try {
+      await app.listen({ host, port: candidatePort });
+      return { app, url: `http://localhost:${candidatePort}`, port: candidatePort };
+    } catch (error) {
+      await app.close().catch(() => void 0);
+      lastError = error;
+      if (!isAddressInUse(error)) throw error;
+    }
+  }
+  throw lastError;
+}
+function portCandidates(startPort, fallbackCount) {
+  if (!Number.isInteger(startPort) || startPort <= 0 || startPort > 65535) return [2005];
+  const count2 = Math.max(0, Math.min(fallbackCount, 100));
+  return Array.from({ length: count2 + 1 }, (_value, index) => startPort + index).filter((port) => port <= 65535);
+}
+function isAddressInUse(error) {
+  return Boolean(error && typeof error === "object" && "code" in error && error.code === "EADDRINUSE");
 }
 function validatePricingBody(body) {
   if (!body || typeof body !== "object" || Array.isArray(body)) {
@@ -3648,7 +4556,9 @@ try {
   if (command === "--help" || command === "-h" || command === "help") {
     printHelp();
   } else if (command === "serve") {
-    const { url } = await startServer({ port: Number(process.env.REPOSPEND_PORT ?? 2005), serveWeb: true });
+    const requestedPort = Number(process.env.REPOSPEND_PORT ?? 2005);
+    const { url, port } = await startServer({ port: requestedPort, serveWeb: true });
+    if (port !== requestedPort) console.log(`Port ${requestedPort} is already in use; using ${port} instead.`);
     console.log(`RepoSpend dashboard: ${url}`);
     openBrowser(url);
   } else if (command === "scan") {
@@ -3689,7 +4599,7 @@ function openBrowser(url) {
 }
 function printGroups(groups) {
   if (!groups.length) {
-    console.log("No usage found. Scanned Codex and Claude Code local data paths.");
+    console.log("No usage found. Scanned Codex, Claude Code, and Cursor local data paths.");
     return;
   }
   const rows = groups.map((group) => ({
@@ -3722,5 +4632,5 @@ function printHelp() {
   repospend export --format csv
 
 Options:
-  --source all|codex|claude`);
+  --source all|codex|claude|cursor`);
 }