repospend 0.0.5 → 0.0.7

package/dist/cli.js

@@ -44,10 +44,14 @@ function summarize(sessions) {
   };
 }
 function groupByRepo(sessions) {
-  return groupBy(sessions, (session) => session.repoRoot, (session) => session.repoName);
+  const groups = groupBy(sessions, (session) => session.repoRoot, (session) => session.repoName);
+  return groups.map((group) => ({
+    ...group,
+    verified: sessions.some((s) => s.repoRoot === group.id && !s.warnings.includes("repo_unverified_no_git_root"))
+  }));
 }
 function groupByModel(sessions) {
-  return groupBy(sessions, (session) => session.model ?? "unknown-model", (session) => session.model ?? "Unknown model");
+  return groupBy(sessions, (session) => session.model ?? "unknown-model", (session) => session.model ?? "Model not recorded");
 }
 function groupBySourceApp(sessions) {
   return groupBy(sessions, (session) => session.sourceApp, (session) => session.sourceApp);
@@ -67,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,
@@ -86,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);
   }
@@ -344,7 +353,7 @@ function filterUsage(sessions, filters) {
     if (!matchesAny(session.sourceClient, filters.source)) return false;
     if (!matchesAny(session.sourceApp, filters.sourceApp)) return false;
     if (!matchesRepo(session, filters.repo)) return false;
-    if (!matchesAny(session.model, filters.model)) return false;
+    if (!matchesModel(session.model, filters.model)) return false;
     const startedAt = timestamp(session.startedAt);
     const hasDateFilter = Boolean(filters.from || filters.to);
     if (hasDateFilter && startedAt === void 0) return false;
@@ -365,6 +374,11 @@ function matchesRepo(session, filter) {
   if (!values.length) return true;
   return values.includes(session.repoName) || values.includes(session.repoRoot);
 }
+function matchesModel(value, filter) {
+  const values = filterValues(filter);
+  if (!values.length) return true;
+  return value !== void 0 ? values.includes(value) : values.includes("unknown-model");
+}
 function filterValues(filter) {
   if (!filter) return [];
   return Array.isArray(filter) ? filter.filter(Boolean) : filter.split(",").map((value) => value.trim()).filter(Boolean);
@@ -843,14 +857,18 @@ 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
 import fs3 from "node:fs";
 import path3 from "node:path";
+function normalizeRoot(p) {
+  const stripped = p.startsWith("\\\\?\\") ? p.slice(4) : p;
+  return stripped.replace(/^([a-zA-Z]):/, (_, letter) => letter.toUpperCase() + ":");
+}
 function findGitRoot(cwd, fileSystem = fs3) {
-  let current = path3.resolve(cwd);
+  let current = normalizeRoot(path3.resolve(cwd));
   while (true) {
     const gitPath = path3.join(current, ".git");
     if (fileSystem.existsSync(gitPath)) {
@@ -897,8 +915,8 @@ function safeFindGitRoot(cwd, fileSystem) {
   }
 }
 function fallbackWorkspaceRoot(cwd) {
-  const resolved = path3.resolve(cwd || process.cwd());
-  const home = process.env.HOME ? path3.resolve(process.env.HOME) : void 0;
+  const resolved = normalizeRoot(path3.resolve(cwd || process.cwd()));
+  const home = process.env.HOME ? normalizeRoot(path3.resolve(process.env.HOME)) : void 0;
   if (home && (resolved === home || resolved.startsWith(`${home}${path3.sep}`))) {
     const relative = path3.relative(home, resolved).split(path3.sep).filter(Boolean);
     const first = relative[0];
@@ -1260,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,
@@ -1273,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";
@@ -1285,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) {
@@ -1295,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"]);
@@ -1354,12 +1417,9 @@ function scanCodex(options) {
   if (stateExists) {
     const stateSessions = readThreads(statePath, sessionFiles, options, warnings);
     sessions.push(...stateSessions);
-    if (!stateSessions.length && sessionsExists) {
-      sessions.push(...readStandaloneSessions(sessionFiles, options));
-    }
   }
-  if (!stateExists && sessionsExists) {
-    sessions.push(...readStandaloneSessions(sessionFiles, options));
+  if (sessionsExists) {
+    sessions.push(...readStandaloneSessions(sessionFiles, options).filter((session) => !hasImportedSession(sessions, session)));
   }
   return {
     source: {
@@ -1402,8 +1462,10 @@ function readThreads(statePath, sessionFiles, options, warnings) {
       warnings.push("Codex threads table has no recognized columns.");
       return [];
     }
+    const importedModels = readImportedModelMap(options.codexHome ?? path4.join(os2.homedir(), ".codex"), warnings);
     const rows = db.prepare(`SELECT ${selectedColumns.map((column) => `"${column}"`).join(", ")} FROM threads`).all();
-    return rows.map((row, index) => threadToUsage(row, index, sessionFiles, options));
+    const sessions = rows.map((row, index) => threadToUsage(row, index, sessionFiles, options, importedModels));
+    return attributeSubagentsToParentSurfaces(sessions, rows);
   } catch (error) {
     warnings.push(`Unable to read Codex SQLite state at ${statePath}: ${errorMessage(error)}`);
     return [];
@@ -1411,6 +1473,37 @@ function readThreads(statePath, sessionFiles, options, warnings) {
     db?.close();
   }
 }
+function attributeSubagentsToParentSurfaces(sessions, rows) {
+  const sessionsById = new Map(sessions.map((session) => [session.id, session]));
+  const parentIdsByChildId = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const childId = stringValue2(row.id);
+    const parentId = codexParentThreadId(stringValue2(row.source));
+    if (childId && parentId) parentIdsByChildId.set(childId, parentId);
+  }
+  return sessions.map((session) => {
+    if (session.sourceApp !== "Codex subagent") return session;
+    const parent = sessionsById.get(parentIdsByChildId.get(session.id) ?? "");
+    if (!parent || parent.sourceApp === "Codex subagent") return session;
+    return {
+      ...session,
+      sourceApp: parent.sourceApp,
+      sourceAppRaw: session.sourceAppRaw,
+      surfaceReason: `subagent attributed to parent thread ${parent.id}: ${parent.surfaceReason}`
+    };
+  });
+}
+function codexParentThreadId(source) {
+  if (!source?.trim().startsWith("{")) return void 0;
+  try {
+    const object = asRecord(JSON.parse(source));
+    const subagent = asRecord(object?.subagent);
+    const threadSpawn = asRecord(subagent?.thread_spawn);
+    return stringValue2(threadSpawn?.parent_thread_id);
+  } catch {
+    return void 0;
+  }
+}
 function openCodexStateDatabase(statePath, warnings) {
   try {
     return new Database(statePath, { readonly: true, fileMustExist: true });
@@ -1475,24 +1568,30 @@ function isNativeSqliteMismatch(error) {
 function exitLabel(status) {
   return status === null ? "" : ` with exit code ${status}`;
 }
-function threadToUsage(row, index, sessionFiles, options) {
+function threadToUsage(row, index, sessionFiles, options, importedModels = /* @__PURE__ */ new Map()) {
+  const id = stringValue2(row.id) ?? `codex-thread-${index}`;
   const sourcePath = stringValue2(row.rollout_path) ?? matchSessionPath(stringValue2(row.id), sessionFiles) ?? "";
   const sessionBreakdown = sourcePath ? readSessionBreakdown(sourcePath) : emptyBreakdown();
   const dbTokens = parseTokenTotal(row.tokens_used);
-  const cwd = stringValue2(row.cwd) ?? fallbackCwdFromPath(sourcePath);
+  const cwd = stringValue2(row.cwd) ?? sessionBreakdown.cwd ?? fallbackCwdFromPath(sourcePath);
   const repo = resolveRepoInfo(cwd, options.config);
+  const inferredModel = stringValue2(row.model) || sessionBreakdown.model ? void 0 : importedModels.get(id);
+  const model = stringValue2(row.model) ?? sessionBreakdown.model ?? inferredModel?.model;
+  const provider = sessionBreakdown.provider ?? inferredModel?.provider ?? stringValue2(row.model_provider);
   const inputTokens = sessionBreakdown.inputTokens;
   const cachedInputTokens = sessionBreakdown.cachedInputTokens;
   const outputTokens = sessionBreakdown.outputTokens;
   const reasoningTokens = sessionBreakdown.reasoningTokens;
   const totalTokens = sessionBreakdown.totalTokens || dbTokens || inputTokens + outputTokens + reasoningTokens;
   const hasPricedBreakdown = inputTokens + cachedInputTokens + outputTokens + reasoningTokens > 0;
-  const warnings = [...repo.warnings, ...sessionBreakdown.warnings];
+  const warnings = [...repo.warnings, ...sessionBreakdown.warnings, ...inferredModel ? ["model_inferred_from_import_source"] : []];
   const threadSource = stringValue2(row.thread_source) ?? sessionBreakdown.threadSource;
-  const sourceAppRaw = stringValue2(row.source) ?? sessionBreakdown.source ?? sessionBreakdown.originator ?? threadSource;
+  const sourceAppRaw = codexSourceRaw(stringValue2(row.source), sessionBreakdown.source, sessionBreakdown.originator, threadSource);
   const surface = detectSurface(sourceAppRaw, threadSource);
+  const startedAt = dateValue2(row.created_at) ?? sessionBreakdown.startedAt;
+  const endedAt = dateValue2(row.updated_at) ?? sessionBreakdown.endedAt;
   const usage = {
-    id: stringValue2(row.id) ?? `codex-thread-${index}`,
+    id,
     sourceClient: "codex",
     sourceApp: codexSourceAppLabel(sourceAppRaw, threadSource),
     sourceAppRaw,
@@ -1502,11 +1601,11 @@ function threadToUsage(row, index, sessionFiles, options) {
     cwd,
     gitRemoteUrl: repo.gitRemoteUrl,
     gitBranch: repo.gitBranch,
-    title: stringValue2(row.title),
-    startedAt: dateValue2(row.created_at),
-    endedAt: dateValue2(row.updated_at),
-    model: stringValue2(row.model),
-    provider: stringValue2(row.model_provider),
+    title: stringValue2(row.title) ?? sessionBreakdown.title,
+    startedAt,
+    endedAt,
+    model,
+    provider,
     inputTokens,
     cachedInputTokens,
     outputTokens,
@@ -1521,7 +1620,7 @@ function threadToUsage(row, index, sessionFiles, options) {
     rawTokenTotal: dbTokens || sessionBreakdown.totalTokens || void 0,
     warnings,
     codexHome: options.codexHome ?? path4.join(os2.homedir(), ".codex"),
-    durationMs: durationMs(dateValue2(row.created_at), dateValue2(row.updated_at)),
+    durationMs: durationMs(startedAt, endedAt),
     rawEventCount: sessionBreakdown.rawEventCount,
     parseStatus: sessionBreakdown.parseStatus,
     parseErrors: sessionBreakdown.parseErrors,
@@ -1559,26 +1658,28 @@ function threadToUsage(row, index, sessionFiles, options) {
 function readStandaloneSessions(sessionFiles, options) {
   return [...sessionFiles.entries()].map(([id, sourcePath]) => {
     const breakdown = readSessionBreakdown(sourcePath);
-    const cwd = fallbackCwdFromPath(sourcePath);
+    const cwd = breakdown.cwd ?? fallbackCwdFromPath(sourcePath);
     const repo = resolveRepoInfo(cwd, options.config);
-    const model = void 0;
-    const surface = detectSurface(breakdown.source ?? breakdown.originator, breakdown.threadSource);
-    return {
-      id,
+    const model = breakdown.model;
+    const provider = breakdown.provider ?? providerForModel(model ?? "");
+    const sourceAppRaw = codexSourceRaw(void 0, breakdown.source, breakdown.originator, breakdown.threadSource);
+    const surface = detectSurface(sourceAppRaw, breakdown.threadSource);
+    const usage = {
+      id: breakdown.id ?? id,
       sourceClient: "codex",
-      sourceApp: codexSourceAppLabel(breakdown.source ?? breakdown.originator, breakdown.threadSource),
-      sourceAppRaw: breakdown.source ?? breakdown.originator ?? breakdown.threadSource,
+      sourceApp: codexSourceAppLabel(sourceAppRaw, breakdown.threadSource),
+      sourceAppRaw,
       sourcePath,
       repoRoot: repo.repoRoot,
       repoName: repo.repoName,
       cwd,
       gitRemoteUrl: repo.gitRemoteUrl,
       gitBranch: repo.gitBranch,
-      title: void 0,
-      startedAt: void 0,
-      endedAt: void 0,
+      title: breakdown.title,
+      startedAt: breakdown.startedAt,
+      endedAt: breakdown.endedAt,
       model,
-      provider: void 0,
+      provider,
       inputTokens: breakdown.inputTokens,
       cachedInputTokens: breakdown.cachedInputTokens,
       outputTokens: breakdown.outputTokens,
@@ -1591,8 +1692,9 @@ function readStandaloneSessions(sessionFiles, options) {
       estimatedCostUsd: void 0,
       messageCount: breakdown.messageCount,
       rawTokenTotal: breakdown.totalTokens || void 0,
-      warnings: [...repo.warnings, ...breakdown.warnings, "unknown_pricing"],
+      warnings: [...repo.warnings, ...breakdown.warnings],
       codexHome: options.codexHome ?? path4.join(os2.homedir(), ".codex"),
+      durationMs: durationMs(breakdown.startedAt, breakdown.endedAt),
       rawEventCount: breakdown.rawEventCount,
       parseStatus: breakdown.parseStatus,
       parseErrors: breakdown.parseErrors,
@@ -1619,8 +1721,87 @@ function readStandaloneSessions(sessionFiles, options) {
       sessionOutcome: inferOutcome(breakdown),
       compaction: breakdown.compaction
     };
+    const hasPricedBreakdown = breakdown.inputTokens + breakdown.cachedInputTokens + breakdown.outputTokens + breakdown.reasoningTokens > 0;
+    const cost = hasPricedBreakdown ? calculateCostUsd(usage, options.pricing) : void 0;
+    return {
+      ...usage,
+      estimatedCostUsd: cost,
+      warnings: cost === void 0 ? [...usage.warnings, hasPricedBreakdown ? "unknown_pricing" : "missing_token_breakdown"] : usage.warnings
+    };
   });
 }
+function hasImportedSession(sessions, candidate) {
+  const candidatePath = comparableSourcePath(candidate.sourcePath);
+  return sessions.some((session) => {
+    if (session.id && session.id === candidate.id) return true;
+    const sessionPath = comparableSourcePath(session.sourcePath);
+    return Boolean(candidatePath && sessionPath && candidatePath === sessionPath);
+  });
+}
+function readImportedModelMap(codexHome, warnings) {
+  const importsPath = path4.join(codexHome, "external_agent_session_imports.json");
+  const models = /* @__PURE__ */ new Map();
+  if (!fs4.existsSync(importsPath)) return models;
+  let parsed;
+  try {
+    parsed = JSON.parse(fs4.readFileSync(importsPath, "utf8"));
+  } catch (error) {
+    warnings.push(`Unable to read Codex external import index at ${importsPath}: ${errorMessage(error)}`);
+    return models;
+  }
+  const records = Array.isArray(asRecord(parsed)?.records) ? asRecord(parsed)?.records : [];
+  for (const record of records) {
+    const item = asRecord(record);
+    const importedThreadId = stringValue2(item?.imported_thread_id);
+    const sourcePath = normalizeVerbatimPath(stringValue2(item?.source_path));
+    if (!importedThreadId || !sourcePath || !fs4.existsSync(sourcePath)) continue;
+    const model = readImportedSourceModel(sourcePath, warnings);
+    if (model) models.set(importedThreadId, { model, provider: providerForModel(model) });
+  }
+  return models;
+}
+function readImportedSourceModel(sourcePath, warnings) {
+  const counts = /* @__PURE__ */ new Map();
+  let content;
+  try {
+    content = fs4.readFileSync(sourcePath, "utf8");
+  } catch (error) {
+    warnings.push(`Unable to read Codex external import source at ${sourcePath}: ${errorMessage(error)}`);
+    return void 0;
+  }
+  for (const [index, line] of content.split(/\r?\n/).entries()) {
+    if (!line.trim()) continue;
+    try {
+      const model = modelFromImportedRecord(JSON.parse(line));
+      if (model) counts.set(model, (counts.get(model) ?? 0) + 1);
+    } catch (error) {
+      warnings.push(`Unable to parse Codex external import source ${sourcePath} line ${index + 1}: ${errorMessage(error)}`);
+    }
+  }
+  return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))[0]?.[0];
+}
+function modelFromImportedRecord(record) {
+  const object = asRecord(record);
+  const type = stringValue2(object?.type) ?? stringValue2(asRecord(object?.payload)?.type);
+  const message = asRecord(object?.message) ?? asRecord(asRecord(object?.payload)?.message);
+  const model = stringValue2(message?.model) ?? stringValue2(object?.model);
+  if (!model || model === "<synthetic>") return void 0;
+  if (type && type !== "assistant") return void 0;
+  return model;
+}
+function providerForModel(model) {
+  const normalized = model.toLowerCase();
+  if (!normalized) return void 0;
+  if (normalized.startsWith("claude")) return "anthropic";
+  if (normalized.startsWith("gpt") || normalized.startsWith("o")) return "openai";
+  return void 0;
+}
+function normalizeVerbatimPath(value) {
+  return value?.replace(/^\\\\\?\\/, "");
+}
+function comparableSourcePath(value) {
+  return normalizeVerbatimPath(value)?.replace(/\\/g, "/");
+}
 function indexSessionFiles(sessionsPath, warnings) {
   const files = /* @__PURE__ */ new Map();
   try {
@@ -1657,6 +1838,7 @@ function readSessionBreakdown(filePath) {
     let responseMessageCount = 0;
     let lastUserMessageText;
     for (const record of records) {
+      applySessionBounds(breakdown, record);
       applySessionMetadata(breakdown, record);
       applyPromptTimeline(breakdown, record);
       if (isCodexEventMessage(record)) eventMessageCount += 1;
@@ -1739,6 +1921,13 @@ function matchSessionPath(id, sessionFiles) {
 }
 function emptyBreakdown() {
   return {
+    id: void 0,
+    cwd: void 0,
+    title: void 0,
+    startedAt: void 0,
+    endedAt: void 0,
+    model: void 0,
+    provider: void 0,
     inputTokens: 0,
     cachedInputTokens: 0,
     outputTokens: 0,
@@ -1783,10 +1972,26 @@ function applySessionMetadata(breakdown, record) {
   if (!record || typeof record !== "object") return;
   const object = record;
   const payload = firstObject3(object.payload) ?? object;
+  const collaborationMode = firstObject3(payload.collaboration_mode);
+  const collaborationSettings = firstObject3(collaborationMode?.settings);
+  breakdown.id ??= stringValue2(payload.id);
+  breakdown.cwd ??= stringValue2(payload.cwd);
+  breakdown.title ??= stringValue2(payload.title);
+  breakdown.model ??= stringValue2(payload.model) ?? stringValue2(collaborationSettings?.model);
+  breakdown.provider ??= stringValue2(payload.model_provider);
   breakdown.source ??= stringValue2(payload.source);
   breakdown.originator ??= stringValue2(payload.originator);
   breakdown.threadSource ??= stringValue2(payload.thread_source);
 }
+function applySessionBounds(breakdown, record) {
+  if (!record || typeof record !== "object") return;
+  const object = record;
+  const payload = firstObject3(object.payload);
+  const timestamp3 = dateValue2(object.timestamp) ?? dateValue2(payload?.timestamp);
+  const sessionStartedAt = object.type === "session_meta" ? dateValue2(payload?.timestamp) ?? timestamp3 : timestamp3;
+  if (sessionStartedAt && (!breakdown.startedAt || sessionStartedAt < breakdown.startedAt)) breakdown.startedAt = sessionStartedAt;
+  if (timestamp3 && (!breakdown.endedAt || timestamp3 > breakdown.endedAt)) breakdown.endedAt = timestamp3;
+}
 function isCodexEventMessage(record) {
   if (!record || typeof record !== "object") return false;
   const object = record;
@@ -1887,9 +2092,14 @@ function hasNearbyDuplicatePromptTimelineItem(items, item) {
     return Math.abs(existingTime - itemTime) <= 5e3;
   });
 }
+function codexSourceRaw(source, sessionSource, originator, threadSource) {
+  if (originator && /codex\s+desktop/i.test(originator)) return originator;
+  return source ?? sessionSource ?? originator ?? threadSource;
+}
 function detectSurface(source, threadSource) {
   const raw = `${source ?? ""} ${threadSource ?? ""}`.toLowerCase();
   if (threadSource === "subagent") return { surface: "codex_exec", confidence: "medium", reason: "thread_source is subagent" };
+  if (raw.includes("codex desktop")) return { surface: "local_agent", confidence: "high", reason: "originator metadata identifies Codex Desktop" };
   if (raw.includes("vscode")) return { surface: "vscode_extension", confidence: "high", reason: "source metadata includes vscode" };
   if (raw.includes("cli") || raw.includes("terminal") || raw.includes("tui")) return { surface: "terminal_cli", confidence: "high", reason: "source metadata indicates CLI/terminal" };
   if (raw.includes("exec")) return { surface: "codex_exec", confidence: "medium", reason: "source metadata includes exec" };
@@ -1913,9 +2123,13 @@ function durationMs(startedAt, endedAt) {
 function stringValue2(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
 function codexSourceAppLabel(source, threadSource) {
   if (threadSource === "subagent") return "Codex subagent";
   if (!source) return "Codex";
+  if (/codex\s+desktop/i.test(source)) return "Codex Desktop";
   if (source === "vscode" || source === "codex_vscode" || source === "codex-vscode") return "VS Code";
   if (source === "cli" || source === "terminal" || source === "codex-tui") return "Terminal";
   if (source === "codex_app" || source === "codex-app") return "Codex app";
@@ -1952,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;
@@ -2060,20 +2274,25 @@ 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;
   const repo = resolveRepoInfo(cwd, options.config);
   const warnings = [...repo.warnings, ...breakdown.warnings];
+  const entrypoint = breakdown.entrypoint ?? inferClaudeEntrypointFromPath(file.filePath);
   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(breakdown.entrypoint),
-    sourceAppRaw: breakdown.entrypoint,
+    sourceApp: claudeSourceAppLabel(entrypoint),
+    sourceAppRaw: entrypoint,
     sourcePath: file.filePath,
     repoRoot: repo.repoRoot,
     repoName: repo.repoName,
@@ -2103,9 +2322,9 @@ function claudeFileToUsage(file, index, options, seenUsageKeys) {
     rawEventCount: breakdown.rawEventCount,
     parseStatus: breakdown.parseStatus,
     parseErrors: breakdown.parseErrors,
-    detectedSurface: claudeSurface(breakdown.entrypoint),
+    detectedSurface: claudeSurface(entrypoint),
     surfaceConfidence: "medium",
-    surfaceReason: breakdown.entrypoint ? `Claude Code entrypoint: ${breakdown.entrypoint}` : "Claude Code transcript",
+    surfaceReason: entrypoint ? `Claude Code entrypoint: ${entrypoint}` : "Claude Code transcript",
     userPromptCount: breakdown.userPromptCount,
     assistantMessageCount: breakdown.assistantMessageCount,
     toolCallCount: breakdown.toolCallCount,
@@ -2132,7 +2351,10 @@ function claudeFileToUsage(file, index, options, seenUsageKeys) {
     warnings: cost === void 0 ? [...usage.warnings, "unknown_pricing"] : usage.warnings
   };
 }
-function readClaudeBreakdown(filePath, seenUsageKeys) {
+function inferClaudeEntrypointFromPath(filePath) {
+  return filePath.split(path5.sep).includes("local-agent-mode-sessions") ? "local-agent" : void 0;
+}
+function readClaudeBreakdown(filePath, usageSelection) {
   const breakdown = emptyBreakdown2();
   try {
     const text = fs5.readFileSync(filePath, "utf8");
@@ -2140,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) {
@@ -2152,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);
@@ -2175,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);
@@ -2202,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);
 }
@@ -2261,7 +2580,8 @@ function emptyBreakdown2() {
     parseStatus: "ok",
     parseErrors: [],
     promptTimeline: [],
-    warnings: []
+    warnings: [],
+    usageEvents: []
   };
 }
 function applyPromptTimeline2(breakdown, role, content, timestamp3) {
@@ -2308,13 +2628,13 @@ function inferOutcome2(breakdown) {
 function claudeSurface(entrypoint) {
   const value = entrypoint?.toLowerCase() ?? "";
   if (value.includes("vscode")) return "vscode_extension";
-  if (value.includes("local-agent")) return "local_agent";
+  if (value.includes("local-agent") || value.includes("desktop")) return "local_agent";
   return "terminal_cli";
 }
 function claudeSourceAppLabel(entrypoint) {
   const value = entrypoint?.toLowerCase() ?? "";
   if (value.includes("vscode")) return "VS Code";
-  if (value.includes("local-agent")) return "Claude desktop local agent";
+  if (value.includes("local-agent") || value.includes("desktop")) return "Claude Desktop App";
   if (value === "cli" || value.includes("terminal")) return "Terminal";
   return "Claude Code";
 }
@@ -2411,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({
@@ -2423,20 +3475,25 @@ 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 = {}) {
+function readDashboardData(filters = {}, options = {}) {
   const raw = readRawUsageData();
-  return buildDashboardSnapshot({ ...raw, filters });
+  return buildDashboardSnapshot({ ...raw, sessions: displaySessions(raw.sessions, options), filters });
 }
 function clearScanCache() {
   scanCache = void 0;
@@ -2473,6 +3530,11 @@ function parseFilters(query) {
   if (to) filters.to = to;
   return filters;
 }
+function parseDashboardOptions(query) {
+  return {
+    splitSourceApps: query.splitSourceApps === "true" || query.splitSourceApps === "1"
+  };
+}
 function readPricingData() {
   const config = loadConfig();
   const pricingPath = resolvePricingPath(config);
@@ -2493,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 };
 }
@@ -2512,13 +3574,46 @@ function listQuery(value) {
   const parsed = values.flatMap((item) => typeof item === "string" ? item.split(",") : []).map((item) => item.trim()).filter(Boolean);
   return parsed.length ? parsed : void 0;
 }
+function displaySessions(sessions, options) {
+  if (!options.splitSourceApps) return sessions;
+  return sessions.map((session) => {
+    const sourceApp = sourceScopedAppLabel(session);
+    return sourceApp === session.sourceApp ? session : { ...session, sourceApp };
+  });
+}
+function sourceScopedAppLabel(session) {
+  const app = session.sourceApp || fallbackSurfaceLabel(session.detectedSurface);
+  if (!app || app === "Unknown") return sourceClientLabel(session.sourceClient);
+  if (!shouldScopeApp(app)) return app;
+  return `${sourceClientLabel(session.sourceClient)} on ${app}`;
+}
+function shouldScopeApp(app) {
+  const normalized = app.toLowerCase();
+  return normalized.includes("vs code") || normalized.includes("vscode") || normalized.includes("terminal") || normalized.includes("cli");
+}
+function sourceClientLabel(source) {
+  if (source === "codex") return "Codex";
+  if (source === "claude") return "Claude Code";
+  if (source === "gemini-cli") return "Gemini CLI";
+  if (source === "opencode") return "OpenCode";
+  if (source === "cursor") return "Cursor";
+  return "Unknown";
+}
+function fallbackSurfaceLabel(surface) {
+  if (surface === "terminal_cli") return "Terminal";
+  if (surface === "vscode_extension") return "VS Code";
+  if (surface === "local_agent") return "Desktop local agent";
+  if (surface === "codex_exec") return "Codex";
+  if (surface === "codex_app_cloud") return "Codex app";
+  return "Unknown";
+}
 function runtimeCwd() {
   return process.env.INIT_CWD || process.cwd();
 }
 
 // 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";
@@ -2534,11 +3629,11 @@ var demoPricing = {
 function demoModeEnabled() {
   return process.env.REPOSPEND_DEMO_DATA === "lotr";
 }
-function readDemoDashboardData(filters = {}) {
+function readDemoDashboardData(filters = {}, options = {}) {
   return buildDashboardSnapshot({
     sources: demoSources,
     sourceStats: demoSourceStats,
-    sessions: demoSessions,
+    sessions: displaySessions(demoSessions, options),
     filters
   });
 }
@@ -2796,7 +3891,7 @@ var demoInputs = [
     repo: "rivendell-dashboard",
     title: "Refactor the council-of-elrond planner",
     sourceClient: "claude",
-    sourceApp: "Claude desktop local agent",
+    sourceApp: "Claude Desktop App",
     sourceAppRaw: "claude-desktop-local-agent",
     model: "claude-sonnet-4-6",
     provider: "anthropic",
@@ -3106,7 +4201,7 @@ function detectedSurfaceForApp(sourceApp) {
   if (sourceApp === "VS Code") return "vscode_extension";
   if (sourceApp === "Terminal") return "terminal_cli";
   if (sourceApp === "Codex app") return "codex_app_cloud";
-  if (sourceApp === "Claude desktop local agent") return "local_agent";
+  if (sourceApp === "Claude Desktop App") return "local_agent";
   return "terminal_cli";
 }
 function timestamp2(hour, minute) {
@@ -3326,9 +4421,11 @@ function createServer(options = {}) {
   const app = Fastify({ logger: false });
   app.get("/api/health", async () => ({ ok: true, app: "RepoSpend", version: readPackageVersion() }));
   app.get("/api/dashboard", async (request) => {
-    const filters = parseFilters(request.query);
+    const query = request.query;
+    const filters = parseFilters(query);
+    const dashboardOptions = parseDashboardOptions(query);
     const demoMode = demoModeEnabled();
-    const data = demoMode ? readDemoDashboardData(filters) : readDashboardData(filters);
+    const data = demoMode ? readDemoDashboardData(filters, dashboardOptions) : readDashboardData(filters, dashboardOptions);
     const rtkGain = demoMode ? readDemoRtkGain() : await readRtkGain();
     return {
       ...data,
@@ -3356,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.`);
@@ -3379,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";
@@ -3481,7 +4578,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) => ({
@@ -3514,5 +4611,5 @@ function printHelp() {
   repospend export --format csv
 
 Options:
-  --source all|codex|claude`);
+  --source all|codex|claude|cursor`);
 }