repospend 0.0.7 → 0.0.9

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // apps/server/src/cli.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 
 // packages/core/src/aggregate.ts
 function summarize(sessions) {
@@ -195,7 +195,8 @@ function unique(values) {
   return [...new Set(values)].sort();
 }
 
-// packages/core/src/config.ts
+// packages/core/src/cache.ts
+import crypto from "node:crypto";
 import fs2 from "node:fs";
 import path2 from "node:path";
 
@@ -314,34 +315,97 @@ function isUsablePricing(pricing) {
   return typeof pricing?.inputPerMillion === "number" && pricing.inputPerMillion > 0 && typeof pricing.outputPerMillion === "number" && pricing.outputPerMillion > 0;
 }
 
+// packages/core/src/cache.ts
+var activeCacheVersion = "parse-v1";
+var preparedCacheRoot;
+function parseCacheRoot() {
+  return path2.join(repospendHome(), "cache", activeCacheVersion);
+}
+function readJsonCache(namespace, keyParts) {
+  const cachePath = cacheEntryPath(namespace, keyParts);
+  if (!cachePath || !fs2.existsSync(cachePath)) return void 0;
+  try {
+    return JSON.parse(fs2.readFileSync(cachePath, "utf8"));
+  } catch {
+    fs2.rmSync(cachePath, { force: true });
+    return void 0;
+  }
+}
+function writeJsonCache(namespace, keyParts, value) {
+  const cachePath = cacheEntryPath(namespace, keyParts);
+  if (!cachePath) return;
+  try {
+    fs2.mkdirSync(path2.dirname(cachePath), { recursive: true });
+    fs2.writeFileSync(cachePath, `${JSON.stringify(value)}
+`);
+  } catch {
+  }
+}
+function clearRepoSpendCache() {
+  const target = path2.join(repospendHome(), "cache");
+  const removed = fs2.existsSync(target);
+  fs2.rmSync(target, { recursive: true, force: true });
+  preparedCacheRoot = void 0;
+  return { path: target, removed };
+}
+function cacheEntryPath(namespace, keyParts) {
+  prepareCacheRoot();
+  const safeNamespace = namespace.replace(/[^a-z0-9_-]/gi, "-");
+  const key = crypto.createHash("sha256").update(JSON.stringify(keyParts)).digest("hex");
+  return path2.join(parseCacheRoot(), safeNamespace, `${key}.json`);
+}
+function prepareCacheRoot() {
+  const root = path2.join(repospendHome(), "cache");
+  if (preparedCacheRoot === root) return;
+  preparedCacheRoot = root;
+  try {
+    fs2.mkdirSync(parseCacheRoot(), { recursive: true });
+    for (const entry of fs2.readdirSync(root, { withFileTypes: true })) {
+      if (entry.isDirectory() && entry.name !== activeCacheVersion) {
+        fs2.rmSync(path2.join(root, entry.name), { recursive: true, force: true });
+      }
+    }
+  } catch {
+  }
+}
+
 // packages/core/src/config.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
 function configPath() {
-  return path2.join(repospendHome(), "config.json");
+  return path3.join(repospendHome(), "config.json");
 }
 function loadConfig() {
   return loadConfigWithWarnings().config;
 }
 function loadConfigWithWarnings() {
   const localConfigPath = configPath();
-  if (!fs2.existsSync(localConfigPath)) {
+  if (!fs3.existsSync(localConfigPath)) {
     return { config: {}, warnings: [] };
   }
   try {
-    return { config: JSON.parse(fs2.readFileSync(localConfigPath, "utf8")), warnings: [] };
+    return { config: JSON.parse(fs3.readFileSync(localConfigPath, "utf8")), warnings: [] };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     return { config: {}, warnings: [`Unable to parse ${localConfigPath}: ${message}`] };
   }
 }
+function saveConfig(config) {
+  const localConfigPath = configPath();
+  fs3.mkdirSync(path3.dirname(localConfigPath), { recursive: true });
+  fs3.writeFileSync(localConfigPath, `${JSON.stringify(config, null, 2)}
+`);
+  return loadConfig();
+}
 function normalizePathForMatch(inputPath) {
-  return path2.resolve(inputPath).replace(/\/+$/, "");
+  return path3.resolve(inputPath).replace(/\/+$/, "");
 }
 function aliasForPath(repoRoot, config) {
   const resolvedRoot = normalizePathForMatch(repoRoot);
   const match = config.repos?.find(
     (repo) => repo.paths.some((repoPath) => {
       const candidate = normalizePathForMatch(repoPath);
-      return resolvedRoot === candidate || resolvedRoot.startsWith(`${candidate}${path2.sep}`);
+      return resolvedRoot === candidate || resolvedRoot.startsWith(`${candidate}${path3.sep}`);
     })
   );
   return match?.name;
@@ -861,16 +925,16 @@ function isDashboardVisibleSession(session) {
 }
 
 // packages/core/src/repo.ts
-import fs3 from "node:fs";
-import path3 from "node:path";
+import fs4 from "node:fs";
+import path4 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 = normalizeRoot(path3.resolve(cwd));
+function findGitRoot(cwd, fileSystem = fs4) {
+  let current = normalizeRoot(path4.resolve(cwd));
   while (true) {
-    const gitPath = path3.join(current, ".git");
+    const gitPath = path4.join(current, ".git");
     if (fileSystem.existsSync(gitPath)) {
       try {
         const stat = fileSystem.statSync(gitPath);
@@ -881,19 +945,19 @@ function findGitRoot(cwd, fileSystem = fs3) {
         return current;
       }
     }
-    const parent = path3.dirname(current);
+    const parent = path4.dirname(current);
     if (parent === current) {
       return void 0;
     }
     current = parent;
   }
 }
-function resolveRepoInfo(cwd, config = {}, fileSystem = fs3) {
+function resolveRepoInfo(cwd, config = {}, fileSystem = fs4) {
   const warnings = [];
   const gitRoot = safeFindGitRoot(cwd, fileSystem);
   const repoRoot = gitRoot ?? fallbackWorkspaceRoot(cwd);
   const alias = aliasForPath(repoRoot, config);
-  const repoName = alias ?? (path3.basename(repoRoot) || "unknown-workspace");
+  const repoName = alias ?? (path4.basename(repoRoot) || "unknown-workspace");
   const gitMeta = gitRoot ? readGitMetadata(gitRoot, fileSystem) : { remote: void 0, branch: void 0 };
   if (!gitRoot) {
     warnings.push("repo_unverified_no_git_root");
@@ -915,23 +979,23 @@ function safeFindGitRoot(cwd, fileSystem) {
   }
 }
 function fallbackWorkspaceRoot(cwd) {
-  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 resolved = normalizeRoot(path4.resolve(cwd || process.cwd()));
+  const home = process.env.HOME ? normalizeRoot(path4.resolve(process.env.HOME)) : void 0;
+  if (home && (resolved === home || resolved.startsWith(`${home}${path4.sep}`))) {
+    const relative = path4.relative(home, resolved).split(path4.sep).filter(Boolean);
     const first = relative[0];
-    return first ? path3.join(home, first) : home;
+    return first ? path4.join(home, first) : home;
   }
-  const parts = resolved.split(path3.sep).filter(Boolean);
-  return `${path3.sep}${parts.slice(0, Math.min(parts.length, 3)).join(path3.sep)}`;
+  const parts = resolved.split(path4.sep).filter(Boolean);
+  return `${path4.sep}${parts.slice(0, Math.min(parts.length, 3)).join(path4.sep)}`;
 }
 function readGitMetadata(repoRoot, fileSystem) {
-  const gitPath = path3.join(repoRoot, ".git");
+  const gitPath = path4.join(repoRoot, ".git");
   try {
     const stat = fileSystem.statSync(gitPath);
     const gitDir = stat.isFile() ? resolveGitFile(repoRoot, fileSystem.readFileSync(gitPath, "utf8")) : gitPath;
-    const configPath2 = path3.join(gitDir, "config");
-    const headPath = path3.join(gitDir, "HEAD");
+    const configPath2 = path4.join(gitDir, "config");
+    const headPath = path4.join(gitDir, "HEAD");
     const remote = fileSystem.existsSync(configPath2) ? parseRemote(fileSystem.readFileSync(configPath2, "utf8")) : void 0;
     const branch = fileSystem.existsSync(headPath) ? parseBranch(fileSystem.readFileSync(headPath, "utf8")) : void 0;
     return { remote, branch };
@@ -942,9 +1006,9 @@ function readGitMetadata(repoRoot, fileSystem) {
 function resolveGitFile(repoRoot, contents) {
   const match = contents.match(/^gitdir:\s*(.+)$/m);
   if (!match?.[1]) {
-    return path3.join(repoRoot, ".git");
+    return path4.join(repoRoot, ".git");
   }
-  return path3.resolve(repoRoot, match[1].trim());
+  return path4.resolve(repoRoot, match[1].trim());
 }
 function parseRemote(config) {
   const originMatch = config.match(/\[remote "origin"\][\s\S]*?\n\s*url\s*=\s*(.+)/);
@@ -957,9 +1021,9 @@ function parseBranch(head) {
 
 // packages/core/src/sources/codex.ts
 import { spawnSync } from "node:child_process";
-import fs4 from "node:fs";
+import fs5 from "node:fs";
 import os2 from "node:os";
-import path4 from "node:path";
+import path5 from "node:path";
 import { fileURLToPath } from "node:url";
 import Database from "better-sqlite3";
 
@@ -1398,28 +1462,29 @@ function numberFromKeys(object, keys) {
 }
 
 // packages/core/src/sources/codex.ts
+var codexSessionCacheVersion = "codex-session-v1";
 var nativeSqliteRebuildAttempted = false;
 function scanCodex(options) {
-  const codexHome = options.codexHome ?? path4.join(os2.homedir(), ".codex");
-  const statePath = path4.join(codexHome, "state_5.sqlite");
-  const sessionsPath = path4.join(codexHome, "sessions");
+  const codexHome = options.codexHome ?? path5.join(os2.homedir(), ".codex");
+  const statePath = path5.join(codexHome, "state_5.sqlite");
+  const sessionsPath = path5.join(codexHome, "sessions");
   const warnings = [];
   const sessions = [];
-  const stateExists = fs4.existsSync(statePath);
-  const sessionsExists = fs4.existsSync(sessionsPath);
+  const stateExists = fs5.existsSync(statePath);
+  const sessionsExists = fs5.existsSync(sessionsPath);
   if (!stateExists) {
     warnings.push(`Codex SQLite state not found at ${statePath}`);
   }
   if (!sessionsExists) {
     warnings.push(`Codex sessions directory not found at ${sessionsPath}`);
   }
-  const sessionFiles = sessionsExists ? indexSessionFiles(sessionsPath, warnings) : /* @__PURE__ */ new Map();
+  const sessionFiles = sessionsExists ? indexSessionFiles(sessionsPath, warnings, options.scanWindow) : /* @__PURE__ */ new Map();
   if (stateExists) {
     const stateSessions = readThreads(statePath, sessionFiles, options, warnings);
     sessions.push(...stateSessions);
   }
   if (sessionsExists) {
-    sessions.push(...readStandaloneSessions(sessionFiles, options).filter((session) => !hasImportedSession(sessions, session)));
+    sessions.push(...readStandaloneSessions(remainingStandaloneSessionFiles(sessionFiles, sessions), options).filter((session) => !hasImportedSession(sessions, session)));
   }
   return {
     source: {
@@ -1462,8 +1527,8 @@ 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();
+    const importedModels = readImportedModelMap(options.codexHome ?? path5.join(os2.homedir(), ".codex"), warnings);
+    const rows = db.prepare(`SELECT ${selectedColumns.map((column) => `"${column}"`).join(", ")} FROM threads`).all().filter((row) => rowMatchesScanWindow(row, options.scanWindow));
     const sessions = rows.map((row, index) => threadToUsage(row, index, sessionFiles, options, importedModels));
     return attributeSubagentsToParentSurfaces(sessions, rows);
   } catch (error) {
@@ -1522,7 +1587,7 @@ function attemptNativeSqliteRebuild(warnings) {
     warnings.push("Codex SQLite native module mismatch detected, but RepoSpend could not locate its package root for an automatic rebuild.");
     return false;
   }
-  const packageManager = fs4.existsSync(path4.join(packageRoot, "pnpm-lock.yaml")) ? "pnpm" : "npm";
+  const packageManager = fs5.existsSync(path5.join(packageRoot, "pnpm-lock.yaml")) ? "pnpm" : "npm";
   const result = spawnSync(packageManager, ["rebuild", "better-sqlite3"], {
     cwd: packageRoot,
     encoding: "utf8",
@@ -1536,8 +1601,8 @@ function attemptNativeSqliteRebuild(warnings) {
 }
 function findRepoSpendPackageRoot() {
   const starts = [
-    process.argv[1] ? path4.dirname(fs4.realpathSync(process.argv[1])) : void 0,
-    path4.dirname(fileURLToPath(import.meta.url)),
+    process.argv[1] ? path5.dirname(fs5.realpathSync(process.argv[1])) : void 0,
+    path5.dirname(fileURLToPath(import.meta.url)),
     process.cwd()
   ].filter((item) => Boolean(item));
   for (const start of starts) {
@@ -1547,17 +1612,17 @@ function findRepoSpendPackageRoot() {
   return void 0;
 }
 function findPackageRootNamedRepoSpend(start) {
-  let current = path4.resolve(start);
+  let current = path5.resolve(start);
   while (true) {
-    const packagePath = path4.join(current, "package.json");
-    if (fs4.existsSync(packagePath)) {
+    const packagePath = path5.join(current, "package.json");
+    if (fs5.existsSync(packagePath)) {
       try {
-        const packageJson = JSON.parse(fs4.readFileSync(packagePath, "utf8"));
+        const packageJson = JSON.parse(fs5.readFileSync(packagePath, "utf8"));
         if (packageJson.name === "repospend") return current;
       } catch {
       }
     }
-    const parent = path4.dirname(current);
+    const parent = path5.dirname(current);
     if (parent === current) return void 0;
     current = parent;
   }
@@ -1619,7 +1684,7 @@ function threadToUsage(row, index, sessionFiles, options, importedModels = /* @_
     messageCount: sessionBreakdown.messageCount,
     rawTokenTotal: dbTokens || sessionBreakdown.totalTokens || void 0,
     warnings,
-    codexHome: options.codexHome ?? path4.join(os2.homedir(), ".codex"),
+    codexHome: options.codexHome ?? path5.join(os2.homedir(), ".codex"),
     durationMs: durationMs(startedAt, endedAt),
     rawEventCount: sessionBreakdown.rawEventCount,
     parseStatus: sessionBreakdown.parseStatus,
@@ -1693,7 +1758,7 @@ function readStandaloneSessions(sessionFiles, options) {
       messageCount: breakdown.messageCount,
       rawTokenTotal: breakdown.totalTokens || void 0,
       warnings: [...repo.warnings, ...breakdown.warnings],
-      codexHome: options.codexHome ?? path4.join(os2.homedir(), ".codex"),
+      codexHome: options.codexHome ?? path5.join(os2.homedir(), ".codex"),
       durationMs: durationMs(breakdown.startedAt, breakdown.endedAt),
       rawEventCount: breakdown.rawEventCount,
       parseStatus: breakdown.parseStatus,
@@ -1738,13 +1803,18 @@ function hasImportedSession(sessions, candidate) {
     return Boolean(candidatePath && sessionPath && candidatePath === sessionPath);
   });
 }
+function remainingStandaloneSessionFiles(sessionFiles, importedSessions) {
+  const importedIds = new Set(importedSessions.map((session) => session.id).filter(Boolean));
+  const importedPaths = new Set(importedSessions.map((session) => comparableSourcePath(session.sourcePath)).filter(Boolean));
+  return new Map([...sessionFiles.entries()].filter(([id, sourcePath]) => !importedIds.has(id) && !importedPaths.has(comparableSourcePath(sourcePath))));
+}
 function readImportedModelMap(codexHome, warnings) {
-  const importsPath = path4.join(codexHome, "external_agent_session_imports.json");
+  const importsPath = path5.join(codexHome, "external_agent_session_imports.json");
   const models = /* @__PURE__ */ new Map();
-  if (!fs4.existsSync(importsPath)) return models;
+  if (!fs5.existsSync(importsPath)) return models;
   let parsed;
   try {
-    parsed = JSON.parse(fs4.readFileSync(importsPath, "utf8"));
+    parsed = JSON.parse(fs5.readFileSync(importsPath, "utf8"));
   } catch (error) {
     warnings.push(`Unable to read Codex external import index at ${importsPath}: ${errorMessage(error)}`);
     return models;
@@ -1754,7 +1824,7 @@ function readImportedModelMap(codexHome, warnings) {
     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;
+    if (!importedThreadId || !sourcePath || !fs5.existsSync(sourcePath)) continue;
     const model = readImportedSourceModel(sourcePath, warnings);
     if (model) models.set(importedThreadId, { model, provider: providerForModel(model) });
   }
@@ -1764,7 +1834,7 @@ function readImportedSourceModel(sourcePath, warnings) {
   const counts = /* @__PURE__ */ new Map();
   let content;
   try {
-    content = fs4.readFileSync(sourcePath, "utf8");
+    content = fs5.readFileSync(sourcePath, "utf8");
   } catch (error) {
     warnings.push(`Unable to read Codex external import source at ${sourcePath}: ${errorMessage(error)}`);
     return void 0;
@@ -1802,12 +1872,13 @@ function normalizeVerbatimPath(value) {
 function comparableSourcePath(value) {
   return normalizeVerbatimPath(value)?.replace(/\\/g, "/");
 }
-function indexSessionFiles(sessionsPath, warnings) {
+function indexSessionFiles(sessionsPath, warnings, scanWindow) {
   const files = /* @__PURE__ */ new Map();
   try {
     walk(sessionsPath, (filePath) => {
       if (!/\.(jsonl|json|log)$/i.test(filePath)) return;
-      const id = path4.basename(filePath).replace(/\.(jsonl|json|log)$/i, "");
+      if (!fileMayOverlapScanWindow(filePath, scanWindow)) return;
+      const id = path5.basename(filePath).replace(/\.(jsonl|json|log)$/i, "");
       files.set(id, filePath);
     });
   } catch (error) {
@@ -1815,9 +1886,26 @@ function indexSessionFiles(sessionsPath, warnings) {
   }
   return files;
 }
+function rowMatchesScanWindow(row, scanWindow) {
+  if (!scanWindow?.fromMs && !scanWindow?.toMs) return true;
+  const updatedAt = timestampMs(row.updated_at);
+  const createdAt = timestampMs(row.created_at);
+  const latestTimestamp = updatedAt ?? createdAt;
+  if (scanWindow.fromMs !== void 0 && latestTimestamp !== void 0 && latestTimestamp < scanWindow.fromMs) return false;
+  if (scanWindow.toMs !== void 0 && createdAt !== void 0 && createdAt > scanWindow.toMs) return false;
+  return true;
+}
+function fileMayOverlapScanWindow(filePath, scanWindow) {
+  if (!scanWindow?.fromMs) return true;
+  try {
+    return fs5.statSync(filePath).mtimeMs >= scanWindow.fromMs;
+  } catch {
+    return true;
+  }
+}
 function walk(root, onFile) {
-  for (const entry of fs4.readdirSync(root, { withFileTypes: true })) {
-    const fullPath = path4.join(root, entry.name);
+  for (const entry of fs5.readdirSync(root, { withFileTypes: true })) {
+    const fullPath = path5.join(root, entry.name);
     if (entry.isDirectory()) {
       walk(fullPath, onFile);
     } else if (entry.isFile()) {
@@ -1826,9 +1914,12 @@ function walk(root, onFile) {
   }
 }
 function readSessionBreakdown(filePath) {
+  const cacheKey = sessionBreakdownCacheKey(filePath);
+  const cached = cacheKey ? readJsonCache("codex-session", cacheKey) : void 0;
+  if (cached) return cached;
   const breakdown = emptyBreakdown();
   try {
-    const text = fs4.readFileSync(filePath, "utf8");
+    const text = fs5.readFileSync(filePath, "utf8");
     const parse = parseSessionRecords(text);
     const records = parse.records;
     breakdown.rawEventCount = records.length;
@@ -1860,8 +1951,22 @@ function readSessionBreakdown(filePath) {
     breakdown.parseErrors.push(message);
     breakdown.warnings.push(message);
   }
+  if (cacheKey) writeJsonCache("codex-session", cacheKey, breakdown);
   return breakdown;
 }
+function sessionBreakdownCacheKey(filePath) {
+  try {
+    const stat = fs5.statSync(filePath);
+    return {
+      version: codexSessionCacheVersion,
+      filePath: path5.resolve(filePath),
+      size: stat.size,
+      mtimeMs: stat.mtimeMs
+    };
+  } catch {
+    return void 0;
+  }
+}
 function parseSessionRecords(text) {
   const trimmed = text.trim();
   if (!trimmed) return { records: [], errors: [] };
@@ -1966,7 +2071,7 @@ function emptyBreakdown() {
   };
 }
 function fallbackCwdFromPath(filePath) {
-  return filePath ? path4.dirname(filePath) : process.cwd();
+  return filePath ? path5.dirname(filePath) : process.cwd();
 }
 function applySessionMetadata(breakdown, record) {
   if (!record || typeof record !== "object") return;
@@ -2146,6 +2251,12 @@ function dateValue2(value) {
   }
   return void 0;
 }
+function timestampMs(value) {
+  const date = dateValue2(value);
+  if (!date) return void 0;
+  const timestamp3 = new Date(date).getTime();
+  return Number.isFinite(timestamp3) ? timestamp3 : void 0;
+}
 function errorMessage(error) {
   const message = error instanceof Error ? error.message : String(error);
   if (message.includes("NODE_MODULE_VERSION") && message.includes("better_sqlite3.node")) {
@@ -2157,24 +2268,24 @@ function errorMessage(error) {
 }
 
 // packages/core/src/sources/claude.ts
-import fs5 from "node:fs";
+import fs6 from "node:fs";
 import os3 from "node:os";
-import path5 from "node:path";
+import path6 from "node:path";
 function scanClaude(options) {
   const claudeHome = options.claudeHome ?? defaultClaudeHome();
-  const historyPath = path5.join(claudeHome, "history.jsonl");
+  const historyPath = path6.join(claudeHome, "history.jsonl");
   const warnings = [];
   const discovery = discoverClaudeSessionFiles(claudeHome, warnings, Boolean(options.claudeHome));
-  const historyExists = fs5.existsSync(historyPath);
-  const orderedFiles = discovery.files.map((file) => ({ file, mtimeMs: safeMtimeMs(file.filePath) })).sort((a, b) => a.mtimeMs - b.mtimeMs);
+  const historyExists = fs6.existsSync(historyPath);
+  const orderedFiles = discovery.files.map((file) => ({ file, mtimeMs: safeMtimeMs(file.filePath) })).filter(({ mtimeMs }) => !options.scanWindow?.fromMs || mtimeMs >= options.scanWindow.fromMs).sort((a, b) => a.mtimeMs - b.mtimeMs);
   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;
   const malformedFileCount = sessions.filter((session) => session.parseErrors?.some((error) => error.startsWith("jsonl_line_"))).length;
-  const projectsPath = path5.join(claudeHome, "projects");
-  if (!discovery.projectsPaths.some((candidate) => fs5.existsSync(candidate))) {
+  const projectsPath = path6.join(claudeHome, "projects");
+  if (!discovery.projectsPaths.some((candidate) => fs6.existsSync(candidate))) {
     warnings.push(`Claude Code projects directory not found at ${projectsPath}`);
   }
   return {
@@ -2193,7 +2304,7 @@ function scanClaude(options) {
       claudeHome,
       projectsPath,
       historyPath,
-      projectsExists: discovery.projectsPaths.some((candidate) => fs5.existsSync(candidate)),
+      projectsExists: discovery.projectsPaths.some((candidate) => fs6.existsSync(candidate)),
       historyExists,
       sessionFileCount: discovery.files.length,
       projectDirCount: discovery.projectDirs.size,
@@ -2209,7 +2320,7 @@ function scanClaude(options) {
 function discoverClaudeSessionFiles(claudeHome, warnings, explicitHome) {
   const files = [];
   const projectDirs = /* @__PURE__ */ new Set();
-  const projectsPaths = explicitHome ? [path5.join(claudeHome, "projects")] : unique3([...configuredClaudeHomes(claudeHome).map((root) => path5.join(root, "projects")), path5.join(os3.homedir(), ".config", "claude", "projects")]);
+  const projectsPaths = explicitHome ? [path6.join(claudeHome, "projects")] : unique3([...configuredClaudeHomes(claudeHome).map((root) => path6.join(root, "projects")), path6.join(os3.homedir(), ".config", "claude", "projects")]);
   for (const projectsPath of projectsPaths) {
     collectProjectFiles(projectsPath, files, projectDirs, warnings);
   }
@@ -2226,16 +2337,16 @@ function discoverClaudeSessionFiles(claudeHome, warnings, explicitHome) {
 }
 function configuredClaudeHomes(primaryHome) {
   if (process.env.CLAUDE_CONFIG_DIR) {
-    return process.env.CLAUDE_CONFIG_DIR.split(",").map((item) => item.trim()).filter(Boolean).map((item) => path5.resolve(item));
+    return process.env.CLAUDE_CONFIG_DIR.split(",").map((item) => item.trim()).filter(Boolean).map((item) => path6.resolve(item));
   }
   return [primaryHome];
 }
 function collectProjectFiles(projectsPath, files, projectDirs, warnings) {
-  if (!fs5.existsSync(projectsPath)) return;
+  if (!fs6.existsSync(projectsPath)) return;
   try {
-    for (const entry of fs5.readdirSync(projectsPath, { withFileTypes: true })) {
+    for (const entry of fs6.readdirSync(projectsPath, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      const projectDir = path5.join(projectsPath, entry.name);
+      const projectDir = path6.join(projectsPath, entry.name);
       projectDirs.add(projectDir);
       walk2(projectDir, 5, (filePath) => {
         if (filePath.endsWith(".jsonl")) files.push({ filePath, projectDir, projectsPath });
@@ -2246,15 +2357,15 @@ function collectProjectFiles(projectsPath, files, projectDirs, warnings) {
   }
 }
 function collectDesktopSessionFiles(root, files, projectDirs, warnings) {
-  if (!fs5.existsSync(root)) return;
+  if (!fs6.existsSync(root)) return;
   try {
     walk2(root, 8, (filePath) => {
       if (!filePath.endsWith(".jsonl")) return;
-      const parts = filePath.split(path5.sep);
+      const parts = filePath.split(path6.sep);
       const projectsIndex = parts.lastIndexOf("projects");
       const hasProjectSegment = projectsIndex >= 0 && projectsIndex < parts.length - 2;
-      const projectsPath = hasProjectSegment ? parts.slice(0, projectsIndex + 1).join(path5.sep) || path5.sep : root;
-      const projectDir = hasProjectSegment ? parts.slice(0, projectsIndex + 2).join(path5.sep) || path5.sep : path5.dirname(filePath);
+      const projectsPath = hasProjectSegment ? parts.slice(0, projectsIndex + 1).join(path6.sep) || path6.sep : root;
+      const projectDir = hasProjectSegment ? parts.slice(0, projectsIndex + 2).join(path6.sep) || path6.sep : path6.dirname(filePath);
       projectDirs.add(projectDir);
       files.push({ filePath, projectDir, projectsPath });
     });
@@ -2264,9 +2375,9 @@ function collectDesktopSessionFiles(root, files, projectDirs, warnings) {
 }
 function walk2(root, maxDepth, onFile, depth = 0) {
   if (depth > maxDepth) return;
-  for (const entry of fs5.readdirSync(root, { withFileTypes: true })) {
+  for (const entry of fs6.readdirSync(root, { withFileTypes: true })) {
     if (entry.name === "node_modules" || entry.name === ".git") continue;
-    const fullPath = path5.join(root, entry.name);
+    const fullPath = path6.join(root, entry.name);
     if (entry.isDirectory()) {
       walk2(fullPath, maxDepth, onFile, depth + 1);
     } else if (entry.isFile()) {
@@ -2280,7 +2391,7 @@ function claudeFileToUsages(file, index, options, usageSelection) {
   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 id = breakdown.id ?? (path6.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);
@@ -2352,12 +2463,12 @@ function claudeBreakdownToUsage(file, index, options, breakdown, idSuffix = "")
   };
 }
 function inferClaudeEntrypointFromPath(filePath) {
-  return filePath.split(path5.sep).includes("local-agent-mode-sessions") ? "local-agent" : void 0;
+  return filePath.split(path6.sep).includes("local-agent-mode-sessions") ? "local-agent" : void 0;
 }
 function readClaudeBreakdown(filePath, usageSelection) {
   const breakdown = emptyBreakdown2();
   try {
-    const text = fs5.readFileSync(filePath, "utf8");
+    const text = fs6.readFileSync(filePath, "utf8");
     const parse = parseJsonLines2(text);
     breakdown.rawEventCount = parse.records.length;
     breakdown.parseErrors = parse.errors;
@@ -2412,7 +2523,7 @@ function selectClaudeUsageOccurrences(files) {
   for (const file of files) {
     let parse;
     try {
-      parse = parseJsonLines2(fs5.readFileSync(file.filePath, "utf8"));
+      parse = parseJsonLines2(fs6.readFileSync(file.filePath, "utf8"));
     } catch {
       continue;
     }
@@ -2446,7 +2557,7 @@ function usageDedupKey(record, message) {
   return `${requestId}:${messageId}`;
 }
 function occurrenceKey(filePath, recordIndex) {
-  return `${path5.resolve(filePath)}:${recordIndex}`;
+  return `${path6.resolve(filePath)}:${recordIndex}`;
 }
 function cloneUsage(usage) {
   return {
@@ -2610,12 +2721,12 @@ function normalizeTimelineText2(text) {
   return text.replace(/\s+/g, " ").trim().slice(0, 1e3);
 }
 function inferProjectPath(projectDir, projectsPath) {
-  const name = path5.basename(projectDir);
+  const name = path6.basename(projectDir);
   if (name.startsWith("-")) {
-    return `${path5.sep}${name.slice(1).split("-").filter(Boolean).join(path5.sep)}`;
+    return `${path6.sep}${name.slice(1).split("-").filter(Boolean).join(path6.sep)}`;
   }
-  const relative = path5.relative(projectsPath, projectDir);
-  return relative && !relative.startsWith("..") ? path5.join(projectsPath, relative) : projectDir;
+  const relative = path6.relative(projectsPath, projectDir);
+  return relative && !relative.startsWith("..") ? path6.join(projectsPath, relative) : projectDir;
 }
 function inferOutcome2(breakdown) {
   if (breakdown.parseStatus === "failed") return "failed";
@@ -2639,20 +2750,20 @@ function claudeSourceAppLabel(entrypoint) {
   return "Claude Code";
 }
 function defaultClaudeHome() {
-  return process.env.CLAUDE_CONFIG_DIR?.split(",").map((item) => item.trim()).filter(Boolean)[0] ?? path5.join(os3.homedir(), ".claude");
+  return process.env.CLAUDE_CONFIG_DIR?.split(",").map((item) => item.trim()).filter(Boolean)[0] ?? path6.join(os3.homedir(), ".claude");
 }
 function defaultDesktopSessionRoots() {
   const home = os3.homedir();
-  const xdg = process.env.XDG_CONFIG_HOME || path5.join(home, ".config");
+  const xdg = process.env.XDG_CONFIG_HOME || path6.join(home, ".config");
   return [
-    path5.join(home, "Library", "Application Support", "Claude", "local-agent-mode-sessions"),
-    path5.join(xdg, "Claude", "local-agent-mode-sessions")
+    path6.join(home, "Library", "Application Support", "Claude", "local-agent-mode-sessions"),
+    path6.join(xdg, "Claude", "local-agent-mode-sessions")
   ];
 }
 function uniqueSessionFiles(files) {
   const seen = /* @__PURE__ */ new Set();
   return files.filter((file) => {
-    const key = path5.resolve(file.filePath);
+    const key = path6.resolve(file.filePath);
     if (seen.has(key)) return false;
     seen.add(key);
     return true;
@@ -2662,10 +2773,10 @@ function unique3(values) {
   return [...new Set(values)];
 }
 function countHistoryEntries(historyPath) {
-  if (!fs5.existsSync(historyPath)) return 0;
+  if (!fs6.existsSync(historyPath)) return 0;
   let entryCount = 0;
   try {
-    for (const line of fs5.readFileSync(historyPath, "utf8").split(/\r?\n/).filter(Boolean)) {
+    for (const line of fs6.readFileSync(historyPath, "utf8").split(/\r?\n/).filter(Boolean)) {
       try {
         JSON.parse(line);
         entryCount += 1;
@@ -2725,16 +2836,16 @@ function errorMessage2(error) {
 }
 function safeMtimeMs(filePath) {
   try {
-    return fs5.statSync(filePath).mtimeMs;
+    return fs6.statSync(filePath).mtimeMs;
   } catch {
     return 0;
   }
 }
 
 // packages/core/src/sources/cursor.ts
-import fs6 from "node:fs";
+import fs7 from "node:fs";
 import os4 from "node:os";
-import path6 from "node:path";
+import path7 from "node:path";
 import Database2 from "better-sqlite3";
 var parserVersion = "cursor-v1";
 var maxJsonlBytes = 20 * 1024 * 1024;
@@ -2742,19 +2853,21 @@ 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 cursorHome = options.cursorHome ?? path7.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 jsonlFiles = discovery.jsonlFiles.filter((filePath) => fileMayOverlapScanWindow2(filePath, options.scanWindow));
+  const databaseFiles = discovery.databaseFiles.filter((filePath) => fileMayOverlapScanWindow2(filePath, options.scanWindow));
+  const jsonlCandidates = jsonlFiles.map((filePath) => cursorJsonlToCandidate(filePath, cursorHome));
+  const databaseCandidates = 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)) {
+  if (!fs7.existsSync(cursorHome)) {
     discovery.warnings.push(`Cursor home directory not found at ${cursorHome}`);
   }
-  if (!fs6.existsSync(discovery.statePath)) {
+  if (!fs7.existsSync(discovery.statePath)) {
     discovery.warnings.push(`Cursor global state database not found at ${discovery.statePath}`);
   }
   return {
@@ -2775,11 +2888,11 @@ function scanCursor(options) {
       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,
+      projectsExists: fs7.existsSync(discovery.projectsPath),
+      stateExists: fs7.existsSync(discovery.statePath),
+      sessionsExists: jsonlFiles.length > 0,
+      sessionFileCount: jsonlFiles.length,
+      databaseFileCount: databaseFiles.length,
       skippedFileCount: discovery.skippedFileCount,
       sessionsImported: sessions.length,
       parseFailureCount,
@@ -2797,7 +2910,7 @@ function discoverCursorFiles(cursorHome, explicitHome) {
   const databaseFiles = [];
   let skippedFileCount = 0;
   for (const root of roots) {
-    if (!fs6.existsSync(root)) continue;
+    if (!fs7.existsSync(root)) continue;
     try {
       if (isReadableRegularFile(root, maxDatabaseBytes)) {
         databaseFiles.push(root);
@@ -2821,7 +2934,7 @@ function discoverCursorFiles(cursorHome, explicitHome) {
   }
   return {
     roots,
-    projectsPath: path6.join(cursorHome, "projects"),
+    projectsPath: path7.join(cursorHome, "projects"),
     globalStoragePath: appPaths.globalStoragePath,
     workspaceStoragePath: appPaths.workspaceStoragePath,
     statePath: appPaths.statePath,
@@ -2835,12 +2948,12 @@ function cursorOwnedGlobalStorageRoots(globalStoragePath) {
   return cursorOwnedChildDirs(globalStoragePath);
 }
 function cursorOwnedWorkspaceStorageRoots(workspaceStoragePath) {
-  if (!fs6.existsSync(workspaceStoragePath)) return [];
+  if (!fs7.existsSync(workspaceStoragePath)) return [];
   const roots = [];
   try {
-    for (const workspace of fs6.readdirSync(workspaceStoragePath, { withFileTypes: true })) {
+    for (const workspace of fs7.readdirSync(workspaceStoragePath, { withFileTypes: true })) {
       if (!workspace.isDirectory()) continue;
-      roots.push(...cursorOwnedChildDirs(path6.join(workspaceStoragePath, workspace.name)));
+      roots.push(...cursorOwnedChildDirs(path7.join(workspaceStoragePath, workspace.name)));
     }
   } catch {
     return [];
@@ -2848,9 +2961,9 @@ function cursorOwnedWorkspaceStorageRoots(workspaceStoragePath) {
   return roots;
 }
 function cursorOwnedChildDirs(root) {
-  if (!fs6.existsSync(root)) return [];
+  if (!fs7.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));
+    return fs7.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && cursorStoragePrefixes.some((prefix) => entry.name.toLowerCase().startsWith(prefix))).map((entry) => path7.join(root, entry.name));
   } catch {
     return [];
   }
@@ -2858,35 +2971,35 @@ function cursorOwnedChildDirs(root) {
 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");
+    const appData = process.env.APPDATA ?? path7.join(home, "AppData", "Roaming");
+    const globalStoragePath2 = path7.join(appData, "Cursor", "User", "globalStorage");
     return {
       globalStoragePath: globalStoragePath2,
-      workspaceStoragePath: path6.join(appData, "Cursor", "User", "workspaceStorage"),
-      statePath: path6.join(globalStoragePath2, "state.vscdb")
+      workspaceStoragePath: path7.join(appData, "Cursor", "User", "workspaceStorage"),
+      statePath: path7.join(globalStoragePath2, "state.vscdb")
     };
   }
   if (process.platform === "darwin") {
-    const globalStoragePath2 = path6.join(home, "Library", "Application Support", "Cursor", "User", "globalStorage");
+    const globalStoragePath2 = path7.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")
+      workspaceStoragePath: path7.join(home, "Library", "Application Support", "Cursor", "User", "workspaceStorage"),
+      statePath: path7.join(globalStoragePath2, "state.vscdb")
     };
   }
-  const xdg = process.env.XDG_CONFIG_HOME || path6.join(home, ".config");
-  const globalStoragePath = path6.join(xdg, "Cursor", "User", "globalStorage");
+  const xdg = process.env.XDG_CONFIG_HOME || path7.join(home, ".config");
+  const globalStoragePath = path7.join(xdg, "Cursor", "User", "globalStorage");
   return {
     globalStoragePath,
-    workspaceStoragePath: path6.join(xdg, "Cursor", "User", "workspaceStorage"),
-    statePath: path6.join(globalStoragePath, "state.vscdb")
+    workspaceStoragePath: path7.join(xdg, "Cursor", "User", "workspaceStorage"),
+    statePath: path7.join(globalStoragePath, "state.vscdb")
   };
 }
 function walk3(root, maxDepth, onFile, depth = 0) {
   if (depth > maxDepth) return;
-  for (const entry of fs6.readdirSync(root, { withFileTypes: true })) {
+  for (const entry of fs7.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);
+    const fullPath = path7.join(root, entry.name);
     if (entry.isDirectory()) {
       walk3(fullPath, maxDepth, onFile, depth + 1);
     } else if (entry.isFile()) {
@@ -2896,22 +3009,34 @@ function walk3(root, maxDepth, onFile, depth = 0) {
 }
 function isReadableRegularFile(filePath, maxBytes) {
   try {
-    fs6.accessSync(filePath, fs6.constants.R_OK);
-    const stat = fs6.statSync(filePath);
+    fs7.accessSync(filePath, fs7.constants.R_OK);
+    const stat = fs7.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;
+  const aTranscript = a.includes(`${path7.sep}agent-transcripts${path7.sep}`) ? 0 : 1;
+  const bTranscript = b.includes(`${path7.sep}agent-transcripts${path7.sep}`) ? 0 : 1;
   return aTranscript - bTranscript || a.localeCompare(b);
 }
+function fileMayOverlapScanWindow2(filePath, scanWindow) {
+  if (!scanWindow?.fromMs && !scanWindow?.toMs) return true;
+  const inferredTimestamp = timestampMs2(inferDateFromCursorPath(filePath));
+  if (scanWindow.fromMs !== void 0 && inferredTimestamp !== void 0 && inferredTimestamp < scanWindow.fromMs) return false;
+  if (scanWindow.toMs !== void 0 && inferredTimestamp !== void 0 && inferredTimestamp > scanWindow.toMs) return false;
+  if (scanWindow.fromMs === void 0) return true;
+  try {
+    return fs7.statSync(filePath).mtimeMs >= scanWindow.fromMs;
+  } catch {
+    return true;
+  }
+}
 function cursorJsonlToCandidate(filePath, cursorHome) {
   const breakdown = emptyBreakdown3();
   try {
-    const parse = parseJsonLines3(fs6.readFileSync(filePath, "utf8"));
+    const parse = parseJsonLines3(fs7.readFileSync(filePath, "utf8"));
     breakdown.rawEventCount = parse.records.length;
     breakdown.parseErrors = parse.errors;
     breakdown.parseStatus = parse.errors.length ? parse.records.length ? "partial" : "failed" : "ok";
@@ -2923,7 +3048,12 @@ function cursorJsonlToCandidate(filePath, cursorHome) {
     breakdown.parseErrors.push(message);
     breakdown.warnings.push(message);
   }
-  if (!breakdown.id) breakdown.id = path6.basename(filePath).replace(/\.jsonl$/i, "") || void 0;
+  if (!breakdown.id) breakdown.id = path7.basename(filePath).replace(/\.jsonl$/i, "") || void 0;
+  const fallbackDate = inferDateFromCursorPath(filePath) ?? fileModifiedDate(filePath);
+  if (fallbackDate) {
+    breakdown.startedAt ??= fallbackDate;
+    breakdown.endedAt ??= fallbackDate;
+  }
   return {
     sourcePath: filePath,
     surface: inferSurfaceFromPath(filePath),
@@ -3193,7 +3323,7 @@ function finalizeBreakdown(breakdown) {
 }
 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 id = breakdown.id ?? `${path7.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;
@@ -3272,21 +3402,81 @@ function candidateToUsage(candidate, index, options) {
   };
 }
 function inferProjectPathFromCursorPath(filePath, cursorHome) {
-  const parts = filePath.split(path6.sep);
+  const parts = filePath.split(path7.sep);
   const projectsIndex = parts.lastIndexOf("projects");
   if (projectsIndex >= 0 && projectsIndex < parts.length - 1) {
     const projectId = parts[projectsIndex + 1];
+    const decodedProjectPath = decodeCursorProjectId(projectId);
+    if (decodedProjectPath) return decodedProjectPath;
     if (projectId?.startsWith("-")) {
-      return `${path6.sep}${projectId.slice(1).split("-").filter(Boolean).join(path6.sep)}`;
+      return `${path7.sep}${projectId.slice(1).split("-").filter(Boolean).join(path7.sep)}`;
     }
-    if (projectId) return path6.join(cursorHome, "projects", projectId);
+    if (projectId) return path7.join(cursorHome, "projects", projectId);
   }
   return void 0;
 }
+function inferDateFromCursorPath(filePath) {
+  const parts = filePath.split(path7.sep);
+  for (const part of parts) {
+    if (!/^\d{10,13}$/.test(part)) continue;
+    const date = dateValue4(Number(part));
+    if (date) return date;
+  }
+  return void 0;
+}
+function timestampMs2(value) {
+  if (!value) return void 0;
+  const timestamp3 = new Date(value).getTime();
+  return Number.isFinite(timestamp3) ? timestamp3 : void 0;
+}
+function fileModifiedDate(filePath) {
+  try {
+    return fs7.statSync(filePath).mtime.toISOString();
+  } catch {
+    return void 0;
+  }
+}
+function decodeCursorProjectId(projectId) {
+  if (!projectId) return void 0;
+  const id = projectId.startsWith("-") ? projectId.slice(1) : projectId;
+  const tokens2 = id.split("-").filter(Boolean);
+  if (tokens2.length < 2) return void 0;
+  const root = cursorProjectRoot(tokens2);
+  if (!root) return void 0;
+  const matched = matchEncodedPath(root.path, tokens2.slice(root.consumed));
+  if (matched) return matched;
+  return path7.join(root.path, ...tokens2.slice(root.consumed));
+}
+function cursorProjectRoot(tokens2) {
+  if (tokens2[0] === "Users" && tokens2[1]) return { path: path7.join(path7.sep, "Users", tokens2[1]), consumed: 2 };
+  if (tokens2[0] === "home" && tokens2[1]) return { path: path7.join(path7.sep, "home", tokens2[1]), consumed: 2 };
+  if (tokens2[0] === "tmp") return { path: path7.join(path7.sep, "tmp"), consumed: 1 };
+  if (/^[A-Za-z]$/.test(tokens2[0] ?? "") && tokens2[1]) return { path: `${tokens2[0]?.toUpperCase()}:\\`, consumed: 1 };
+  return void 0;
+}
+function matchEncodedPath(root, tokens2) {
+  if (!tokens2.length) return fs7.existsSync(root) ? root : void 0;
+  if (!fs7.existsSync(root)) return void 0;
+  try {
+    for (const entry of fs7.readdirSync(root, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const entryTokens = entry.name.split("-").filter(Boolean);
+      if (!startsWithTokens(tokens2, entryTokens)) continue;
+      const matched = matchEncodedPath(path7.join(root, entry.name), tokens2.slice(entryTokens.length));
+      if (matched) return matched;
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+function startsWithTokens(tokens2, prefix) {
+  return prefix.length <= tokens2.length && prefix.every((token, index) => tokens2[index] === token);
+}
 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";
+  if (lower.includes(`${path7.sep}agent-transcripts${path7.sep}`) || lower.endsWith(".jsonl")) return "cli";
+  if (lower.includes(`${path7.sep}workspaceStorage${path7.sep}`.toLowerCase()) || lower.includes(`${path7.sep}globalStorage${path7.sep}`.toLowerCase()) || lower.endsWith(".vscdb")) return "desktop";
   return "unknown";
 }
 function cursorSourceAppLabel(surface) {
@@ -3468,52 +3658,103 @@ function scanUsageSources(options) {
   const codex = scanCodex({
     ...options.codexHome ? { codexHome: options.codexHome } : {},
     ...options.config ? { config: options.config } : {},
+    ...options.scanWindow ? { scanWindow: options.scanWindow } : {},
     pricing: options.pricing
   });
   const claude = scanClaude({
     ...options.claudeHome ? { claudeHome: options.claudeHome } : {},
     ...options.config ? { config: options.config } : {},
+    ...options.scanWindow ? { scanWindow: options.scanWindow } : {},
     pricing: options.pricing
   });
-  const cursor = scanCursor({
+  const cursorEnabled = options.config?.experimentalSources?.cursor === true || Boolean(options.cursorHome);
+  const cursor = cursorEnabled ? scanCursor({
     ...options.cursorHome ? { cursorHome: options.cursorHome } : {},
     ...options.config ? { config: options.config } : {},
+    ...options.scanWindow ? { scanWindow: options.scanWindow } : {},
     pricing: options.pricing
-  });
+  }) : void 0;
   return {
-    sources: [codex.source, claude.source, cursor.source],
-    sourceStats: [codex.stats, claude.stats, cursor.stats],
-    sessions: [...codex.sessions, ...claude.sessions, ...cursor.sessions]
+    sources: [codex.source, claude.source, ...cursor ? [cursor.source] : []],
+    sourceStats: [codex.stats, claude.stats, ...cursor ? [cursor.stats] : []],
+    sessions: [...codex.sessions, ...claude.sessions, ...cursor?.sessions ?? []]
   };
 }
 
 // apps/server/src/data.ts
-import fs7 from "node:fs";
+import fs8 from "node:fs";
+import path8 from "node:path";
+import { spawn } from "node:child_process";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 var scanCacheTtlMs = 1e4;
 var scanCache;
+var warmScanInFlight = false;
+var warmScanChild;
+var warmedScanKeys = /* @__PURE__ */ new Set();
 function readDashboardData(filters = {}, options = {}) {
-  const raw = readRawUsageData();
+  const raw = readRawUsageData(filters);
   return buildDashboardSnapshot({ ...raw, sessions: displaySessions(raw.sessions, options), filters });
 }
 function clearScanCache() {
   scanCache = void 0;
+  warmScanInFlight = false;
+  warmScanChild?.kill();
+  warmScanChild = void 0;
+  warmedScanKeys.clear();
 }
-function readRawUsageData() {
+function readRawUsageData(filters = {}) {
   const cwd = runtimeCwd();
-  if (scanCache && scanCache.cwd === cwd && scanCache.expiresAt > Date.now()) {
+  const { config, warnings: configWarnings } = loadConfigWithWarnings();
+  const cacheKey = scanCacheKey({ cwd, filters, cursorEnabled: config.experimentalSources?.cursor === true });
+  if (scanCache && scanCache.key === cacheKey && scanCache.expiresAt > Date.now()) {
     return scanCache.data;
   }
-  const { config, warnings: configWarnings } = loadConfigWithWarnings();
   const pricing = loadPricingTable(resolvePricingPath(config));
-  const scan = scanUsageSources({ config, pricing });
+  const scanWindow = scanWindowFromFilters(filters);
+  const scan = scanUsageSources({
+    config,
+    pricing,
+    ...scanWindow ? { scanWindow } : {}
+  });
   const data = {
     sources: scan.sources.map((source) => ({ ...source, warnings: [...source.warnings, ...configWarnings] })),
     sourceStats: scan.sourceStats,
     sessions: scan.sessions
   };
-  scanCache = { cwd, data, expiresAt: Date.now() + scanCacheTtlMs };
+  scanCache = { key: cacheKey, data, expiresAt: Date.now() + scanCacheTtlMs };
   return data;
 }
+function warmDashboardCache(filters = {}, options = {}) {
+  const cwd = runtimeCwd();
+  const config = loadConfig();
+  const key = scanCacheKey({ cwd, filters, cursorEnabled: config.experimentalSources?.cursor === true });
+  if (scanCache?.key === key || warmedScanKeys.has(key)) return { started: false, key, reason: "already_warm" };
+  if (warmScanInFlight) return { started: false, key, reason: "warm_scan_in_flight" };
+  warmScanInFlight = true;
+  let child;
+  try {
+    child = spawn(process.execPath, [...process.execArgv, cliEntryPath(), "__warm-cache", ...warmCacheArgs(filters, options)], {
+      detached: true,
+      env: process.env,
+      stdio: "ignore"
+    });
+  } catch (error) {
+    warmScanInFlight = false;
+    return { started: false, key, reason: error instanceof Error ? error.message : String(error) };
+  }
+  warmScanChild = child;
+  child.once("error", () => {
+    warmScanInFlight = false;
+    if (warmScanChild === child) warmScanChild = void 0;
+  });
+  child.once("exit", (code) => {
+    warmScanInFlight = false;
+    if (warmScanChild === child) warmScanChild = void 0;
+    if (code === 0) warmedScanKeys.add(key);
+  });
+  child.unref();
+  return { started: true, key };
+}
 function parseFilters(query) {
   const filters = {};
   const source = listQuery(query.source);
@@ -3543,6 +3784,20 @@ function readPricingData() {
     models: loadPricingTable(pricingPath)
   };
 }
+function readConfigData() {
+  return {
+    path: configPath(),
+    config: loadConfig()
+  };
+}
+function writeConfigData(nextConfig) {
+  const saved = saveConfig(nextConfig);
+  clearScanCache();
+  return {
+    path: configPath(),
+    config: saved
+  };
+}
 function writePricingData(models) {
   const config = loadConfig();
   const pricingPath = resolvePricingPath(config);
@@ -3555,11 +3810,16 @@ function writePricingData(models) {
 }
 function clearRepoSpendLocalData() {
   const target = repospendHome();
-  const removed = fs7.existsSync(target);
-  fs7.rmSync(target, { recursive: true, force: true });
+  const removed = fs8.existsSync(target);
+  fs8.rmSync(target, { recursive: true, force: true });
   clearScanCache();
   return { path: target, removed };
 }
+function clearRepoSpendParseCache() {
+  const result = clearRepoSpendCache();
+  clearScanCache();
+  return result;
+}
 function exportJson() {
   return JSON.stringify(readDashboardData().sessions, null, 2);
 }
@@ -3587,6 +3847,35 @@ function sourceScopedAppLabel(session) {
   if (!shouldScopeApp(app)) return app;
   return `${sourceClientLabel(session.sourceClient)} on ${app}`;
 }
+function scanWindowFromFilters(filters) {
+  const fromMs = filters.from ? lowerBound(filters.from) : void 0;
+  const toMs = filters.to ? upperBound(filters.to) : void 0;
+  const scanWindow = {};
+  if (fromMs !== void 0) scanWindow.fromMs = fromMs;
+  if (toMs !== void 0) scanWindow.toMs = toMs;
+  return scanWindow.fromMs === void 0 && scanWindow.toMs === void 0 ? void 0 : scanWindow;
+}
+function scanCacheKey({ cwd, filters, cursorEnabled }) {
+  return JSON.stringify({
+    cwd,
+    from: filters.from ?? "",
+    to: filters.to ?? "",
+    cursor: cursorEnabled
+  });
+}
+function warmCacheArgs(filters, options) {
+  const args2 = [];
+  if (filters.from) args2.push("--from", filters.from);
+  if (filters.to) args2.push("--to", filters.to);
+  if (options.splitSourceApps) args2.push("--splitSourceApps");
+  return args2;
+}
+function cliEntryPath() {
+  const currentDir = path8.dirname(fileURLToPath2(import.meta.url));
+  const sourceCli = path8.join(currentDir, "cli.ts");
+  if (fs8.existsSync(sourceCli)) return sourceCli;
+  return path8.join(currentDir, "cli.js");
+}
 function shouldScopeApp(app) {
   const normalized = app.toLowerCase();
   return normalized.includes("vs code") || normalized.includes("vscode") || normalized.includes("terminal") || normalized.includes("cli");
@@ -3612,9 +3901,9 @@ function runtimeCwd() {
 }
 
 // apps/server/src/server.ts
-import fs8 from "node:fs";
-import path7 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import fs9 from "node:fs";
+import path9 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 import fastifyStatic from "@fastify/static";
 import Fastify from "fastify";
 
@@ -4427,6 +4716,7 @@ function createServer(options = {}) {
     const demoMode = demoModeEnabled();
     const data = demoMode ? readDemoDashboardData(filters, dashboardOptions) : readDashboardData(filters, dashboardOptions);
     const rtkGain = demoMode ? readDemoRtkGain() : await readRtkGain();
+    const configData = readConfigData();
     return {
       ...data,
       appVersion: readPackageVersion(),
@@ -4435,6 +4725,8 @@ function createServer(options = {}) {
         info: pricingInfo,
         ...readPricingData()
       },
+      config: configData.config,
+      configPath: configData.path,
       rtkGain
     };
   });
@@ -4442,7 +4734,17 @@ function createServer(options = {}) {
     info: pricingInfo,
     ...writePricingData(validatePricingBody(request.body))
   }));
+  app.put("/api/settings/config", async (request) => writeConfigData(validateConfigBody(request.body)));
   app.delete("/api/settings/local-data", async () => clearRepoSpendLocalData());
+  app.delete("/api/settings/cache", async () => {
+    if (demoModeEnabled()) return { path: "demo mode (cache disabled)", removed: false, demo: true };
+    return clearRepoSpendParseCache();
+  });
+  app.post("/api/cache/warm", async (request) => {
+    if (demoModeEnabled()) return { started: false, reason: "demo_mode" };
+    const query = request.query;
+    return warmDashboardCache(warmCacheFilters(), parseDashboardOptions(query));
+  });
   app.get("/api/export.json", async (_request, reply) => {
     reply.header("content-type", "application/json; charset=utf-8");
     return exportJson();
@@ -4453,9 +4755,9 @@ function createServer(options = {}) {
     return exportCsv();
   });
   if (options.serveWeb !== false) {
-    const serverDist = path7.dirname(fileURLToPath2(import.meta.url));
-    const packagedWebDist = path7.resolve(serverDist, "../web-dist");
-    const workspaceWebDist = path7.resolve(serverDist, "../../web/dist");
+    const serverDist = path9.dirname(fileURLToPath3(import.meta.url));
+    const packagedWebDist = path9.resolve(serverDist, "../web-dist");
+    const workspaceWebDist = path9.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.`);
@@ -4476,13 +4778,13 @@ function createServer(options = {}) {
   return app;
 }
 function fsExists(inputPath) {
-  return Boolean(inputPath) && path7.isAbsolute(inputPath) && fs8.existsSync(inputPath);
+  return Boolean(inputPath) && path9.isAbsolute(inputPath) && fs9.existsSync(inputPath);
 }
 function readPackageVersion() {
-  const serverDist = path7.dirname(fileURLToPath2(import.meta.url));
-  const packagePath = path7.resolve(serverDist, "../package.json");
+  const serverDist = path9.dirname(fileURLToPath3(import.meta.url));
+  const packagePath = path9.resolve(serverDist, "../package.json");
   try {
-    const parsed = JSON.parse(fs8.readFileSync(packagePath, "utf8"));
+    const parsed = JSON.parse(fs9.readFileSync(packagePath, "utf8"));
     return typeof parsed.version === "string" ? parsed.version : "unknown";
   } catch {
     return "unknown";
@@ -4491,9 +4793,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)) {
@@ -4525,6 +4846,32 @@ function validatePricingBody(body) {
   }
   return validated;
 }
+function validateConfigBody(body) {
+  if (!body || typeof body !== "object" || Array.isArray(body)) return {};
+  const input = body;
+  const config = {};
+  if (Array.isArray(input.repos)) config.repos = input.repos;
+  if (Array.isArray(input.budgets)) config.budgets = input.budgets;
+  if (typeof input.pricingPath === "string") config.pricingPath = input.pricingPath;
+  const experimentalSources = input.experimentalSources;
+  if (experimentalSources && typeof experimentalSources === "object" && !Array.isArray(experimentalSources)) {
+    config.experimentalSources = {
+      cursor: experimentalSources.cursor === true
+    };
+  }
+  return config;
+}
+function warmCacheFilters() {
+  const days = 30;
+  const now = /* @__PURE__ */ new Date();
+  return {
+    from: dateOnly(new Date(now.getTime() - days * 24 * 60 * 60 * 1e3)),
+    to: dateOnly(now)
+  };
+}
+function dateOnly(value) {
+  return value.toISOString().slice(0, 10);
+}
 function finiteNumber(value) {
   if (value === "" || value === null || value === void 0) return void 0;
   const parsed = typeof value === "number" ? value : Number(value);
@@ -4537,9 +4884,13 @@ 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 === "__warm-cache") {
+    readDashboardData(cliDateFilters(args), { splitSourceApps: args.includes("--splitSourceApps") });
   } else if (command === "scan") {
     const data = readDashboardData(cliFilters(args));
     console.log(JSON.stringify({ sources: data.sources, sessionCount: data.sessions.length, summary: data.summary }, null, 2));
@@ -4571,14 +4922,14 @@ function openBrowser(url) {
   if (process.env.REPOSPEND_NO_OPEN === "1" || process.env.CI === "true") return;
   const command2 = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
   const args2 = process.platform === "win32" ? ["/c", "start", "", url] : [url];
-  const child = spawn(command2, args2, { detached: true, stdio: "ignore" });
+  const child = spawn2(command2, args2, { detached: true, stdio: "ignore" });
   child.on("error", () => {
   });
   child.unref();
 }
 function printGroups(groups) {
   if (!groups.length) {
-    console.log("No usage found. Scanned Codex, Claude Code, and Cursor local data paths.");
+    console.log("No usage found. Scanned enabled local data paths.");
     return;
   }
   const rows = groups.map((group) => ({
@@ -4594,6 +4945,14 @@ function cliFilters(args2) {
   if (!source || source === "all") return {};
   return { source };
 }
+function cliDateFilters(args2) {
+  const from = valueAfter(args2, "--from");
+  const to = valueAfter(args2, "--to");
+  return {
+    ...from ? { from } : {},
+    ...to ? { to } : {}
+  };
+}
 function valueAfter(args2, flag) {
   const index = args2.indexOf(flag);
   return index >= 0 ? args2[index + 1] : void 0;
@@ -4611,5 +4970,7 @@ function printHelp() {
   repospend export --format csv
 
 Options:
-  --source all|codex|claude|cursor`);
+  --source all|codex|claude|cursor
+
+Cursor is experimental and only scans when enabled in ~/.repospend/config.json.`);
 }