vibe-replay 0.2.3 → 0.2.4

package/dist/index.js

@@ -28,60 +28,14 @@ var init_version = __esm({
   }
 });
 
-// src/utils.ts
-import { homedir as homedir3 } from "os";
-function shortenPath(path) {
-  const home = homedir3();
-  if (path.startsWith(home)) return `~${path.slice(home.length)}`;
-  return path;
-}
-function normalizeTitle(value) {
-  const cleaned = (value || "").replace(/\s+/g, " ").trim().slice(0, MAX_TITLE_CHARS);
-  return cleaned || void 0;
-}
-function extractToolFilePath(input) {
-  return extractToolFilePaths(input)[0];
-}
-function extractToolFilePaths(input) {
-  if (!input) return [];
-  const plural2 = input.file_paths ?? input.filePaths ?? input.paths;
-  const paths = Array.isArray(plural2) ? plural2.filter((fp) => typeof fp === "string" && fp.trim().length > 0) : [];
-  const singular = input.file_path ?? input.filePath ?? input.path ?? input.relativeWorkspacePath;
-  if (typeof singular === "string" && singular.trim()) paths.unshift(singular);
-  return [...new Set(paths)];
-}
-function localDayKey(input) {
-  if (input == null || input === "") return void 0;
-  const d = input instanceof Date ? input : new Date(input);
-  if (Number.isNaN(d.getTime())) return void 0;
-  const y = d.getFullYear();
-  const m = String(d.getMonth() + 1).padStart(2, "0");
-  const day = String(d.getDate()).padStart(2, "0");
-  return `${y}-${m}-${day}`;
-}
-var MAX_TITLE_CHARS, FILE_EDIT_TOOLS;
-var init_utils = __esm({
-  "src/utils.ts"() {
-    "use strict";
-    MAX_TITLE_CHARS = 120;
-    FILE_EDIT_TOOLS = /* @__PURE__ */ new Set([
-      "Edit",
-      "MultiEdit",
-      "Write",
-      "NotebookEdit",
-      "Delete"
-    ]);
-  }
-});
-
 // src/overlays.ts
-import { readFile as readFile16 } from "fs/promises";
-import { join as join16, resolve } from "path";
+import { readFile as readFile17 } from "fs/promises";
+import { join as join17, resolve as resolve2 } from "path";
 async function loadOverlays(baseDir, slug) {
-  const dirs = [join16(baseDir, slug), resolve("./vibe-replay", slug)];
+  const dirs = [join17(baseDir, slug), resolve2("./vibe-replay", slug)];
   for (const dir of dirs) {
     try {
-      const raw = await readFile16(join16(dir, "overlays.json"), "utf-8");
+      const raw = await readFile17(join17(dir, "overlays.json"), "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed && typeof parsed === "object" && Array.isArray(parsed.overlays)) {
         return parsed;
@@ -140,9 +94,9 @@ __export(cloud_exports, {
   saveAuthTokenSync: () => saveAuthTokenSync
 });
 import { existsSync, mkdirSync, readFileSync as readFileSync2, rmSync, writeFileSync } from "fs";
-import { mkdir as mkdir3, readFile as readFile17, unlink, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile18, unlink, writeFile as writeFile3 } from "fs/promises";
 import { homedir as homedir14 } from "os";
-import { basename as basename7, dirname as dirname3, join as join17 } from "path";
+import { basename as basename7, dirname as dirname3, join as join18 } from "path";
 function authOrigin(url) {
   try {
     return new URL(url).origin;
@@ -243,8 +197,8 @@ async function publishCloud(outputDir, opts) {
   if (!auth) {
     throw new Error("Not logged in. Run `vibe-replay auth login` first.");
   }
-  const jsonPath = join17(outputDir, "replay.json");
-  const content = await readFile17(jsonPath, "utf-8");
+  const jsonPath = join18(outputDir, "replay.json");
+  const content = await readFile18(jsonPath, "utf-8");
   const replay = JSON.parse(content);
   const sizeBytes = Buffer.byteLength(content, "utf-8");
   const MAX_SIZE = 10 * 1024 * 1024;
@@ -291,8 +245,8 @@ async function publishCloudWithOverlays(outputDir, opts) {
   if (overlays.overlays.length === 0) {
     return publishCloud(outputDir, opts);
   }
-  const replayPath = join17(outputDir, "replay.json");
-  const originalContent = await readFile17(replayPath, "utf-8");
+  const replayPath = join18(outputDir, "replay.json");
+  const originalContent = await readFile18(replayPath, "utf-8");
   const session = JSON.parse(originalContent);
   const merged = sessionWithEffectiveContent(session, overlays);
   await writeFile3(replayPath, JSON.stringify(merged), "utf-8");
@@ -304,7 +258,7 @@ async function publishCloudWithOverlays(outputDir, opts) {
 }
 async function loadSavedCloudInfo(outputDir) {
   try {
-    const raw = await readFile17(join17(outputDir, CLOUD_META_FILE), "utf-8");
+    const raw = await readFile18(join18(outputDir, CLOUD_META_FILE), "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed?.id || !parsed?.url) return void 0;
     return parsed;
@@ -313,7 +267,7 @@ async function loadSavedCloudInfo(outputDir) {
   }
 }
 async function saveCloudInfo(outputDir, info) {
-  await writeFile3(join17(outputDir, CLOUD_META_FILE), JSON.stringify(info, null, 2), "utf-8");
+  await writeFile3(join18(outputDir, CLOUD_META_FILE), JSON.stringify(info, null, 2), "utf-8");
 }
 var CLOUD_META_FILE, DEFAULT_API_URL, AUTH_DIR, AUTH_FILE;
 var init_cloud = __esm({
@@ -322,8 +276,8 @@ var init_cloud = __esm({
     init_overlays();
     CLOUD_META_FILE = ".vibe-replay-cloud.json";
     DEFAULT_API_URL = "https://vibe-replay.com";
-    AUTH_DIR = join17(homedir14(), ".config", "vibe-replay");
-    AUTH_FILE = join17(AUTH_DIR, "auth.json");
+    AUTH_DIR = join18(homedir14(), ".config", "vibe-replay");
+    AUTH_FILE = join18(AUTH_DIR, "auth.json");
   }
 });
 
@@ -396,6 +350,54 @@ var init_machine_id = __esm({
   }
 });
 
+// src/utils.ts
+import { readFile as readFile20 } from "fs/promises";
+import { homedir as homedir15 } from "os";
+import { join as join20 } from "path";
+function shortenPath2(path) {
+  const home = homedir15();
+  if (path.startsWith(home)) return `~${path.slice(home.length)}`;
+  return path;
+}
+function normalizeTitle(value) {
+  const cleaned = (value || "").replace(/\s+/g, " ").trim().slice(0, MAX_TITLE_CHARS);
+  return cleaned || void 0;
+}
+function extractToolFilePath(input) {
+  return extractToolFilePaths(input)[0];
+}
+function extractToolFilePaths(input) {
+  if (!input) return [];
+  const plural2 = input.file_paths ?? input.filePaths ?? input.paths;
+  const paths = Array.isArray(plural2) ? plural2.filter((fp) => typeof fp === "string" && fp.trim().length > 0) : [];
+  const singular = input.file_path ?? input.filePath ?? input.path ?? input.relativeWorkspacePath;
+  if (typeof singular === "string" && singular.trim()) paths.unshift(singular);
+  return [...new Set(paths)];
+}
+function localDayKey(input) {
+  if (input == null || input === "") return void 0;
+  const d = input instanceof Date ? input : new Date(input);
+  if (Number.isNaN(d.getTime())) return void 0;
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+var MAX_TITLE_CHARS, FILE_EDIT_TOOLS;
+var init_utils = __esm({
+  "src/utils.ts"() {
+    "use strict";
+    MAX_TITLE_CHARS = 120;
+    FILE_EDIT_TOOLS = /* @__PURE__ */ new Set([
+      "Edit",
+      "MultiEdit",
+      "Write",
+      "NotebookEdit",
+      "Delete"
+    ]);
+  }
+});
+
 // src/insights.ts
 var insights_exports = {};
 __export(insights_exports, {
@@ -406,12 +408,12 @@ __export(insights_exports, {
   scanResultToInsight: () => scanResultToInsight,
   writeInsightsStore: () => writeInsightsStore
 });
-import { mkdir as mkdir4, readFile as readFile19, rename, writeFile as writeFile5 } from "fs/promises";
-import { homedir as homedir15 } from "os";
-import { dirname as dirname4, join as join19 } from "path";
+import { mkdir as mkdir4, readFile as readFile21, rename, writeFile as writeFile5 } from "fs/promises";
+import { homedir as homedir16 } from "os";
+import { dirname as dirname4, join as join21 } from "path";
 async function readInsightsStore() {
   try {
-    const raw = await readFile19(STORE_PATH, "utf-8");
+    const raw = await readFile21(STORE_PATH, "utf-8");
     const parsed = JSON.parse(raw);
     return migrateInsightsStore(parsed);
   } catch {
@@ -607,8 +609,8 @@ var init_insights = __esm({
     init_machine_id();
     init_utils();
     init_version();
-    INSIGHTS_DIR = join19(homedir15(), ".vibe-replay", "insights");
-    STORE_PATH = join19(INSIGHTS_DIR, "store.json");
+    INSIGHTS_DIR = join21(homedir16(), ".vibe-replay", "insights");
+    STORE_PATH = join21(INSIGHTS_DIR, "store.json");
   }
 });
 
@@ -619,26 +621,32 @@ import chalk2 from "chalk";
 import { program } from "commander";
 import ora from "ora";
 
-// src/cache.ts
-init_version();
+// ../provider-core/src/cache.ts
 import { mkdir, readFile, writeFile } from "fs/promises";
 import { homedir } from "os";
 import { join } from "path";
 var CACHE_ENVELOPE_VERSION = 1;
 var CACHE_DIR = join(homedir(), ".vibe-replay", "cache");
+var configuredAppVersion;
 function isFileCacheDisabled() {
   return process.env.VIBE_REPLAY_DISABLE_FILE_CACHE === "1";
 }
+function setFileCacheAppVersion(appVersion) {
+  configuredAppVersion = appVersion;
+}
+function currentAppVersion(options) {
+  return options?.appVersion || configuredAppVersion || process.env.npm_package_version || "0.0.0";
+}
 function toCachePath(key) {
   const safeKey = key.replace(/[^a-zA-Z0-9._-]/g, "_");
   return join(CACHE_DIR, `${safeKey}.json`);
 }
-async function readFileCache(key) {
+async function readFileCache(key, options) {
   if (isFileCacheDisabled()) return null;
   try {
     const raw = await readFile(toCachePath(key), "utf-8");
     const parsed = JSON.parse(raw);
-    if (parsed.envelopeVersion !== CACHE_ENVELOPE_VERSION || parsed.appVersion !== CLI_VERSION || typeof parsed.updatedAt !== "string" || !("data" in parsed)) {
+    if (parsed.envelopeVersion !== CACHE_ENVELOPE_VERSION || parsed.appVersion !== currentAppVersion(options) || typeof parsed.updatedAt !== "string" || !("data" in parsed)) {
       return null;
     }
     return { updatedAt: parsed.updatedAt, data: parsed.data };
@@ -646,13 +654,13 @@ async function readFileCache(key) {
     return null;
   }
 }
-async function writeFileCache(key, data) {
+async function writeFileCache(key, data, options) {
   if (isFileCacheDisabled()) return;
   try {
     await mkdir(CACHE_DIR, { recursive: true });
     const payload = {
       envelopeVersion: CACHE_ENVELOPE_VERSION,
-      appVersion: CLI_VERSION,
+      appVersion: currentAppVersion(options),
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       data
     };
@@ -661,6 +669,69 @@ async function writeFileCache(key, data) {
   }
 }
 
+// ../provider-core/src/utils.ts
+import { readFile as readFile2, stat } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { isAbsolute, join as join2, resolve } from "path";
+function shortenPath(path) {
+  const home = homedir2();
+  if (path.startsWith(home)) return `~${path.slice(home.length)}`;
+  return path;
+}
+async function readGitRepo(projectDir) {
+  if (!projectDir.trim()) return void 0;
+  try {
+    const resolved = projectDir.startsWith("~") ? join2(homedir2(), projectDir.slice(1)) : projectDir;
+    const gitPath = join2(resolved, ".git");
+    let configPath = join2(gitPath, "config");
+    const gitStat = await stat(gitPath).catch(() => null);
+    if (gitStat?.isFile()) {
+      const gitFile = await readFile2(gitPath, "utf-8");
+      const gitdirMatch = gitFile.match(/^gitdir:\s*(.+)$/m);
+      if (!gitdirMatch) return void 0;
+      const gitdir = gitdirMatch[1].trim();
+      const absoluteGitdir = isAbsolute(gitdir) ? gitdir : resolve(resolved, gitdir);
+      const commonDir = await readFile2(join2(absoluteGitdir, "commondir"), "utf-8").catch(
+        () => "../.."
+      );
+      configPath = join2(resolve(absoluteGitdir, commonDir.trim()), "config");
+    }
+    const config = await readFile2(configPath, "utf-8");
+    const match = config.match(/\[remote "origin"\][^[]*?url\s*=\s*(.+)/);
+    if (!match) return void 0;
+    return normalizeGitUrl(match[1].trim());
+  } catch {
+    return void 0;
+  }
+}
+function normalizeGitUrl(url) {
+  const trimmed = url.trim();
+  const scpMatch = trimmed.match(/:([^/][^:]+?)(?:\.git)?\s*$/);
+  if (!trimmed.startsWith("http") && !trimmed.startsWith("ssh://") && scpMatch) {
+    const path = scpMatch[1];
+    const parts = path.split("/");
+    if (parts.length >= 2) return `${parts[0]}/${parts[1]}`;
+  }
+  try {
+    const parsed = new URL(trimmed);
+    const parts = parsed.pathname.replace(/^\//, "").replace(/\.git$/, "").split("/");
+    if (parts.length >= 2) {
+      return `${parts[0]}/${parts[1]}`;
+    }
+  } catch {
+  }
+  return void 0;
+}
+
+// src/cache.ts
+init_version();
+async function readFileCache2(key) {
+  return readFileCache(key, { appVersion: CLI_VERSION });
+}
+async function writeFileCache2(key, data) {
+  return writeFileCache(key, data, { appVersion: CLI_VERSION });
+}
+
 // src/clean-prompt.ts
 function isSystemGeneratedMessage(text) {
   return text.startsWith("[Request interrupted by user") || text.startsWith("<command-name>") || text.startsWith("<command-message>") || text.startsWith("<local-command-caveat>") || text.startsWith("<local-command-stdout>") || text.startsWith("<task-notification>") || text.startsWith("<bash-input>") || text.startsWith("<bash-stdout>");
@@ -729,19 +800,19 @@ function stripTerminalTranscriptNoise(text) {
 }
 
 // src/cleanup-warning.ts
-import { readFile as readFile2 } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
+import { readFile as readFile3 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
 var DEFAULT_CLEANUP_PERIOD_DAYS = 30;
 var WARNING_THRESHOLD_DAYS = 7;
 async function getClaudeCodeCleanupPeriod() {
-  const home = homedir2();
+  const home = homedir3();
   for (const file of [
-    join2(home, ".claude", "settings.local.json"),
-    join2(home, ".claude", "settings.json")
+    join3(home, ".claude", "settings.local.json"),
+    join3(home, ".claude", "settings.json")
   ]) {
     try {
-      const raw = await readFile2(file, "utf-8");
+      const raw = await readFile3(file, "utf-8");
       const settings = JSON.parse(raw);
       if (typeof settings.cleanupPeriodDays === "number") {
         return settings.cleanupPeriodDays;
@@ -1617,8 +1688,8 @@ async function generateGitHubGif(session, opts = {}) {
 }
 
 // src/generator.ts
-import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
-import { dirname, join as join3 } from "path";
+import { mkdir as mkdir2, readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
+import { dirname, join as join4 } from "path";
 import { fileURLToPath } from "url";
 var __dirname = dirname(fileURLToPath(import.meta.url));
 async function generateOutput(session, outputDir) {
@@ -1632,21 +1703,21 @@ async function generateOutput(session, outputDir) {
     "<title>vibe-replay</title>",
     `<title>${escapeHtml(title)} \u2014 vibe-replay</title>`
   );
-  const outputPath = join3(outputDir, "index.html");
+  const outputPath = join4(outputDir, "index.html");
   await writeFile2(outputPath, finalHtml, "utf-8");
-  const jsonPath = join3(outputDir, "replay.json");
+  const jsonPath = join4(outputDir, "replay.json");
   await writeFile2(jsonPath, JSON.stringify(session), "utf-8");
   return outputPath;
 }
 async function loadViewerHtml() {
   const assetsPaths = [
-    join3(__dirname, "..", "assets", "viewer.html"),
-    join3(__dirname, "assets", "viewer.html"),
-    join3(__dirname, "..", "..", "assets", "viewer.html")
+    join4(__dirname, "..", "assets", "viewer.html"),
+    join4(__dirname, "assets", "viewer.html"),
+    join4(__dirname, "..", "..", "assets", "viewer.html")
   ];
   for (const p of assetsPaths) {
     try {
-      return await readFile3(p, "utf-8");
+      return await readFile4(p, "utf-8");
     } catch (err) {
       if (err instanceof Error && "code" in err && err.code !== "ENOENT")
         throw err;
@@ -1669,14 +1740,82 @@ function injectDataScript(html, scriptTag) {
 ${html.slice(headIdx)}`;
 }
 
-// src/providers/claude-code/discover.ts
+// ../provider-claude-code/src/claude-code/discover.ts
 import { createReadStream } from "fs";
-import { readdir, stat } from "fs/promises";
+import { readdir, stat as stat2 } from "fs/promises";
 import { homedir as homedir4 } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import { createInterface } from "readline";
-init_utils();
-var CLAUDE_DIR = join4(homedir4(), ".claude", "projects");
+
+// ../provider-core/src/clean-prompt.ts
+function isSystemGeneratedMessage2(text) {
+  return text.startsWith("[Request interrupted by user") || text.startsWith("<command-name>") || text.startsWith("<command-message>") || text.startsWith("<local-command-caveat>") || text.startsWith("<local-command-stdout>") || text.startsWith("<task-notification>") || text.startsWith("<bash-input>") || text.startsWith("<bash-stdout>");
+}
+function previewPrompt2(text) {
+  return cleanPromptText2(text).slice(0, 200);
+}
+function cleanPromptText2(text) {
+  if (typeof text !== "string") return "";
+  let cleaned = text.trim();
+  if (!cleaned) return "";
+  if (looksLikeConversationSummary2(cleaned)) return "";
+  const hadTerminalNoise = /Last login:|gh auth status|github\.com|credential\.helper=|branch\./i.test(cleaned);
+  cleaned = stripSlackPreamble2(cleaned);
+  cleaned = stripTerminalTranscriptNoise2(cleaned);
+  if (/<attached_files>|<code_selection\b/i.test(cleaned)) {
+    return "";
+  }
+  cleaned = cleaned.replace(/<\/?[a-z][^>]*>/gi, "");
+  cleaned = cleaned.replace(/^\s*\d+\|\s*/gm, "");
+  cleaned = cleaned.replace(
+    /Caveat:\s*The messages below were generated by the user while running local commands\.[^.]*/g,
+    ""
+  );
+  cleaned = cleaned.replace(/DO NOT respond to these messages[^.]*/g, "");
+  cleaned = cleaned.replace(/^\/\w+\s*/g, "");
+  cleaned = cleaned.replace(/\n/g, " ").replace(/\s+/g, " ").trim();
+  if (!cleaned || looksLikeConversationSummary2(cleaned)) return "";
+  if (hadTerminalNoise && /^[a-z0-9._:-]{1,12}$/i.test(cleaned)) return "";
+  return cleaned;
+}
+function looksLikeConversationSummary2(text) {
+  const normalized = text.trim();
+  return /^\[Previous conversation summary\]:/i.test(normalized) || /^Summary:\s*1\.\s*Primary Request and Intent:/i.test(normalized) || // Cursor sometimes stores a truncated mid-sentence summary fragment instead
+  // of the real first prompt; suppress that artifact in previews.
+  /^and merge infrastructure was built for human-paced output/i.test(normalized);
+}
+function stripSlackPreamble2(text) {
+  const lines = text.split("\n");
+  const trimmed = [...lines];
+  const removedSpeaker = /^\S.*\[\d{1,2}:\d{2}\s?(?:AM|PM)\]$/i.test(trimmed[0] || "");
+  if (removedSpeaker) {
+    trimmed.shift();
+  }
+  if (removedSpeaker && /^(?:hello|hi)\b/i.test((trimmed[0] || "").trim())) {
+    trimmed.shift();
+  }
+  return trimmed.join("\n").trim();
+}
+function stripTerminalTranscriptNoise2(text) {
+  const lines = text.split("\n");
+  const kept = lines.filter((line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return true;
+    if (/^Last login:/i.test(trimmed)) return false;
+    if (/^(?:➜|❯)\s+/.test(trimmed)) return false;
+    if (/^github(?:\.com|\.rbx\.com)?$/i.test(trimmed)) return false;
+    if (/^[✓✔]/.test(trimmed)) return false;
+    if (/^-\s+(?:Active account|Git operations protocol|Token|Token scopes):/i.test(trimmed))
+      return false;
+    if (/^(?:credential|init|user|filter|alias|core|remote|branch)\.[^=]+=/i.test(trimmed) || /^branch\.[^.]+\./i.test(trimmed))
+      return false;
+    return true;
+  });
+  return kept.join("\n").trim();
+}
+
+// ../provider-claude-code/src/claude-code/discover.ts
+var CLAUDE_DIR = join5(homedir4(), ".claude", "projects");
 async function discoverClaudeCodeSessions() {
   const sessions = [];
   let projectDirs;
@@ -1686,8 +1825,8 @@ async function discoverClaudeCodeSessions() {
     return sessions;
   }
   for (const projDir of projectDirs) {
-    const projPath = join4(CLAUDE_DIR, projDir);
-    const projStat = await stat(projPath).catch(() => null);
+    const projPath = join5(CLAUDE_DIR, projDir);
+    const projStat = await stat2(projPath).catch(() => null);
     if (!projStat?.isDirectory()) continue;
     const project = decodeProjectDir(projDir);
     let files;
@@ -1696,13 +1835,22 @@ async function discoverClaudeCodeSessions() {
     } catch {
       continue;
     }
+    let gitRepo;
+    let gitRepoResolved = false;
     for (const file of files) {
       if (!file.endsWith(".jsonl")) continue;
-      const filePath = join4(projPath, file);
-      const fileStat = await stat(filePath).catch(() => null);
+      const filePath = join5(projPath, file);
+      const fileStat = await stat2(filePath).catch(() => null);
       if (!fileStat) continue;
       const info = await extractSessionInfo(filePath, fileStat.size, project);
-      if (info) sessions.push(info);
+      if (info) {
+        if (!gitRepoResolved && info.cwd) {
+          gitRepo = await readGitRepo(info.cwd);
+          gitRepoResolved = true;
+        }
+        info.gitRepo = gitRepo;
+        sessions.push(info);
+      }
     }
   }
   sessions.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
@@ -1780,8 +1928,8 @@ async function extractSessionInfo(filePath, fileSize, project) {
           if (prompts.length < MAX_PROMPTS && obj.type === "user" && obj.message?.role === "user") {
             const contentField = obj.message.content;
             const text = typeof contentField === "string" ? contentField : Array.isArray(contentField) ? contentField.filter((b) => b.type === "text").map((b) => b.text ?? "").join("") : "";
-            if (text && !isSystemGeneratedMessage(text)) {
-              const cleaned = cleanPromptText(text);
+            if (text && !isSystemGeneratedMessage2(text)) {
+              const cleaned = cleanPromptText2(text);
               if (cleaned.length >= 10) prompts.push(cleaned.slice(0, 200));
             }
           }
@@ -1821,7 +1969,7 @@ async function extractSessionInfo(filePath, fileSize, project) {
     }
   }
   if (!timestamp) {
-    const fileStat2 = await stat(filePath).catch(() => null);
+    const fileStat2 = await stat2(filePath).catch(() => null);
     if (fileStat2) timestamp = fileStat2.mtime.toISOString();
     else return null;
   }
@@ -1850,11 +1998,11 @@ async function extractSessionInfo(filePath, fileSize, project) {
   };
 }
 
-// src/providers/claude-code/parser.ts
-import { readdir as readdir2, readFile as readFile4 } from "fs/promises";
-import { join as join5 } from "path";
+// ../provider-claude-code/src/claude-code/parser.ts
+import { readdir as readdir2, readFile as readFile5 } from "fs/promises";
+import { join as join6 } from "path";
 
-// src/duration.ts
+// ../provider-core/src/duration.ts
 var DEFAULT_MAX_GAP_MS = 5 * 60 * 1e3;
 function estimateActiveDuration(timestamps, maxGapMs = DEFAULT_MAX_GAP_MS) {
   if (timestamps.length < 2) return void 0;
@@ -1868,7 +2016,7 @@ function estimateActiveDuration(timestamps, maxGapMs = DEFAULT_MAX_GAP_MS) {
   return active > 0 ? active : void 0;
 }
 
-// src/providers/warnings.ts
+// ../provider-contract/src/warnings.ts
 function addParseWarning(warnings, warning) {
   const existing = warnings.find(
     (w) => w.kind === warning.kind && w.source === warning.source && w.message === warning.message
@@ -1892,12 +2040,12 @@ function compactWarningSample(value, max = 160) {
   return `${compacted.slice(0, max)}...`;
 }
 
-// src/providers/claude-code/parser.ts
+// ../provider-claude-code/src/claude-code/parser.ts
 async function parseClaudeCodeSession(filePaths) {
   const paths = Array.isArray(filePaths) ? filePaths : [filePaths];
   const allLines = [];
   for (const fp of paths) {
-    const content = await readFile4(fp, "utf-8");
+    const content = await readFile5(fp, "utf-8");
     allLines.push(...content.split("\n"));
   }
   return parseClaudeCodeLines(allLines, { subagentsSourcePath: paths[0] });
@@ -2098,7 +2246,7 @@ async function parseClaudeCodeLines(lines, options = {}) {
       continue;
     }
     if (role === "user" && typeof msgContent === "string") {
-      if (isSystemGeneratedMessage(msgContent)) continue;
+      if (isSystemGeneratedMessage2(msgContent)) continue;
       const isCompaction = obj.isCompactSummary || msgContent.startsWith("This session is being continued from a previous conversation");
       userTurns.push({
         role: "user",
@@ -2135,7 +2283,7 @@ async function parseClaudeCodeLines(lines, options = {}) {
         }
       }
       const combinedText = textParts.join("").trim();
-      if (!isToolSearchResponse && !isSystemGeneratedMessage(combinedText) && (textParts.length > 0 || userImages.length > 0)) {
+      if (!isToolSearchResponse && !isSystemGeneratedMessage2(combinedText) && (textParts.length > 0 || userImages.length > 0)) {
         const blocks = textParts.map(
           (t) => ({ type: "text", text: t })
         );
@@ -2453,19 +2601,19 @@ function buildTurnStats(finalTurns, usageByMsgId, turnDurations) {
     } else if (group.startTimestamp && group.endTimestamp) {
       durationMs = estimateActiveDuration([group.startTimestamp, group.endTimestamp]);
     }
-    const stat12 = { turnIndex: i };
-    if (turnModel) stat12.model = turnModel;
-    if (durationMs !== void 0) stat12.durationMs = durationMs;
-    if (turnTokens) stat12.tokenUsage = turnTokens;
-    if (maxContextTokens > 0) stat12.contextTokens = maxContextTokens;
-    stats.push(stat12);
+    const stat13 = { turnIndex: i };
+    if (turnModel) stat13.model = turnModel;
+    if (durationMs !== void 0) stat13.durationMs = durationMs;
+    if (turnTokens) stat13.tokenUsage = turnTokens;
+    if (maxContextTokens > 0) stat13.contextTokens = maxContextTokens;
+    stats.push(stat13);
   }
   return stats;
 }
 async function readSubagents(mainFilePath, usageByMsgId, parseWarnings) {
   const result = /* @__PURE__ */ new Map();
   const sessionDir = mainFilePath.replace(/\.jsonl$/, "");
-  const subagentsDir = join5(sessionDir, "subagents");
+  const subagentsDir = join6(sessionDir, "subagents");
   let files;
   try {
     files = await readdir2(subagentsDir);
@@ -2478,8 +2626,8 @@ async function readSubagents(mainFilePath, usageByMsgId, parseWarnings) {
     let agentType = "unknown";
     let description;
     try {
-      const metaPath = join5(subagentsDir, file.replace(/\.jsonl$/, ".meta.json"));
-      const metaContent = await readFile4(metaPath, "utf-8");
+      const metaPath = join6(subagentsDir, file.replace(/\.jsonl$/, ".meta.json"));
+      const metaContent = await readFile5(metaPath, "utf-8");
       const meta = JSON.parse(metaContent);
       agentType = meta.agentType || "unknown";
       description = meta.description;
@@ -2487,7 +2635,7 @@ async function readSubagents(mainFilePath, usageByMsgId, parseWarnings) {
     }
     let content;
     try {
-      content = await readFile4(join5(subagentsDir, file), "utf-8");
+      content = await readFile5(join6(subagentsDir, file), "utf-8");
     } catch {
       continue;
     }
@@ -2621,7 +2769,7 @@ async function readSubagents(mainFilePath, usageByMsgId, parseWarnings) {
   return result;
 }
 
-// src/providers/claude-code/index.ts
+// ../provider-claude-code/src/claude-code/index.ts
 var claudeCodeProvider = {
   name: "claude-code",
   displayName: "Claude Code",
@@ -2629,13 +2777,13 @@ var claudeCodeProvider = {
   parse: parseClaudeCodeSession
 };
 
-// src/providers/claude-cowork/discover.ts
+// ../provider-claude-code/src/claude-cowork/discover.ts
 import { createReadStream as createReadStream2 } from "fs";
-import { readdir as readdir3, readFile as readFile5, stat as stat2 } from "fs/promises";
+import { readdir as readdir3, readFile as readFile6, stat as stat3 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 import { createInterface as createInterface2 } from "readline";
-var COWORK_DIR = join6(
+var COWORK_DIR = join7(
   homedir5(),
   "Library",
   "Application Support",
@@ -2655,8 +2803,8 @@ async function discoverCoworkFromDir(coworkDir) {
     return sessions;
   }
   for (const accountId of accountDirs) {
-    const accountPath = join6(coworkDir, accountId);
-    const accountStat = await stat2(accountPath).catch(() => null);
+    const accountPath = join7(coworkDir, accountId);
+    const accountStat = await stat3(accountPath).catch(() => null);
     if (!accountStat?.isDirectory()) continue;
     let orgDirs;
     try {
@@ -2665,8 +2813,8 @@ async function discoverCoworkFromDir(coworkDir) {
       continue;
     }
     for (const orgId of orgDirs) {
-      const orgPath = join6(accountPath, orgId);
-      const orgStat = await stat2(orgPath).catch(() => null);
+      const orgPath = join7(accountPath, orgId);
+      const orgStat = await stat3(orgPath).catch(() => null);
       if (!orgStat?.isDirectory()) continue;
       let entries;
       try {
@@ -2676,7 +2824,7 @@ async function discoverCoworkFromDir(coworkDir) {
       }
       for (const entry of entries) {
         if (!entry.startsWith("local_") || !entry.endsWith(".json")) continue;
-        const jsonPath = join6(orgPath, entry);
+        const jsonPath = join7(orgPath, entry);
         const info = await extractCoworkSessionInfo(jsonPath);
         if (info) sessions.push(info);
       }
@@ -2688,7 +2836,7 @@ async function discoverCoworkFromDir(coworkDir) {
 async function extractCoworkSessionInfo(jsonPath) {
   let raw;
   try {
-    raw = await readFile5(jsonPath, "utf-8");
+    raw = await readFile6(jsonPath, "utf-8");
   } catch {
     return null;
   }
@@ -2700,8 +2848,8 @@ async function extractCoworkSessionInfo(jsonPath) {
   }
   if (!meta.sessionId) return null;
   const dir = jsonPath.replace(/\.json$/, "");
-  const auditPath = join6(dir, "audit.jsonl");
-  const auditStat = await stat2(auditPath).catch(() => null);
+  const auditPath = join7(dir, "audit.jsonl");
+  const auditStat = await stat3(auditPath).catch(() => null);
   if (!auditStat || auditStat.size === 0) return null;
   const sessionId = meta.sessionId.replace(/^local_/, "");
   const toolUseRe = /"type"\s*:\s*"tool_use"/g;
@@ -2738,6 +2886,7 @@ async function extractCoworkSessionInfo(jsonPath) {
   const model = meta.model ? meta.model.replace(/\[[^\]]*\]$/, "") : void 0;
   const fsDetectedFiles = Array.isArray(meta.fsDetectedFiles) ? meta.fsDetectedFiles.filter((file) => typeof file === "string") : void 0;
   const project = "Cowork";
+  const gitRepo = meta.cwd ? await readGitRepo(meta.cwd) : void 0;
   return {
     provider: "claude-cowork",
     sessionId,
@@ -2746,6 +2895,7 @@ async function extractCoworkSessionInfo(jsonPath) {
     project,
     cwd: meta.cwd || "",
     version: "",
+    gitRepo,
     timestamp,
     lineCount,
     fileSize,
@@ -2769,8 +2919,8 @@ function collectPromptsFromLines(lines, initialMessage) {
   const MAX = 2;
   const pushCleaned = (text) => {
     if (!text) return;
-    if (isSystemGeneratedMessage(text)) return;
-    const cleaned = previewPrompt(text);
+    if (isSystemGeneratedMessage2(text)) return;
+    const cleaned = previewPrompt2(text);
     if (cleaned.length < 10) return;
     if (prompts.includes(cleaned)) return;
     prompts.push(cleaned);
@@ -2794,8 +2944,8 @@ function collectPromptsFromLines(lines, initialMessage) {
   return prompts;
 }
 
-// src/providers/claude-cowork/parser.ts
-import { readFile as readFile6 } from "fs/promises";
+// ../provider-claude-code/src/claude-cowork/parser.ts
+import { readFile as readFile7 } from "fs/promises";
 function normalizeCoworkLine(line, onMalformedJson) {
   let obj;
   try {
@@ -2823,7 +2973,7 @@ async function parseClaudeCoworkSession(filePaths, sessionInfo) {
   const normalized = [];
   const parseWarnings = [];
   for (const fp of paths) {
-    const content = await readFile6(fp, "utf-8");
+    const content = await readFile7(fp, "utf-8");
     const lines = content.split("\n");
     for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
       const raw = lines[lineIndex];
@@ -2854,7 +3004,7 @@ async function parseClaudeCoworkSession(filePaths, sessionInfo) {
   return result;
 }
 
-// src/providers/claude-cowork/index.ts
+// ../provider-claude-code/src/claude-cowork/index.ts
 var claudeCoworkProvider = {
   name: "claude-cowork",
   displayName: "Claude Cowork",
@@ -2862,18 +3012,18 @@ var claudeCoworkProvider = {
   parse: parseClaudeCoworkSession
 };
 
-// src/providers/claude-desktop/discover.ts
-import { readdir as readdir4, readFile as readFile7, stat as stat3 } from "fs/promises";
+// ../provider-claude-code/src/claude-desktop/discover.ts
+import { readdir as readdir4, readFile as readFile8, stat as stat4 } from "fs/promises";
 import { homedir as homedir6 } from "os";
-import { join as join7 } from "path";
-var DESKTOP_DIR = join7(
+import { join as join8 } from "path";
+var DESKTOP_DIR = join8(
   homedir6(),
   "Library",
   "Application Support",
   "Claude",
   "claude-code-sessions"
 );
-var DEFAULT_CLAUDE_PROJECTS_DIR = join7(homedir6(), ".claude", "projects");
+var DEFAULT_CLAUDE_PROJECTS_DIR = join8(homedir6(), ".claude", "projects");
 async function discoverClaudeDesktopSessions() {
   if (process.platform !== "darwin") return [];
   return discoverFromDir(DESKTOP_DIR, DEFAULT_CLAUDE_PROJECTS_DIR);
@@ -2887,8 +3037,8 @@ async function discoverFromDir(desktopDir, claudeProjectsDir) {
     return sessions;
   }
   for (const accountId of accountDirs) {
-    const accountPath = join7(desktopDir, accountId);
-    const accountStat = await stat3(accountPath).catch(() => null);
+    const accountPath = join8(desktopDir, accountId);
+    const accountStat = await stat4(accountPath).catch(() => null);
     if (!accountStat?.isDirectory()) continue;
     let orgDirs;
     try {
@@ -2897,8 +3047,8 @@ async function discoverFromDir(desktopDir, claudeProjectsDir) {
       continue;
     }
     for (const orgId of orgDirs) {
-      const orgPath = join7(accountPath, orgId);
-      const orgStat = await stat3(orgPath).catch(() => null);
+      const orgPath = join8(accountPath, orgId);
+      const orgStat = await stat4(orgPath).catch(() => null);
       if (!orgStat?.isDirectory()) continue;
       let files;
       try {
@@ -2908,7 +3058,7 @@ async function discoverFromDir(desktopDir, claudeProjectsDir) {
       }
       for (const file of files) {
         if (!file.startsWith("local_") || !file.endsWith(".json")) continue;
-        const jsonPath = join7(orgPath, file);
+        const jsonPath = join8(orgPath, file);
         const info = await extractDesktopSessionInfo(jsonPath, claudeProjectsDir);
         if (info) sessions.push(info);
       }
@@ -2919,28 +3069,30 @@ async function discoverFromDir(desktopDir, claudeProjectsDir) {
 }
 async function extractDesktopSessionInfo(jsonPath, claudeProjectsDir = DEFAULT_CLAUDE_PROJECTS_DIR) {
   try {
-    const content = await readFile7(jsonPath, "utf-8");
+    const content = await readFile8(jsonPath, "utf-8");
     const desktop = JSON.parse(content);
     if (!desktop.cliSessionId || !desktop.cwd) return null;
     const encodedCwd = desktop.cwd.replace(/\/+$/, "").replace(/\//g, "-");
-    const jsonlPath = join7(claudeProjectsDir, encodedCwd, `${desktop.cliSessionId}.jsonl`);
-    const jsonlStat = await stat3(jsonlPath).catch(() => null);
+    const jsonlPath = join8(claudeProjectsDir, encodedCwd, `${desktop.cliSessionId}.jsonl`);
+    const jsonlStat = await stat4(jsonlPath).catch(() => null);
     if (!jsonlStat) return null;
     const info = await extractSessionInfo(jsonlPath, jsonlStat.size, desktop.cwd);
     if (!info) return null;
+    const gitRepo = await readGitRepo(desktop.cwd);
     return {
       ...info,
       provider: "claude-desktop",
       title: desktop.title || info.title,
       model: desktop.model || info.model,
-      timestamp: new Date(desktop.lastActivityAt).toISOString()
+      timestamp: new Date(desktop.lastActivityAt).toISOString(),
+      gitRepo
     };
   } catch {
     return null;
   }
 }
 
-// src/providers/claude-desktop/index.ts
+// ../provider-claude-code/src/claude-desktop/index.ts
 var claudeDesktopProvider = {
   name: "claude-desktop",
   displayName: "Claude Desktop",
@@ -2948,15 +3100,14 @@ var claudeDesktopProvider = {
   parse: parseClaudeCodeSession
 };
 
-// src/providers/codex/discover.ts
+// ../provider-codex/src/codex/discover.ts
 import { createReadStream as createReadStream3 } from "fs";
-import { readFile as readFile8, readdir as readdir5, stat as stat4 } from "fs/promises";
+import { readFile as readFile9, readdir as readdir5, stat as stat5 } from "fs/promises";
 import { homedir as homedir7 } from "os";
-import { basename, join as join8 } from "path";
+import { basename, join as join9 } from "path";
 import { createInterface as createInterface3 } from "readline";
-init_utils();
 
-// src/providers/codex/constants.ts
+// ../provider-codex/src/codex/constants.ts
 var USER_MESSAGE_BEGIN = "## My request for Codex:";
 var CODEX_CONTEXT_TAGS = [
   "environment_context",
@@ -3000,7 +3151,7 @@ function codexStripTwoPass(text) {
   return result;
 }
 
-// src/providers/codex/discover.ts
+// ../provider-codex/src/codex/discover.ts
 var STATE_DB_FILENAME = "state_5.sqlite";
 async function discoverCodexSessions() {
   const byId = /* @__PURE__ */ new Map();
@@ -3009,31 +3160,37 @@ async function discoverCodexSessions() {
     const info = await sessionInfoFromThreadRow(row);
     if (info) byId.set(info.sessionId, info);
   }
-  for (const filePath of await findRolloutFiles(join8(codexHome, "sessions"))) {
-    const fileStat = await stat4(filePath).catch(() => null);
+  for (const filePath of await findRolloutFiles(join9(codexHome, "sessions"))) {
+    const fileStat = await stat5(filePath).catch(() => null);
     if (!fileStat?.isFile()) continue;
     const info = await extractCodexSessionInfo(filePath, fileStat.size);
-    if (info && !byId.has(info.sessionId)) byId.set(info.sessionId, info);
+    if (info && !byId.has(info.sessionId)) {
+      if (info.cwd) info.gitRepo = await readGitRepo(info.cwd);
+      byId.set(info.sessionId, info);
+    }
   }
   return [...byId.values()].sort((a, b) => b.timestamp.localeCompare(a.timestamp));
 }
 async function sessionInfoFromThreadRow(row) {
   if (!row.id || !row.rollout_path) return null;
-  const fileStat = await stat4(row.rollout_path).catch(() => null);
+  const fileStat = await stat5(row.rollout_path).catch(() => null);
   if (!fileStat?.isFile()) return null;
   const extracted = await extractCodexSessionInfo(row.rollout_path, fileStat.size);
   const rowFirstPrompt = row.first_user_message ? normalizeDiscoveredUserMessage(row.first_user_message) : "";
   const firstPrompt = rowFirstPrompt || extracted?.firstPrompt || "";
   if (!firstPrompt) return extracted;
+  const cwd = row.cwd || extracted?.cwd || "";
+  const gitRepo = await readGitRepo(cwd);
   return {
     provider: "codex",
     sessionId: row.id,
     slug: row.id.slice(0, 8),
     title: row.title || extracted?.title,
-    project: shortenPath(row.cwd || extracted?.cwd || ""),
-    cwd: row.cwd || extracted?.cwd || "",
+    project: shortenPath(cwd),
+    cwd,
     version: row.cli_version || extracted?.version || "",
     gitBranch: row.git_branch || extracted?.gitBranch,
+    gitRepo,
     timestamp: toIsoFlexible(row.updated_at_ms || row.updated_at) || extracted?.timestamp || fileStat.mtime.toISOString(),
     lineCount: extracted?.lineCount || 0,
     fileSize: fileStat.size,
@@ -3144,7 +3301,7 @@ async function extractCodexSessionInfo(filePath, fileSize) {
     cwd,
     version: version2,
     gitBranch,
-    timestamp: timestamp || await stat4(filePath).then((s) => s.mtime.toISOString()),
+    timestamp: timestamp || await stat5(filePath).then((s) => s.mtime.toISOString()),
     lineCount,
     fileSize,
     filePath,
@@ -3160,12 +3317,12 @@ async function extractCodexSessionInfo(filePath, fileSize) {
 }
 async function readThreadRowsFromStateDb() {
   const stateDbPath = getStateDbPath();
-  const dbStat = await stat4(stateDbPath).catch(() => null);
+  const dbStat = await stat5(stateDbPath).catch(() => null);
   if (!dbStat?.isFile() || dbStat.size < 1024) return [];
   try {
     const mod = await import("sql.js");
     const SQL = await mod.default();
-    const dbBuffer = await readFile8(stateDbPath);
+    const dbBuffer = await readFile9(stateDbPath);
     const db = new SQL.Database(dbBuffer);
     try {
       const result = db.exec(`
@@ -3202,7 +3359,7 @@ async function findRolloutFiles(dir) {
       return;
     }
     for (const entry of entries) {
-      const fp = join8(current, entry.name);
+      const fp = join9(current, entry.name);
       if (entry.isDirectory()) await walk(fp);
       else if (entry.isFile() && entry.name.startsWith("rollout-") && entry.name.endsWith(".jsonl")) {
         out.push(fp);
@@ -3213,11 +3370,11 @@ async function findRolloutFiles(dir) {
   return out;
 }
 function getCodexHome() {
-  return process.env.CODEX_HOME || join8(homedir7(), ".codex");
+  return process.env.CODEX_HOME || join9(homedir7(), ".codex");
 }
 function getStateDbPath() {
   const sqliteHome = process.env.CODEX_SQLITE_HOME || getCodexHome();
-  return join8(sqliteHome, STATE_DB_FILENAME);
+  return join9(sqliteHome, STATE_DB_FILENAME);
 }
 function toIsoFlexible(value) {
   if (!value) return void 0;
@@ -3229,7 +3386,7 @@ function isEditTool(name) {
   return !!name && ["apply_patch", "edit", "write_file"].includes(name);
 }
 function normalizeDiscoveredUserMessage(text) {
-  return cleanPromptText(codexStripTwoPass(text));
+  return cleanPromptText2(codexStripTwoPass(text));
 }
 function recordDiscoveredPrompt(promptSeen, prompts, timestamp, text, imageKey) {
   const hasImages = imageKey.length > 0;
@@ -3279,9 +3436,9 @@ function imageDedupeKey(image) {
   return `${image.slice(0, 64)}:${image.length}:${image.slice(-32)}`;
 }
 
-// src/providers/codex/parser.ts
+// ../provider-codex/src/codex/parser.ts
 import { readFileSync } from "fs";
-import { readFile as readFile9 } from "fs/promises";
+import { readFile as readFile10 } from "fs/promises";
 import { extname } from "path";
 function asCodexTokenInfo(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
@@ -3294,7 +3451,7 @@ async function parseCodexSession(filePaths, sessionInfo) {
   const paths = Array.isArray(filePaths) ? filePaths : [filePaths];
   const lines = [];
   for (const fp of paths) {
-    const content = await readFile9(fp, "utf-8");
+    const content = await readFile10(fp, "utf-8");
     lines.push(...content.split("\n"));
   }
   return parseCodexLines(lines, sessionInfo, paths);
@@ -3921,31 +4078,31 @@ function buildCodexTurnStats(turns, snapshots, taskDurations, model) {
   const usable = snapshots.filter((s) => s.last);
   return userTurns.map((turn, i) => {
     const usage = usable[i]?.last;
-    const stat12 = { turnIndex: i };
-    if (model) stat12.model = model;
+    const stat13 = { turnIndex: i };
+    if (model) stat13.model = model;
     if (usage) {
       const input = usage.input_tokens || 0;
       const cached = usage.cached_input_tokens || 0;
-      stat12.tokenUsage = {
+      stat13.tokenUsage = {
         inputTokens: Math.max(0, input - cached),
         outputTokens: usage.output_tokens || 0,
         cacheCreationTokens: 0,
         cacheReadTokens: cached
       };
-      stat12.contextTokens = input;
+      stat13.contextTokens = input;
     }
     const nextUser = userTurns[i + 1]?.timestamp;
     const taskDuration = taskDurations[i];
     if (typeof taskDuration === "number" && taskDuration > 0) {
-      stat12.durationMs = taskDuration;
+      stat13.durationMs = taskDuration;
     } else if (turn.timestamp) {
       const end = nextUser || usable[i]?.timestamp;
       if (end) {
         const diff = Date.parse(end) - Date.parse(turn.timestamp);
-        if (diff > 0 && diff < 12 * 60 * 60 * 1e3) stat12.durationMs = diff;
+        if (diff > 0 && diff < 12 * 60 * 60 * 1e3) stat13.durationMs = diff;
       }
     }
-    return stat12;
+    return stat13;
   });
 }
 function pushUnique(items, value) {
@@ -3979,7 +4136,7 @@ function mimeTypeForPath(path) {
   }
 }
 
-// src/providers/codex/index.ts
+// ../provider-codex/src/codex/index.ts
 var codexProvider = {
   name: "codex",
   displayName: "Codex",
@@ -3987,22 +4144,20 @@ var codexProvider = {
   parse: parseCodexSession
 };
 
-// src/providers/cursor/discover.ts
-init_utils();
-import { readdir as readdir8, readFile as readFile12, stat as stat7 } from "fs/promises";
+// ../provider-cursor/src/cursor/discover.ts
+import { readdir as readdir8, readFile as readFile13, stat as stat8 } from "fs/promises";
 import { homedir as homedir11 } from "os";
-import { basename as basename3, join as join12 } from "path";
+import { basename as basename3, join as join13 } from "path";
 
-// src/providers/cursor/sqlite-reader.ts
+// ../provider-cursor/src/cursor/sqlite-reader.ts
 import { createHash as createHash2 } from "crypto";
 import { execFile } from "child_process";
-import { readdir as readdir6, readFile as readFile10, stat as stat5 } from "fs/promises";
+import { readdir as readdir6, readFile as readFile11, stat as stat6 } from "fs/promises";
 import { homedir as homedir9 } from "os";
-import { basename as basename2, dirname as dirname2, join as join10, posix } from "path";
+import { basename as basename2, dirname as dirname2, join as join11, posix } from "path";
 import { promisify } from "util";
-init_utils();
 
-// src/providers/cursor/sanitize.ts
+// ../provider-cursor/src/cursor/sanitize.ts
 function internalPlanningHeadingBreakRe() {
   return /\n{2,}\*\*([^*\n]{3,120})\*\*\n{2,}/g;
 }
@@ -4071,11 +4226,11 @@ function looksLikeInternalPlanningBody(text) {
   );
 }
 
-// src/providers/cursor/sqlite-io.ts
+// ../provider-cursor/src/cursor/sqlite-io.ts
 import { createHash } from "crypto";
 import { homedir as homedir8 } from "os";
-import { join as join9 } from "path";
-var CURSOR_CHATS_DIR = join9(homedir8(), ".cursor", "chats");
+import { join as join10 } from "path";
+var CURSOR_CHATS_DIR = join10(homedir8(), ".cursor", "chats");
 function createRetryableInit(factory) {
   let promise = null;
   return async () => {
@@ -4092,7 +4247,7 @@ function workspaceHash(absolutePath) {
   return createHash("md5").update(absolutePath).digest("hex");
 }
 
-// src/providers/cursor/tool-mapping.ts
+// ../provider-cursor/src/cursor/tool-mapping.ts
 function parseJson(raw) {
   if (typeof raw !== "string") return null;
   try {
@@ -4385,7 +4540,7 @@ function mapToolArgs(toolName, args, resultText = "") {
   return argsObj;
 }
 
-// src/providers/cursor/sqlite-reader.ts
+// ../provider-cursor/src/cursor/sqlite-reader.ts
 var SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 var MIN_STORE_DB_SIZE = 8192;
 var MAX_CURSOR_REQUEST_CONTEXT_ROWS = 500;
@@ -4412,7 +4567,7 @@ var resolvedProjectRootCache = /* @__PURE__ */ new Map();
 var GLOBAL_STATE_DISCOVERY_CACHE_PREFIX = "cursor-global-state-discovery-v4";
 function globalStateDbCandidates() {
   const candidates = [
-    join10(
+    join11(
       homedir9(),
       "Library",
       "Application Support",
@@ -4421,23 +4576,23 @@ function globalStateDbCandidates() {
       "globalStorage",
       "state.vscdb"
     ),
-    join10(homedir9(), ".config", "Cursor", "User", "globalStorage", "state.vscdb")
+    join11(homedir9(), ".config", "Cursor", "User", "globalStorage", "state.vscdb")
   ];
   const appData = process.env.APPDATA;
   if (appData) {
-    candidates.push(join10(appData, "Cursor", "User", "globalStorage", "state.vscdb"));
+    candidates.push(join11(appData, "Cursor", "User", "globalStorage", "state.vscdb"));
   }
   return [...new Set(candidates)];
 }
 async function findGlobalStateDb() {
   for (const candidate of globalStateDbCandidates()) {
-    const s = await stat5(candidate).catch(() => null);
+    const s = await stat6(candidate).catch(() => null);
     if (s?.isFile() && s.size >= MIN_STORE_DB_SIZE) return candidate;
   }
   return null;
 }
 async function globalStateWalFingerprint(dbPath) {
-  const walStat = await stat5(`${dbPath}-wal`).catch(() => null);
+  const walStat = await stat6(`${dbPath}-wal`).catch(() => null);
   return {
     walSize: walStat?.isFile() ? walStat.size : 0,
     walMtimeMs: walStat?.isFile() ? walStat.mtimeMs : 0
@@ -4623,7 +4778,7 @@ async function queryGlobalStateTextValue(globalStateDb, key) {
 async function openGlobalStateDb() {
   const dbPath = await findGlobalStateDb();
   if (!dbPath) return null;
-  const dbStat = await stat5(dbPath).catch(() => null);
+  const dbStat = await stat6(dbPath).catch(() => null);
   if (!dbStat?.isFile() || dbStat.size < MIN_STORE_DB_SIZE) return null;
   const walFingerprint = await globalStateWalFingerprint(dbPath);
   if (cachedGlobalStateDb && cachedGlobalStateDb.dbPath === dbPath && cachedGlobalStateDb.size === dbStat.size && cachedGlobalStateDb.mtimeMs === dbStat.mtimeMs && cachedGlobalStateDb.walSize === walFingerprint.walSize && cachedGlobalStateDb.walMtimeMs === walFingerprint.walMtimeMs) {
@@ -4646,7 +4801,7 @@ async function openGlobalStateDb() {
   } catch {
     return null;
   }
-  const dbBuffer = await readFile10(dbPath).catch(() => null);
+  const dbBuffer = await readFile11(dbPath).catch(() => null);
   if (!dbBuffer) return null;
   const db = new SQL.Database(dbBuffer);
   closeCachedSqlJsDb();
@@ -4678,8 +4833,8 @@ async function buildStoreDbIndex() {
     return index;
   }
   for (const wsHash of workspaceDirs) {
-    const wsDir = join10(CURSOR_CHATS_DIR, wsHash);
-    const wsStat = await stat5(wsDir).catch(() => null);
+    const wsDir = join11(CURSOR_CHATS_DIR, wsHash);
+    const wsStat = await stat6(wsDir).catch(() => null);
     if (!wsStat?.isDirectory()) continue;
     let sessions;
     try {
@@ -4689,8 +4844,8 @@ async function buildStoreDbIndex() {
     }
     for (const sessionId of sessions) {
       if (!SESSION_ID_RE.test(sessionId)) continue;
-      const dbPath = join10(wsDir, sessionId, "store.db");
-      const dbStat = await stat5(dbPath).catch(() => null);
+      const dbPath = join11(wsDir, sessionId, "store.db");
+      const dbStat = await stat6(dbPath).catch(() => null);
       if (!dbStat?.isFile() || dbStat.size < MIN_STORE_DB_SIZE) continue;
       index.set(sessionId, {
         dbPath,
@@ -4715,7 +4870,7 @@ async function findStoreDb(sessionId) {
   return refreshed.get(sessionId)?.dbPath || null;
 }
 async function existingPath(path) {
-  const s = await stat5(path).catch(() => null);
+  const s = await stat6(path).catch(() => null);
   return s ? path : null;
 }
 async function resolveCursorLiveWatchPaths(sessionId) {
@@ -5054,14 +5209,14 @@ async function resolveProjectRootFromPath(rawPath) {
   if (cached) return cached;
   const resolving = (async () => {
     let current = candidate;
-    const initial = await stat5(current).catch(() => null);
+    const initial = await stat6(current).catch(() => null);
     if (initial?.isFile()) current = dirname2(current);
     let deepestExisting = null;
     while (current && current !== "/") {
-      const dirStat = await stat5(current).catch(() => null);
+      const dirStat = await stat6(current).catch(() => null);
       if (dirStat?.isDirectory()) {
         if (!deepestExisting) deepestExisting = current;
-        const gitStat = await stat5(join10(current, ".git")).catch(() => null);
+        const gitStat = await stat6(join11(current, ".git")).catch(() => null);
         if (gitStat) return current;
       }
       const parent = dirname2(current);
@@ -5184,7 +5339,7 @@ async function readStoreDbMeta(dbPath) {
   } catch {
     return null;
   }
-  const dbBuffer = await readFile10(dbPath).catch(() => null);
+  const dbBuffer = await readFile11(dbPath).catch(() => null);
   if (!dbBuffer) return null;
   const db = new SQL.Database(dbBuffer);
   try {
@@ -5490,7 +5645,7 @@ async function parseCursorStoreDb(sessionId, workspacePath = "") {
   } catch {
     return null;
   }
-  const dbBuffer = await readFile10(dbPath);
+  const dbBuffer = await readFile11(dbPath);
   const db = new SQL.Database(dbBuffer);
   try {
     const metaRows = db.exec("SELECT value FROM meta WHERE key = '0'");
@@ -5607,7 +5762,7 @@ function buildCursorStoreResult(sessionId, workspacePath, metaJson, messages) {
   const { turns, turnStats, totalDurationMs } = messagesToTurns(messages);
   const slug = sessionId.slice(0, 8);
   const title = metaJson.name || firstUserTextSnippet(turns);
-  const hasDurationStats = turnStats.some((stat12) => (stat12.durationMs || 0) > 0);
+  const hasDurationStats = turnStats.some((stat13) => (stat13.durationMs || 0) > 0);
   const notes = [];
   if (hasDurationStats) {
     notes.push("Per-turn duration is estimated from Cursor tool execution metadata.");
@@ -5620,7 +5775,7 @@ function buildCursorStoreResult(sessionId, workspacePath, metaJson, messages) {
     slug,
     title,
     cwd: workspacePath,
-    model: normalizeCursorModelName(metaJson.lastUsedModel) || turnStats.find((stat12) => typeof stat12.model === "string" && stat12.model)?.model,
+    model: normalizeCursorModelName(metaJson.lastUsedModel) || turnStats.find((stat13) => typeof stat13.model === "string" && stat13.model)?.model,
     startTime: metaJson.createdAt ? new Date(metaJson.createdAt).toISOString() : void 0,
     ...totalDurationMs !== void 0 ? { totalDurationMs } : {},
     ...turnStats.length > 0 ? { turnStats } : {},
@@ -6022,13 +6177,13 @@ function mergeUniqueStrings(...groups) {
 }
 function mergeCursorParseResults(primary, enrichment) {
   const mergedModel = chooseMergedCursorModel(primary.model, enrichment.model);
-  const preferEnrichmentDuration = enrichment.dataSource === "global-state" && (enrichment.totalDurationMs !== void 0 || enrichment.turnStats?.some((stat12) => stat12.durationMs !== void 0) === true);
+  const preferEnrichmentDuration = enrichment.dataSource === "global-state" && (enrichment.totalDurationMs !== void 0 || enrichment.turnStats?.some((stat13) => stat13.durationMs !== void 0) === true);
   const mergedTurnStats = mergeTurnStats(primary.turnStats, enrichment.turnStats, {
     preferEnrichmentDuration
   });
   const mergedTokenUsage = primary.tokenUsage || enrichment.tokenUsage;
   const mergedTokenUsageByModel = primary.tokenUsageByModel || enrichment.tokenUsageByModel;
-  const mergedTotalDurationMs = (preferEnrichmentDuration ? enrichment.totalDurationMs : void 0) || primary.totalDurationMs || (!preferEnrichmentDuration ? enrichment.totalDurationMs : void 0) || (mergedTurnStats && mergedTurnStats.length > 0 ? mergedTurnStats.reduce((sum, stat12) => sum + (stat12.durationMs || 0), 0) || void 0 : void 0);
+  const mergedTotalDurationMs = (preferEnrichmentDuration ? enrichment.totalDurationMs : void 0) || primary.totalDurationMs || (!preferEnrichmentDuration ? enrichment.totalDurationMs : void 0) || (mergedTurnStats && mergedTurnStats.length > 0 ? mergedTurnStats.reduce((sum, stat13) => sum + (stat13.durationMs || 0), 0) || void 0 : void 0);
   const mergedDuration = mergedTotalDurationMs !== primary.totalDurationMs;
   const mergedTokens = !primary.tokenUsage && !!enrichment.tokenUsage || !primary.tokenUsageByModel && !!enrichment.tokenUsageByModel;
   const supplements = mergeUniqueStrings(
@@ -6112,11 +6267,11 @@ function mergeTurnStats(primary, enrichment, options) {
   if (!primary?.length) return enrichment;
   if (!enrichment?.length) return primary;
   const maxTurnIndex = Math.max(
-    ...primary.map((stat12) => stat12.turnIndex),
-    ...enrichment.map((stat12) => stat12.turnIndex)
+    ...primary.map((stat13) => stat13.turnIndex),
+    ...enrichment.map((stat13) => stat13.turnIndex)
   );
-  const primaryByIndex = new Map(primary.map((stat12) => [stat12.turnIndex, stat12]));
-  const enrichmentByIndex = new Map(enrichment.map((stat12) => [stat12.turnIndex, stat12]));
+  const primaryByIndex = new Map(primary.map((stat13) => [stat13.turnIndex, stat13]));
+  const enrichmentByIndex = new Map(enrichment.map((stat13) => [stat13.turnIndex, stat13]));
   const merged = [];
   for (let turnIndex = 0; turnIndex <= maxTurnIndex; turnIndex++) {
     const current = primaryByIndex.get(turnIndex);
@@ -6210,17 +6365,17 @@ function applyGlobalStateWallClockDurations(entries, turnStats) {
   if (durationsByTurn.size === 0) {
     return {
       turnStats,
-      totalDurationMs: turnStats.reduce((sum, stat12) => sum + (stat12.durationMs || 0), 0) || void 0,
+      totalDurationMs: turnStats.reduce((sum, stat13) => sum + (stat13.durationMs || 0), 0) || void 0,
       usedWallClock: false
     };
   }
-  const mergedTurnStats = turnStats.map((stat12) => {
-    const wallClockDuration = durationsByTurn.get(stat12.turnIndex);
-    return wallClockDuration !== void 0 ? { ...stat12, durationMs: wallClockDuration } : stat12;
+  const mergedTurnStats = turnStats.map((stat13) => {
+    const wallClockDuration = durationsByTurn.get(stat13.turnIndex);
+    return wallClockDuration !== void 0 ? { ...stat13, durationMs: wallClockDuration } : stat13;
   });
   return {
     turnStats: mergedTurnStats,
-    totalDurationMs: mergedTurnStats.reduce((sum, stat12) => sum + (stat12.durationMs || 0), 0) || void 0,
+    totalDurationMs: mergedTurnStats.reduce((sum, stat13) => sum + (stat13.durationMs || 0), 0) || void 0,
     usedWallClock: true
   };
 }
@@ -6266,15 +6421,15 @@ function buildGlobalStateMetrics(entries, fallbackModel, sessionTokenUsage) {
       current.durationMs = (current.durationMs || 0) + bubbleDurationMs;
     }
   }
-  for (const stat12 of turnStats) {
-    if (stat12.tokenUsage && !hasAnyTokens(stat12.tokenUsage)) {
-      delete stat12.tokenUsage;
+  for (const stat13 of turnStats) {
+    if (stat13.tokenUsage && !hasAnyTokens(stat13.tokenUsage)) {
+      delete stat13.tokenUsage;
     }
-    if ((stat12.durationMs || 0) <= 0) {
-      delete stat12.durationMs;
+    if ((stat13.durationMs || 0) <= 0) {
+      delete stat13.durationMs;
     }
-    if ((stat12.contextTokens || 0) <= 0) {
-      delete stat12.contextTokens;
+    if ((stat13.contextTokens || 0) <= 0) {
+      delete stat13.contextTokens;
     }
   }
   const {
@@ -6422,7 +6577,7 @@ ${buildBubbleProjectHintData(bubbleEntries)}`,
     }
     const hasDetailedTurnStats = Boolean(
       metrics.turnStats?.some(
-        (stat12) => !!stat12.durationMs || !!stat12.contextTokens || !!stat12.tokenUsage
+        (stat13) => !!stat13.durationMs || !!stat13.contextTokens || !!stat13.tokenUsage
       )
     );
     if (!hasDetailedTurnStats) {
@@ -6525,7 +6680,7 @@ function messagesToTurns(messages) {
     }
   }
   const turnStats = buildStoreTurnStats(turns);
-  const totalDurationMs = turnStats.length > 0 ? turnStats.reduce((sum, stat12) => sum + (stat12.durationMs || 0), 0) || void 0 : void 0;
+  const totalDurationMs = turnStats.length > 0 ? turnStats.reduce((sum, stat13) => sum + (stat13.durationMs || 0), 0) || void 0 : void 0;
   return { turns, turnStats, totalDurationMs };
 }
 var CURSOR_SYSTEM_CONTEXT_RE = /^<(?:user_info|system_reminder|agent_transcripts|rules|git_status)>/;
@@ -6613,13 +6768,13 @@ function extractModel(msg) {
   return void 0;
 }
 
-// src/providers/cursor/sdk-reader.ts
+// ../provider-cursor/src/cursor/sdk-reader.ts
 import { execFile as execFile2 } from "child_process";
-import { readdir as readdir7, readFile as readFile11, stat as stat6 } from "fs/promises";
+import { readdir as readdir7, readFile as readFile12, stat as stat7 } from "fs/promises";
 import { homedir as homedir10 } from "os";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 import { promisify as promisify2 } from "util";
-var CURSOR_PROJECTS_ROOT = join11(homedir10(), ".cursor", "projects");
+var CURSOR_PROJECTS_ROOT = join12(homedir10(), ".cursor", "projects");
 var SDK_STORE_SUBDIR = "sdk-agent-store";
 var SDK_INDEX_DB_BASENAME = "index.db";
 var MIN_INDEX_DB_SIZE = 1024;
@@ -6902,7 +7057,7 @@ function applySdkEnrichmentToTurns(turns, enrichment) {
   return { turns, toolCallsEnriched, assistantTurnsModelTagged };
 }
 async function openIndexDb(dbPath) {
-  const st = await stat6(dbPath).catch(() => null);
+  const st = await stat7(dbPath).catch(() => null);
   if (!st?.isFile() || st.size < MIN_INDEX_DB_SIZE) return null;
   if (await canUseSqliteCliFor(dbPath)) {
     return { dbPath, backend: "sqlite-cli" };
@@ -6914,7 +7069,7 @@ async function openIndexDb(dbPath) {
     return null;
   }
   if (st.size > MAX_SQLJS_DB_BYTES) return null;
-  const buffer = await readFile11(dbPath).catch(() => null);
+  const buffer = await readFile12(dbPath).catch(() => null);
   if (!buffer) return null;
   const db = new SQL.Database(buffer);
   return { dbPath, backend: "sqljs", db };
@@ -6973,13 +7128,13 @@ async function listSdkIndexDbPaths(projectsRoot) {
   const perProjectPaths = await Promise.all(
     projects.map(async (project) => {
       const out = [];
-      const sdkRoot = join11(projectsRoot, project, SDK_STORE_SUBDIR);
-      const sdkStat = await stat6(sdkRoot).catch(() => null);
+      const sdkRoot = join12(projectsRoot, project, SDK_STORE_SUBDIR);
+      const sdkStat = await stat7(sdkRoot).catch(() => null);
       if (!sdkStat?.isDirectory()) return out;
       const projectHashes = await readdir7(sdkRoot).catch(() => []);
       for (const hash of projectHashes) {
-        const dbPath = join11(sdkRoot, hash, SDK_INDEX_DB_BASENAME);
-        const dbStat = await stat6(dbPath).catch(() => null);
+        const dbPath = join12(sdkRoot, hash, SDK_INDEX_DB_BASENAME);
+        const dbStat = await stat7(dbPath).catch(() => null);
         if (!dbStat?.isFile() || dbStat.size < MIN_INDEX_DB_SIZE) continue;
         out.push(dbPath);
       }
@@ -7012,8 +7167,8 @@ function safeJsonStringify(value) {
   }
 }
 
-// src/providers/cursor/discover.ts
-var CURSOR_DIR = join12(homedir11(), ".cursor", "projects");
+// ../provider-cursor/src/cursor/discover.ts
+var CURSOR_DIR = join13(homedir11(), ".cursor", "projects");
 var PROJECT_DISCOVERY_CONCURRENCY = 6;
 var TRANSCRIPT_INFO_CONCURRENCY = 6;
 var ENTRY_STAT_CONCURRENCY = 32;
@@ -7052,14 +7207,15 @@ async function discoverCursorSessions() {
   return sessions;
 }
 async function discoverProjectSessions(projDir) {
-  const transcriptsDir = join12(CURSOR_DIR, projDir, "agent-transcripts");
-  const dirStat = await stat7(transcriptsDir).catch(() => null);
+  const transcriptsDir = join13(CURSOR_DIR, projDir, "agent-transcripts");
+  const dirStat = await stat8(transcriptsDir).catch(() => null);
   if (!dirStat?.isDirectory()) return [];
   const project = await decodeProjectDir2(projDir);
+  const gitRepo = await readGitRepo(project);
   const transcriptEntries = await collectTranscriptEntries(transcriptsDir);
   if (transcriptEntries.length === 0) return [];
   transcriptEntries.sort((a, b) => a.mtimeMs - b.mtimeMs);
-  const toolEntries = await collectToolEntries(join12(CURSOR_DIR, projDir, "agent-tools"));
+  const toolEntries = await collectToolEntries(join13(CURSOR_DIR, projDir, "agent-tools"));
   toolEntries.sort((a, b) => a.mtimeMs - b.mtimeMs);
   const jobs = [];
   let toolStart = 0;
@@ -7089,6 +7245,7 @@ async function discoverProjectSessions(projDir) {
     if (!info) return null;
     info.workspacePath = project;
     info.hasSqlite = false;
+    info.gitRepo = gitRepo;
     return info;
   });
   return infos.filter((info) => info !== null);
@@ -7148,7 +7305,7 @@ async function decodeWindowsProjectDir(encoded) {
 }
 async function resolveEncodedProjectParts(parts, idx, current) {
   if (idx >= parts.length) {
-    const currentStat = await stat7(current).catch(() => null);
+    const currentStat = await stat8(current).catch(() => null);
     return currentStat?.isDirectory() ? current : null;
   }
   const entries = await readdir8(current, { withFileTypes: true }).catch(() => []);
@@ -7158,10 +7315,10 @@ async function resolveEncodedProjectParts(parts, idx, current) {
   );
   for (let end = idx + 1; end <= parts.length; end++) {
     const candidate = parts.slice(idx, end).join("-");
-    const candidatePath = join12(current, candidate);
+    const candidatePath = join13(current, candidate);
     if (!dirNames.has(candidate)) {
       if (process.platform !== "win32") continue;
-      const candidateStat = await stat7(candidatePath).catch(() => null);
+      const candidateStat = await stat8(candidatePath).catch(() => null);
       if (!candidateStat?.isDirectory()) continue;
     }
     const resolved = await resolveEncodedProjectParts(parts, end, candidatePath);
@@ -7171,7 +7328,7 @@ async function resolveEncodedProjectParts(parts, idx, current) {
 }
 async function extractSessionInfo2(filePath, fileSize, mtimeMs, project, toolPaths) {
   try {
-    const content = await readFile12(filePath, "utf-8");
+    const content = await readFile13(filePath, "utf-8");
     const sessionId = basename3(filePath, ".jsonl");
     let firstPrompt = "";
     let promptCount = 0;
@@ -7248,8 +7405,8 @@ async function collectTranscriptEntries(transcriptsDir) {
     return [];
   }
   const transcripts = await mapLimit(entries, ENTRY_STAT_CONCURRENCY, async (entry) => {
-    const entryPath = join12(transcriptsDir, entry);
-    const entryStat = await stat7(entryPath).catch(() => null);
+    const entryPath = join13(transcriptsDir, entry);
+    const entryStat = await stat8(entryPath).catch(() => null);
     if (!entryStat) return null;
     if (entry.endsWith(".jsonl") && entryStat.isFile()) {
       return {
@@ -7259,8 +7416,8 @@ async function collectTranscriptEntries(transcriptsDir) {
       };
     }
     if (!entryStat.isDirectory()) return null;
-    const innerPath = join12(entryPath, `${entry}.jsonl`);
-    const innerStat = await stat7(innerPath).catch(() => null);
+    const innerPath = join13(entryPath, `${entry}.jsonl`);
+    const innerStat = await stat8(innerPath).catch(() => null);
     if (!innerStat?.isFile()) return null;
     return {
       path: innerPath,
@@ -7271,7 +7428,7 @@ async function collectTranscriptEntries(transcriptsDir) {
   return transcripts.filter((entry) => entry !== null);
 }
 async function collectToolEntries(toolDir) {
-  const dirStat = await stat7(toolDir).catch(() => null);
+  const dirStat = await stat8(toolDir).catch(() => null);
   if (!dirStat?.isDirectory()) return [];
   let entries;
   try {
@@ -7281,8 +7438,8 @@ async function collectToolEntries(toolDir) {
   }
   const toolFiles = entries.filter((entry) => entry.endsWith(".txt"));
   const tools = await mapLimit(toolFiles, ENTRY_STAT_CONCURRENCY, async (entry) => {
-    const entryPath = join12(toolDir, entry);
-    const entryStat = await stat7(entryPath).catch(() => null);
+    const entryPath = join13(toolDir, entry);
+    const entryStat = await stat8(entryPath).catch(() => null);
     if (!entryStat?.isFile()) return null;
     return { path: entryPath, mtimeMs: entryStat.mtimeMs };
   });
@@ -7305,10 +7462,20 @@ async function mapLimit(items, concurrency, worker) {
   return results;
 }
 
-// src/providers/cursor/parser.ts
-import { readdir as readdir9, readFile as readFile13, stat as stat8 } from "fs/promises";
+// ../provider-cursor/src/cursor/parser.ts
+import { readdir as readdir9, readFile as readFile14, stat as stat9 } from "fs/promises";
 import { homedir as homedir12 } from "os";
-import { basename as basename4, extname as extname2, join as join13 } from "path";
+import { basename as basename4, extname as extname2, join as join14 } from "path";
+var defaultDependencies = {
+  isSystemContextText,
+  mapCursorToolName,
+  mapToolArgs,
+  parseCursorSqlite
+};
+function createCursorParser(deps = {}) {
+  const resolved = { ...defaultDependencies, ...deps };
+  return (filePaths, sessionInfo) => parseCursorSessionWithDependencies(filePaths, sessionInfo, resolved);
+}
 var CURSOR_UUID_SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function toErrorMessage(err) {
   if (err instanceof Error && err.message) return err.message;
@@ -7319,7 +7486,8 @@ function compactErrorMessage(err, max = 180) {
   if (cleaned.length <= max) return cleaned;
   return `${cleaned.slice(0, max)}...`;
 }
-async function parseCursorSession(filePaths, sessionInfo) {
+var parseCursorSession = createCursorParser();
+async function parseCursorSessionWithDependencies(filePaths, sessionInfo, deps) {
   const paths = Array.isArray(filePaths) ? filePaths : [filePaths];
   const transcriptPaths = paths.filter((p) => p.endsWith(".jsonl"));
   const explicitToolPaths = paths.filter((p) => p.endsWith(".txt"));
@@ -7333,7 +7501,7 @@ async function parseCursorSession(filePaths, sessionInfo) {
     let sqliteResult = null;
     try {
       const preferredWorkspacePath2 = sessionInfo?.workspacePath || sessionInfo?.cwd || "";
-      sqliteResult = await parseCursorSqlite(preferredWorkspacePath2, sqliteSessionId);
+      sqliteResult = await deps.parseCursorSqlite(preferredWorkspacePath2, sqliteSessionId);
     } catch (err) {
       sqliteError = compactErrorMessage(err);
       sqliteFallbackNote = `cursor SQLite parse failed (${sqliteError}); fell back to JSONL transcript`;
@@ -7343,9 +7511,14 @@ async function parseCursorSession(filePaths, sessionInfo) {
       if (transcriptPaths.length > 0) {
         const thinkingBefore = countThinkingBlocks(sqliteResult.turns);
         const userImagesBefore = countUserImages(sqliteResult.turns);
-        const jsonlThinking = await parseCursorJsonl(transcriptPaths, [], {
-          inferToolPaths: false
-        });
+        const jsonlThinking = await parseCursorJsonl(
+          transcriptPaths,
+          [],
+          {
+            inferToolPaths: false
+          },
+          deps
+        );
         sqliteResult.parseWarnings = mergeParseWarnings(
           sqliteResult.parseWarnings,
           jsonlThinking.parseWarnings
@@ -7379,9 +7552,14 @@ async function parseCursorSession(filePaths, sessionInfo) {
     }
     throw new Error("Cursor parse requires at least one transcript .jsonl path");
   }
-  const jsonlResult = await parseCursorJsonl(transcriptPaths, explicitToolPaths, {
-    inferToolPaths: true
-  });
+  const jsonlResult = await parseCursorJsonl(
+    transcriptPaths,
+    explicitToolPaths,
+    {
+      inferToolPaths: true
+    },
+    deps
+  );
   const preferredWorkspacePath = sessionInfo?.workspacePath || sessionInfo?.cwd || "";
   if (!jsonlResult.cwd && preferredWorkspacePath) {
     jsonlResult.cwd = preferredWorkspacePath;
@@ -7488,7 +7666,7 @@ function withNote(info, note) {
   if (!notes.includes(note)) notes.push(note);
   return { ...info, notes };
 }
-async function parseCursorJsonl(transcriptPaths, explicitToolPaths, options) {
+async function parseCursorJsonl(transcriptPaths, explicitToolPaths, options, deps) {
   const allTurns = [];
   let syntheticToolId = 0;
   const toolResults = /* @__PURE__ */ new Map();
@@ -7498,7 +7676,7 @@ async function parseCursorJsonl(transcriptPaths, explicitToolPaths, options) {
   const sortedTranscriptPaths = await sortByMtime(transcriptPaths);
   const sessionId = basename4(sortedTranscriptPaths[sortedTranscriptPaths.length - 1], ".jsonl");
   for (const filePath of sortedTranscriptPaths) {
-    const content = await readFile13(filePath, "utf-8");
+    const content = await readFile14(filePath, "utf-8");
     const lines = content.split("\n");
     for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
       const line = lines[lineIndex];
@@ -7536,7 +7714,7 @@ async function parseCursorJsonl(transcriptPaths, explicitToolPaths, options) {
           }
         } else if (block.type === "text" && block.text) {
           let text = stripUserQueryWrapper(block.text);
-          if (role === "user" && isSystemContextText(text)) continue;
+          if (role === "user" && deps.isSystemContextText(text)) continue;
           const extracted = extractImageFilePathsFromText(text);
           text = normalizeImagePlaceholderLines(extracted.cleanedText);
           for (const imagePath of extracted.paths) imageFilePaths.add(imagePath);
@@ -7605,14 +7783,14 @@ async function parseCursorJsonl(transcriptPaths, explicitToolPaths, options) {
           if (thinking) blocks.push({ type: "thinking", thinking });
         } else if (block.type === "tool_use") {
           const rawName = typeof block.name === "string" && block.name.trim() ? block.name.trim() : "Tool";
-          const name = mapCursorToolName(rawName);
+          const name = deps.mapCursorToolName(rawName);
           blocks.push({
             type: "tool_use",
             id: typeof block.id === "string" && block.id.trim() ? block.id : `cursor-inline-${syntheticToolId++}`,
             name,
             // Keep the raw name here because Cursor raw tools carry different arg
             // schemas even when they map to the same canonical replay tool.
-            input: mapToolArgs(rawName, block.input)
+            input: deps.mapToolArgs(rawName, block.input)
           });
         }
       }
@@ -7628,7 +7806,7 @@ async function parseCursorJsonl(transcriptPaths, explicitToolPaths, options) {
   const toolPaths = explicitToolPaths.length > 0 ? await sortByMtime(explicitToolPaths) : options.inferToolPaths ? await inferToolPaths(sortedTranscriptPaths) : [];
   const toolEvents = await loadToolEvents(toolPaths);
   attachToolEvents(allTurns, toolEvents);
-  attachToolResults(allTurns, toolResults, toolErrors, toolImages);
+  attachToolResults(allTurns, toolResults, toolErrors, toolImages, deps);
   const slug = sessionId.slice(0, 8);
   const firstUser = allTurns.find((t) => t.role === "user");
   const firstBlock = firstUser?.blocks[0];
@@ -7664,7 +7842,7 @@ function normalizeImagePlaceholderLines(text) {
 }
 function resolveImagePath(pathValue) {
   if (pathValue.startsWith("~/") || pathValue.startsWith("~\\")) {
-    return join13(homedir12(), pathValue.slice(2));
+    return join14(homedir12(), pathValue.slice(2));
   }
   return pathValue;
 }
@@ -7693,7 +7871,7 @@ function extractImageFilePathsFromText(text) {
 }
 async function readImageFileAsDataUrl(pathValue) {
   try {
-    const data = await readFile13(pathValue);
+    const data = await readFile14(pathValue);
     return `data:${imageMediaType(pathValue)};base64,${data.toString("base64")}`;
   } catch {
     return null;
@@ -7755,7 +7933,7 @@ function extractToolResultImages(block) {
     return `data:${mediaType};base64,${source.data}`;
   }).filter((value) => typeof value === "string");
 }
-function attachToolResults(turns, toolResults, toolErrors, toolImages) {
+function attachToolResults(turns, toolResults, toolErrors, toolImages, deps) {
   for (const turn of turns) {
     if (turn.role !== "assistant") continue;
     for (const block of turn.blocks) {
@@ -7763,7 +7941,7 @@ function attachToolResults(turns, toolResults, toolErrors, toolImages) {
       const result = toolResults.get(block.id);
       if (result !== void 0) {
         block._result = result.result;
-        block.input = mapToolArgs(block.name, block.input, result.result);
+        block.input = deps.mapToolArgs(block.name, block.input, result.result);
         const durationMs = durationBetween(turn.timestamp, result.timestamp);
         if (durationMs !== void 0) block._durationMs = durationMs;
       }
@@ -7830,7 +8008,7 @@ function mergeJsonlSupplementsIntoCursorTurns(primaryTurns, jsonlTurns) {
 async function sortByMtime(paths) {
   const entries = [];
   for (const path of paths) {
-    const st = await stat8(path).catch(() => null);
+    const st = await stat9(path).catch(() => null);
     if (!st?.isFile()) continue;
     entries.push({ path, mtimeMs: st.mtimeMs });
   }
@@ -7848,8 +8026,8 @@ async function inferToolPaths(transcriptPaths) {
     projects.get(projectRoot)?.add(transcriptPath);
   }
   for (const [projectRoot, selectedPaths] of projects.entries()) {
-    const transcriptsDir = join13(projectRoot, "agent-transcripts");
-    const toolDir = join13(projectRoot, "agent-tools");
+    const transcriptsDir = join14(projectRoot, "agent-transcripts");
+    const toolDir = join14(projectRoot, "agent-tools");
     const transcriptEntries = await collectTranscriptEntries2(transcriptsDir);
     const toolEntries = await collectToolEntries2(toolDir);
     if (transcriptEntries.length === 0 || toolEntries.length === 0) continue;
@@ -7878,16 +8056,16 @@ async function collectTranscriptEntries2(transcriptsDir) {
   }
   const transcripts = [];
   for (const entry of entries) {
-    const entryPath = join13(transcriptsDir, entry);
-    const st = await stat8(entryPath).catch(() => null);
+    const entryPath = join14(transcriptsDir, entry);
+    const st = await stat9(entryPath).catch(() => null);
     if (!st) continue;
     if (entry.endsWith(".jsonl") && st.isFile()) {
       transcripts.push({ path: entryPath, mtimeMs: st.mtimeMs });
       continue;
     }
     if (!st.isDirectory()) continue;
-    const nested = join13(entryPath, `${entry}.jsonl`);
-    const nestedStat = await stat8(nested).catch(() => null);
+    const nested = join14(entryPath, `${entry}.jsonl`);
+    const nestedStat = await stat9(nested).catch(() => null);
     if (!nestedStat?.isFile()) continue;
     transcripts.push({ path: nested, mtimeMs: nestedStat.mtimeMs });
   }
@@ -7903,8 +8081,8 @@ async function collectToolEntries2(toolDir) {
   const tools = [];
   for (const entry of entries) {
     if (!entry.endsWith(".txt")) continue;
-    const entryPath = join13(toolDir, entry);
-    const st = await stat8(entryPath).catch(() => null);
+    const entryPath = join14(toolDir, entry);
+    const st = await stat9(entryPath).catch(() => null);
     if (!st?.isFile()) continue;
     tools.push({ path: entryPath, mtimeMs: st.mtimeMs });
   }
@@ -7918,10 +8096,10 @@ function getCursorProjectRoot(transcriptPath) {
 async function loadToolEvents(toolPaths) {
   const events = [];
   for (const path of toolPaths) {
-    const content = await readFile13(path, "utf-8").catch(() => "");
+    const content = await readFile14(path, "utf-8").catch(() => "");
     const result = content.trim();
     if (!result) continue;
-    const st = await stat8(path).catch(() => null);
+    const st = await stat9(path).catch(() => null);
     const id = basename4(path, extname2(path));
     events.push({
       id,
@@ -8018,7 +8196,7 @@ function splitToolMarker(text) {
   return void 0;
 }
 
-// src/providers/cursor/index.ts
+// ../provider-cursor/src/cursor/index.ts
 var cursorProvider = {
   name: "cursor",
   displayName: "Cursor",
@@ -8026,27 +8204,27 @@ var cursorProvider = {
   parse: (filePaths, sessionInfo) => parseCursorSession(filePaths, sessionInfo)
 };
 
-// src/providers/pi/discover.ts
+// ../provider-pi/src/pi/discover.ts
 import { createReadStream as createReadStream4 } from "fs";
-import { readdir as readdir10, stat as stat9 } from "fs/promises";
-import { basename as basename5, join as join15 } from "path";
+import { readdir as readdir10, stat as stat10 } from "fs/promises";
+import { basename as basename5, join as join16 } from "path";
 import { createInterface as createInterface4 } from "readline";
 
-// src/providers/pi/config.ts
-import { readFile as readFile14 } from "fs/promises";
+// ../provider-pi/src/pi/config.ts
+import { readFile as readFile15 } from "fs/promises";
 import { homedir as homedir13 } from "os";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 function getPiAgentDir() {
-  return process.env.PI_CODING_AGENT_DIR || join14(homedir13(), ".pi", "agent");
+  return process.env.PI_CODING_AGENT_DIR || join15(homedir13(), ".pi", "agent");
 }
 function getPiSessionsDir() {
-  return process.env.PI_CODING_AGENT_SESSION_DIR || join14(getPiAgentDir(), "sessions");
+  return process.env.PI_CODING_AGENT_SESSION_DIR || join15(getPiAgentDir(), "sessions");
 }
 async function readPiModelContextWindows() {
   const result = /* @__PURE__ */ new Map();
   let raw;
   try {
-    raw = await readFile14(join14(getPiAgentDir(), "models.json"), "utf-8");
+    raw = await readFile15(join15(getPiAgentDir(), "models.json"), "utf-8");
   } catch {
     return result;
   }
@@ -8072,7 +8250,7 @@ function collectModelContextWindows(value, result) {
   for (const nested of Object.values(obj)) collectModelContextWindows(nested, result);
 }
 
-// src/providers/pi/discover.ts
+// ../provider-pi/src/pi/discover.ts
 var PROMPT_SCAN_LIMIT = 2;
 async function discoverPiSessions() {
   const sessionsRoot = getPiSessionsDir();
@@ -8084,8 +8262,8 @@ async function discoverPiSessions() {
     return sessions;
   }
   for (const projectDir of projectDirs) {
-    const projectPath = join15(sessionsRoot, projectDir);
-    const projectStat = await stat9(projectPath).catch(() => null);
+    const projectPath = join16(sessionsRoot, projectDir);
+    const projectStat = await stat10(projectPath).catch(() => null);
     if (!projectStat?.isDirectory()) continue;
     let files;
     try {
@@ -8095,8 +8273,8 @@ async function discoverPiSessions() {
     }
     for (const file of files) {
       if (!file.endsWith(".jsonl")) continue;
-      const filePath = join15(projectPath, file);
-      const fileStat = await stat9(filePath).catch(() => null);
+      const filePath = join16(projectPath, file);
+      const fileStat = await stat10(filePath).catch(() => null);
       if (!fileStat) continue;
       const info = await extractPiSessionInfo(filePath, fileStat.size, projectDir);
       if (info) sessions.push(info);
@@ -8154,7 +8332,7 @@ async function extractPiSessionInfo(filePath, fileSize, encodedProjectDir) {
         if (text) {
           promptCount++;
           if (prompts.length < PROMPT_SCAN_LIMIT) {
-            prompts.push(cleanPromptText(text).slice(0, 200));
+            prompts.push(cleanPromptText2(text).slice(0, 200));
           }
         }
       } else if (message.role === "assistant") {
@@ -8175,6 +8353,7 @@ async function extractPiSessionInfo(filePath, fileSize, encodedProjectDir) {
   }
   if (!header || prompts.length === 0) return null;
   const cwd = header.cwd || decodeProjectDir3(encodedProjectDir);
+  const gitRepo = await readGitRepo(cwd);
   const slug = basename5(filePath, ".jsonl").replace(/^\d{4}-\d{2}-\d{2}T[^_]+_/, "");
   const fallbackTimestamp = timestamp || header.timestamp || (/* @__PURE__ */ new Date()).toISOString();
   return {
@@ -8185,6 +8364,7 @@ async function extractPiSessionInfo(filePath, fileSize, encodedProjectDir) {
     project: cwd,
     cwd,
     version: String(header.version || 1),
+    gitRepo,
     timestamp: fallbackTimestamp,
     lineCount,
     fileSize,
@@ -8213,15 +8393,14 @@ function isEditTool2(name) {
   return name === "edit" || name === "write" || name === "Edit" || name === "Write";
 }
 
-// src/providers/pi/parser.ts
-init_utils();
-import { readFile as readFile15 } from "fs/promises";
+// ../provider-pi/src/pi/parser.ts
+import { readFile as readFile16 } from "fs/promises";
 import { basename as basename6 } from "path";
 async function parsePiSession(filePaths, sessionInfo) {
   const paths = Array.isArray(filePaths) ? filePaths : [filePaths];
   const allLines = [];
   for (const fp of paths) {
-    const content = await readFile15(fp, "utf-8");
+    const content = await readFile16(fp, "utf-8");
     allLines.push(...content.split("\n"));
   }
   return parsePiLines(allLines, {
@@ -8655,7 +8834,7 @@ function estimateActiveDuration2(timestamps) {
   return total || void 0;
 }
 
-// src/providers/pi/index.ts
+// ../provider-pi/src/pi/index.ts
 var piProvider = {
   name: "pi",
   displayName: "Pi",
@@ -8663,7 +8842,7 @@ var piProvider = {
   parse: parsePiSession
 };
 
-// src/providers/index.ts
+// ../providers-default/src/index.ts
 var providers = [
   claudeCoworkProvider,
   claudeDesktopProvider,
@@ -8709,8 +8888,8 @@ init_cloud();
 // src/publishers/gist.ts
 init_cloud();
 import { createHash as createHash3 } from "crypto";
-import { readFile as readFile18, writeFile as writeFile4 } from "fs/promises";
-import { join as join18 } from "path";
+import { readFile as readFile19, writeFile as writeFile4 } from "fs/promises";
+import { join as join19 } from "path";
 var GIST_META_FILE = ".vibe-replay-gist.json";
 function checkPublishStatus() {
   const auth = loadAuthToken();
@@ -8722,8 +8901,8 @@ async function publishGist(outputDir, title, opts) {
   if (!auth) {
     throw new Error("Not logged in. Run `vibe-replay auth login` first.");
   }
-  const jsonPath = join18(outputDir, "replay.json");
-  const content = await readFile18(jsonPath, "utf-8");
+  const jsonPath = join19(outputDir, "replay.json");
+  const content = await readFile19(jsonPath, "utf-8");
   const overwrite = opts?.overwrite;
   const filename = overwrite?.filename || `${sanitizeFilename(title)}.json`;
   const description = `vibe-replay: ${title}`;
@@ -8787,7 +8966,7 @@ async function publishGist(outputDir, title, opts) {
 }
 async function loadSavedGistInfo(outputDir) {
   try {
-    const raw = await readFile18(join18(outputDir, GIST_META_FILE), "utf-8");
+    const raw = await readFile19(join19(outputDir, GIST_META_FILE), "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed?.gistId || !parsed?.filename) return void 0;
     return parsed;
@@ -8796,7 +8975,7 @@ async function loadSavedGistInfo(outputDir) {
   }
 }
 async function saveGistInfo(outputDir, info) {
-  await writeFile4(join18(outputDir, GIST_META_FILE), JSON.stringify(info, null, 2), "utf-8");
+  await writeFile4(join19(outputDir, GIST_META_FILE), JSON.stringify(info, null, 2), "utf-8");
 }
 function sanitizeFilename(s) {
   return s.replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-").slice(0, 60);
@@ -8914,13 +9093,13 @@ import {
   mkdir as mkdir6,
   open as fsOpen,
   readdir as readdir12,
-  readFile as readFile22,
-  stat as stat11,
+  readFile as readFile24,
+  stat as stat12,
   unlink as unlink2,
   writeFile as writeFile7
 } from "fs/promises";
-import { homedir as homedir19 } from "os";
-import { join as join22, resolve as resolve3 } from "path";
+import { homedir as homedir20 } from "os";
+import { join as join24, resolve as resolve4 } from "path";
 import { promisify as promisify3 } from "util";
 import { serve } from "@hono/node-server";
 import chalk from "chalk";
@@ -9176,7 +9355,7 @@ async function executeFeedback(prompt, tool) {
   return runOpencode(prompt, tool.command);
 }
 function runClaude(prompt, cmd) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const proc = spawnTool(cmd, ["-p", "--output-format", "json"], {
       env: { ...process.env, NO_COLOR: "1" },
       timeout: 6e5,
@@ -9190,9 +9369,9 @@ function runClaude(prompt, cmd) {
       if (code === 0) {
         try {
           const parsed = JSON.parse(stdout);
-          resolve4(parsed.result || stdout);
+          resolve5(parsed.result || stdout);
         } catch {
-          resolve4(stdout);
+          resolve5(stdout);
         }
       } else {
         reject(new Error(`claude exited ${code}: ${stderr.slice(0, 500)}`));
@@ -9204,7 +9383,7 @@ function runClaude(prompt, cmd) {
   });
 }
 function runOpencode(prompt, cmd) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const proc = spawnTool(cmd, ["run"], {
       env: { ...process.env, NO_COLOR: "1", TERM: "dumb" },
       timeout: 6e5,
@@ -9216,7 +9395,7 @@ function runOpencode(prompt, cmd) {
     proc.stderr.on("data", (d) => stderr += d.toString());
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve4(stripAnsi(stdout));
+        resolve5(stripAnsi(stdout));
       } else {
         reject(new Error(`opencode exited ${code}: ${stripAnsi(stderr).slice(0, 500)}`));
       }
@@ -9227,7 +9406,7 @@ function runOpencode(prompt, cmd) {
   });
 }
 function runAgent(prompt, cmd) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const proc = spawnTool(cmd, ["-p", "--output-format", "json", "--mode", "ask", "--trust"], {
       env: { ...process.env, NO_COLOR: "1" },
       timeout: 6e5,
@@ -9241,9 +9420,9 @@ function runAgent(prompt, cmd) {
       if (code === 0) {
         try {
           const parsed = JSON.parse(stdout);
-          resolve4(typeof parsed.result === "string" ? parsed.result : stdout);
+          resolve5(typeof parsed.result === "string" ? parsed.result : stdout);
         } catch {
-          resolve4(stdout);
+          resolve5(stdout);
         }
       } else {
         reject(new Error(`agent exited ${code}: ${stderr.slice(0, 500)}`));
@@ -9839,18 +10018,18 @@ function stripAnsi(str) {
   return str.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "").replace(/\x1B\][^\x07]*\x07/g, "");
 }
 function locateCommand(cmd) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const locator = IS_WINDOWS ? "where" : "which";
     const proc = spawn(locator, [cmd], { timeout: 5e3 });
     let out = "";
     proc.stdout.on("data", (d) => out += d.toString());
     proc.on("close", (code) => {
       if (code !== 0) {
-        resolve4(null);
+        resolve5(null);
         return;
       }
       const first = out.split(/\r?\n/).find((line) => line.trim());
-      resolve4(first ? first.trim() : null);
+      resolve5(first ? first.trim() : null);
     });
     proc.on("error", reject);
   });
@@ -9862,13 +10041,13 @@ init_overlays();
 init_cloud();
 
 // src/server-persistence.ts
-import { mkdir as mkdir5, readFile as readFile20, writeFile as writeFile6 } from "fs/promises";
-import { join as join20, resolve as resolve2 } from "path";
+import { mkdir as mkdir5, readFile as readFile22, writeFile as writeFile6 } from "fs/promises";
+import { join as join22, resolve as resolve3 } from "path";
 async function loadAnnotations(baseDir, slug) {
-  const dirs = [join20(baseDir, slug), resolve2("./vibe-replay", slug)];
+  const dirs = [join22(baseDir, slug), resolve3("./vibe-replay", slug)];
   for (const dir of dirs) {
     try {
-      const raw = await readFile20(join20(dir, "annotations.json"), "utf-8");
+      const raw = await readFile22(join22(dir, "annotations.json"), "utf-8");
       const anns = JSON.parse(raw);
       if (Array.isArray(anns)) return anns;
     } catch {
@@ -9877,13 +10056,13 @@ async function loadAnnotations(baseDir, slug) {
   return [];
 }
 async function saveAnnotations(baseDir, slug, annotations) {
-  await mkdir5(join20(baseDir, slug), { recursive: true });
-  const annPath = join20(baseDir, slug, "annotations.json");
+  await mkdir5(join22(baseDir, slug), { recursive: true });
+  const annPath = join22(baseDir, slug, "annotations.json");
   await writeFile6(annPath, JSON.stringify(annotations, null, 2), "utf-8");
 }
 async function saveOverlays(baseDir, slug, overlays) {
-  await mkdir5(join20(baseDir, slug), { recursive: true });
-  const overlayPath = join20(baseDir, slug, "overlays.json");
+  await mkdir5(join22(baseDir, slug), { recursive: true });
+  const overlayPath = join22(baseDir, slug, "overlays.json");
   await writeFile6(overlayPath, JSON.stringify(overlays, null, 2), "utf-8");
 }
 
@@ -9891,7 +10070,7 @@ async function saveOverlays(baseDir, slug, overlays) {
 init_overlays();
 
 // src/server-core.ts
-import { homedir as homedir16 } from "os";
+import { homedir as homedir17 } from "os";
 import { basename as basename8 } from "path";
 function safeSlug(raw) {
   if (!raw) return null;
@@ -9910,7 +10089,7 @@ function getErrorMessage(err) {
   return "Unknown error";
 }
 function normalizeProjectPath(project) {
-  const home = homedir16();
+  const home = homedir17();
   return project.startsWith(home) ? `~${project.slice(home.length)}` : project;
 }
 var MAX_INSIGHTS_SYNC_DAYS_PER_REQUEST = 90;
@@ -10032,11 +10211,25 @@ function registerSessionAssetRoutes(app, deps) {
 }
 
 // src/scanner.ts
-import { readdir as readdir11, readFile as readFile21, stat as stat10 } from "fs/promises";
-import { homedir as homedir17 } from "os";
-import { join as join21 } from "path";
+import { readdir as readdir11, readFile as readFile23, stat as stat11 } from "fs/promises";
+import { homedir as homedir18 } from "os";
+import { join as join23 } from "path";
+
+// src/duration.ts
+var DEFAULT_MAX_GAP_MS2 = 5 * 60 * 1e3;
+function estimateActiveDuration3(timestamps, maxGapMs = DEFAULT_MAX_GAP_MS2) {
+  if (timestamps.length < 2) return void 0;
+  const sorted = timestamps.map((t) => Date.parse(t)).filter(Number.isFinite).sort((a, b) => a - b);
+  if (sorted.length < 2) return void 0;
+  let active = 0;
+  for (let i = 1; i < sorted.length; i++) {
+    const gap = sorted[i] - sorted[i - 1];
+    active += Math.min(gap, maxGapMs);
+  }
+  return active > 0 ? active : void 0;
+}
 
-// src/pricing.ts
+// ../replay-core/src/pricing.ts
 var MODEL_PRICING = {
   "gpt-5.5": {
     inputRate: 5,
@@ -10245,7 +10438,7 @@ async function scanSession(input) {
   for (const filePath of input.filePaths) {
     let content;
     try {
-      content = await readFile21(filePath, "utf-8");
+      content = await readFile23(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -10354,7 +10547,7 @@ async function scanSession(input) {
               const fp = extractToolFilePath(block.input);
               if (fp) {
                 editCount++;
-                const short = shortenPath(fp);
+                const short = shortenPath2(fp);
                 fileEditCounts.set(short, (fileEditCounts.get(short) || 0) + 1);
               }
             }
@@ -10367,7 +10560,7 @@ async function scanSession(input) {
   if (input.filePaths.length > 0) {
     const mainFile = input.filePaths[0];
     const sessionDir = mainFile.replace(/\.jsonl$/, "");
-    const subagentsDir = join21(sessionDir, "subagents");
+    const subagentsDir = join23(sessionDir, "subagents");
     try {
       const files = await readdir11(subagentsDir);
       const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
@@ -10375,7 +10568,7 @@ async function scanSession(input) {
       for (const saFile of jsonlFiles) {
         let saContent;
         try {
-          saContent = await readFile21(join21(subagentsDir, saFile), "utf-8");
+          saContent = await readFile23(join23(subagentsDir, saFile), "utf-8");
         } catch {
           continue;
         }
@@ -10395,7 +10588,7 @@ async function scanSession(input) {
               const fp = extractToolFilePath(block.input);
               if (fp) {
                 editCount++;
-                const short = shortenPath(fp);
+                const short = shortenPath2(fp);
                 fileEditCounts.set(short, (fileEditCounts.get(short) || 0) + 1);
               }
             }
@@ -10444,7 +10637,7 @@ async function scanSession(input) {
   }
   let durationMs = totalDurationMs || void 0;
   if (!durationMs) {
-    durationMs = estimateActiveDuration(allTimestamps);
+    durationMs = estimateActiveDuration3(allTimestamps);
   }
   const gitBranch = gitBranches.length > 0 ? gitBranches[gitBranches.length - 1] : void 0;
   return {
@@ -10604,7 +10797,7 @@ function buildScanResultFromParsed(input, parsed) {
           const saPath = extractToolFilePath(saScene.input);
           if (!saPath) continue;
           editCount++;
-          const short = shortenPath(saPath);
+          const short = shortenPath2(saPath);
           fileEditCounts.set(short, (fileEditCounts.get(short) || 0) + 1);
         }
       }
@@ -10613,7 +10806,7 @@ function buildScanResultFromParsed(input, parsed) {
       if (rawPaths.length === 0) continue;
       editCount++;
       for (const rawPath of rawPaths) {
-        const short = shortenPath(rawPath);
+        const short = shortenPath2(rawPath);
         fileEditCounts.set(short, (fileEditCounts.get(short) || 0) + 1);
       }
     }
@@ -10674,20 +10867,20 @@ function estimateParsedCost(parsed) {
 var SCAN_CACHE_KEY = "session-scans-v1";
 var SCAN_CONCURRENCY = 4;
 async function readScanCache() {
-  const cached = await readFileCache(SCAN_CACHE_KEY);
+  const cached = await readFileCache2(SCAN_CACHE_KEY);
   if (!cached) return null;
   if (cached.data.scannerVersion !== SCANNER_VERSION) return null;
   return cached.data;
 }
 async function writeScanCache(data) {
-  await writeFileCache(SCAN_CACHE_KEY, data);
+  await writeFileCache2(SCAN_CACHE_KEY, data);
 }
 async function getFileMeta(filePaths) {
   let totalSize = 0;
   let maxMtime = 0;
   for (const fp of filePaths) {
     try {
-      const s = await stat10(fp);
+      const s = await stat11(fp);
       totalSize += s.size;
       if (s.mtimeMs > maxMtime) maxMtime = s.mtimeMs;
     } catch {
@@ -11040,24 +11233,24 @@ function buildAggregateDataQuality(scans) {
   }
   return notes.length > 0 ? { notes } : void 0;
 }
-var CLAUDE_DIR2 = join21(homedir17(), ".claude", "projects");
+var CLAUDE_DIR2 = join23(homedir18(), ".claude", "projects");
 function encodeProjectDir(project) {
   let resolved = project;
   if (resolved.startsWith("~/")) {
-    resolved = join21(homedir17(), resolved.slice(2));
+    resolved = join23(homedir18(), resolved.slice(2));
   } else if (resolved === "~") {
-    resolved = homedir17();
+    resolved = homedir18();
   }
   return resolved.replace(/\//g, "-");
 }
 async function readProjectMemory(project) {
   const encoded = encodeProjectDir(project);
-  const projectDir = join21(CLAUDE_DIR2, encoded);
-  const memoryDir = join21(projectDir, "memory");
+  const projectDir = join23(CLAUDE_DIR2, encoded);
+  const memoryDir = join23(projectDir, "memory");
   const memoryFiles = [];
   let claudeMd;
   try {
-    const content = await readFile21(join21(projectDir, "CLAUDE.md"), "utf-8");
+    const content = await readFile23(join23(projectDir, "CLAUDE.md"), "utf-8");
     if (content.trim()) claudeMd = content.slice(0, 5e3);
   } catch {
   }
@@ -11066,7 +11259,7 @@ async function readProjectMemory(project) {
     for (const file of files) {
       if (!file.endsWith(".md") || file === "MEMORY.md") continue;
       try {
-        const content = await readFile21(join21(memoryDir, file), "utf-8");
+        const content = await readFile23(join23(memoryDir, file), "utf-8");
         const fm = parseFrontmatter(content);
         memoryFiles.push({
           name: fm.name || file.replace(/\.md$/, ""),
@@ -11106,18 +11299,18 @@ function extractMetaText(content) {
   return "";
 }
 
-// src/transform.ts
-import { homedir as homedir18 } from "os";
+// ../replay-core/src/transform.ts
+import { homedir as homedir19 } from "os";
 
-// src/utils/tokenEstimate.ts
+// ../replay-core/src/utils/tokenEstimate.ts
 function estimateTokens(s) {
   if (!s) return 0;
   if (!s.trim()) return 0;
   return Math.max(1, Math.round(s.length / 4));
 }
 
-// src/transform.ts
-var HOME = homedir18();
+// ../replay-core/src/transform.ts
+var HOME = homedir19();
 function redactPath(s) {
   if (!HOME) return s;
   return s.replaceAll(HOME, "~");
@@ -11270,6 +11463,8 @@ function transformToReplay(parsed, provider, project, options) {
       compactions: parsed.compactions,
       ...parsed.subAgentSummary && parsed.subAgentSummary.length > 0 ? { subAgentSummary: parsed.subAgentSummary } : syntheticSubAgentSummary.length > 0 ? { subAgentSummary: syntheticSubAgentSummary } : {},
       ...parsed.gitBranch ? { gitBranch: parsed.gitBranch } : {},
+      // Provider metadata wins over caller fallback when both are present.
+      ...parsed.gitRepo || options?.gitRepo ? { gitRepo: parsed.gitRepo || options?.gitRepo } : {},
       ...parsed.gitBranches ? { gitBranches: parsed.gitBranches } : {},
       ...parsed.entrypoint ? { entrypoint: parsed.entrypoint } : {},
       ...parsed.permissionMode ? { permissionMode: parsed.permissionMode } : {},
@@ -11556,23 +11751,30 @@ init_version();
 var ARCHIVE_DIR = ".archive";
 async function getArchivedSlugs(baseDir) {
   try {
-    const entries = await readdir12(join22(baseDir, ARCHIVE_DIR));
+    const entries = await readdir12(join24(baseDir, ARCHIVE_DIR));
     return new Set(entries);
   } catch {
     return /* @__PURE__ */ new Set();
   }
 }
 async function archiveSlug(baseDir, slug) {
-  const dir = join22(baseDir, ARCHIVE_DIR);
+  const dir = join24(baseDir, ARCHIVE_DIR);
   await mkdir6(dir, { recursive: true });
-  await writeFile7(join22(dir, slug), "");
+  await writeFile7(join24(dir, slug), "");
 }
 async function unarchiveSlug(baseDir, slug) {
   try {
-    await unlink2(join22(baseDir, ARCHIVE_DIR, slug));
+    await unlink2(join24(baseDir, ARCHIVE_DIR, slug));
   } catch {
   }
 }
+var replayGitRepoByProjectCache = /* @__PURE__ */ new Map();
+async function readReplayGitRepo(project) {
+  if (!replayGitRepoByProjectCache.has(project)) {
+    replayGitRepoByProjectCache.set(project, await readGitRepo(project));
+  }
+  return replayGitRepoByProjectCache.get(project);
+}
 async function scanSessionsFromDir(baseDir) {
   const results = [];
   let entries;
@@ -11582,22 +11784,26 @@ async function scanSessionsFromDir(baseDir) {
     return results;
   }
   for (const entry of entries) {
-    const replayPath = join22(baseDir, entry, "replay.json");
+    const replayPath = join24(baseDir, entry, "replay.json");
     try {
-      const raw = await readFile22(replayPath, "utf-8");
+      const raw = await readFile24(replayPath, "utf-8");
       const session = JSON.parse(raw);
       const annotationCount = (await loadAnnotations(baseDir, entry)).length;
       let gist;
       try {
-        gist = await loadSavedGistInfo(join22(baseDir, entry));
+        gist = await loadSavedGistInfo(join24(baseDir, entry));
       } catch {
       }
-      const cloudInfo = await loadSavedCloudInfo(join22(baseDir, entry));
+      const cloudInfo = await loadSavedCloudInfo(join24(baseDir, entry));
       const userPrompts = (session.scenes || []).filter((sc) => sc.type === "user-prompt").map((sc) => previewPrompt(sc.content)).filter((m) => m.length >= 10);
       const firstMessage = userPrompts[0] || void 0;
       const messages = userPrompts.length > 0 ? userPrompts.slice(0, 2) : void 0;
       const generatorVersion = session.meta.generator?.version;
       const replayOutdated = generatorVersion ? generatorVersion !== CLI_VERSION : false;
+      let gitRepo = session.meta.gitRepo;
+      if (!gitRepo && session.meta.project) {
+        gitRepo = await readReplayGitRepo(session.meta.project);
+      }
       results.push({
         slug: entry,
         baseDir,
@@ -11605,6 +11811,7 @@ async function scanSessionsFromDir(baseDir) {
         title: session.meta.title,
         provider: session.meta.provider,
         model: session.meta.model,
+        gitRepo,
         project: session.meta.project,
         startTime: session.meta.startTime,
         endTime: session.meta.endTime,
@@ -11620,7 +11827,7 @@ async function scanSessionsFromDir(baseDir) {
           let outdated = false;
           if (gist?.contentHash) {
             try {
-              const content = await readFile22(replayPath, "utf-8");
+              const content = await readFile24(replayPath, "utf-8");
               const currentHash = createHash5("sha256").update(content).digest("hex").slice(0, 16);
               outdated = currentHash !== gist?.contentHash;
             } catch {
@@ -11647,7 +11854,7 @@ async function scanSessionsFromDir(baseDir) {
 }
 async function scanSessions(baseDir) {
   const dirs = [baseDir];
-  const cwdLocal = resolve3("./vibe-replay");
+  const cwdLocal = resolve4("./vibe-replay");
   if (cwdLocal !== baseDir) {
     dirs.push(cwdLocal);
   }
@@ -11666,15 +11873,15 @@ async function scanSessions(baseDir) {
   return allResults;
 }
 async function loadSessionFromDisk(baseDir, slug) {
-  let replayPath = join22(baseDir, slug, "replay.json");
+  let replayPath = join24(baseDir, slug, "replay.json");
   try {
-    await stat11(replayPath);
+    await stat12(replayPath);
   } catch {
-    const fallback = resolve3("./vibe-replay", slug, "replay.json");
-    await stat11(fallback);
+    const fallback = resolve4("./vibe-replay", slug, "replay.json");
+    await stat12(fallback);
     replayPath = fallback;
   }
-  const raw = await readFile22(replayPath, "utf-8");
+  const raw = await readFile24(replayPath, "utf-8");
   const session = JSON.parse(raw);
   const annotations = await loadAnnotations(baseDir, slug);
   if (annotations.length > 0) {
@@ -11682,6 +11889,173 @@ async function loadSessionFromDisk(baseDir, slug) {
   }
   return session;
 }
+function isSourceSessionCatalogCache(value) {
+  return !!value && typeof value === "object" && value.schemaVersion === 1 && typeof value.discoveredAt === "string" && Array.isArray(value.sessions);
+}
+function normalizeSourceSessionCatalogCache(cached) {
+  if (!cached) return null;
+  if (Array.isArray(cached.data)) {
+    return {
+      sessions: cached.data,
+      cachedAt: cached.updatedAt,
+      discoveredAt: cached.updatedAt,
+      updatedAt: cached.updatedAt,
+      legacy: true
+    };
+  }
+  if (isSourceSessionCatalogCache(cached.data)) {
+    return {
+      sessions: cached.data.sessions,
+      cachedAt: cached.updatedAt,
+      discoveredAt: cached.data.discoveredAt || cached.updatedAt,
+      updatedAt: cached.data.updatedAt || cached.updatedAt,
+      providerStates: cached.data.providerStates,
+      legacy: false
+    };
+  }
+  return null;
+}
+function buildProviderDiscoveryStates(sources, discoveredAt) {
+  const byProvider = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    const bucket = byProvider.get(source.provider) || [];
+    bucket.push(source);
+    byProvider.set(source.provider, bucket);
+  }
+  const states = {};
+  for (const [provider, providerSources] of byProvider) {
+    states[provider] = {
+      provider,
+      discoveredAt,
+      sessionCount: providerSources.length
+    };
+  }
+  return states;
+}
+function buildSourceSessionCatalogCache(sessions, discoveredAt, previous) {
+  const providerStates = {
+    ...previous?.providerStates,
+    ...buildProviderDiscoveryStates(sessions, discoveredAt)
+  };
+  return {
+    schemaVersion: 1,
+    discoveredAt,
+    updatedAt: discoveredAt,
+    providerStates,
+    sessions
+  };
+}
+async function probeSourceRecordsFreshness(sources, provider) {
+  const probe = {
+    provider,
+    sessionsRoot: provider,
+    fileCount: 0
+  };
+  const paths = new Set(
+    sources.filter((source) => source.provider === provider).flatMap((source) => source.filePaths || []).filter(
+      (filePath) => typeof filePath === "string" && filePath.length > 0
+    )
+  );
+  for (const filePath of paths) {
+    const fileStat = await stat12(filePath).catch(() => null);
+    if (!fileStat) continue;
+    probe.fileCount += 1;
+    if (probe.newestSourceMtimeMs == null || fileStat.mtimeMs > probe.newestSourceMtimeMs) {
+      probe.newestSourceMtimeMs = fileStat.mtimeMs;
+      probe.newestSourcePath = filePath;
+    }
+  }
+  return probe;
+}
+function mergeSourceCatalogSessionUpdates(current, updates) {
+  if (current.length === 0) return updates;
+  const bySessionId = /* @__PURE__ */ new Map();
+  const byKey = /* @__PURE__ */ new Map();
+  for (const update of updates) {
+    byKey.set(sourceSessionKey(update.provider, update.project, update.slug), update);
+    if (typeof update.sessionId === "string" && update.sessionId) {
+      bySessionId.set(update.sessionId, update);
+    }
+  }
+  return current.map((session) => {
+    const byId = session.sessionId ? bySessionId.get(session.sessionId) : void 0;
+    const update = (byId?.provider === session.provider ? byId : void 0) ?? byKey.get(sourceSessionKey(session.provider, session.project, session.slug));
+    return update ? { ...session, ...update } : session;
+  });
+}
+function updateSourceSessionCatalogSessions(catalog, sessions, updatedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    schemaVersion: 1,
+    discoveredAt: catalog.discoveredAt || catalog.cachedAt || updatedAt,
+    updatedAt,
+    providerStates: catalog.providerStates,
+    sessions
+  };
+}
+async function walkJsonlFreshness(root, provider) {
+  const probe = {
+    provider,
+    sessionsRoot: root,
+    fileCount: 0
+  };
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await readdir12(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    await Promise.all(
+      entries.map(async (entry) => {
+        const entryPath = join24(dir, entry.name);
+        if (entry.isDirectory()) {
+          await walk(entryPath);
+          return;
+        }
+        if (!entry.isFile() || !entry.name.endsWith(".jsonl")) return;
+        const fileStat = await stat12(entryPath).catch(() => null);
+        if (!fileStat) return;
+        probe.fileCount += 1;
+        if (probe.newestSourceMtimeMs == null || fileStat.mtimeMs > probe.newestSourceMtimeMs) {
+          probe.newestSourceMtimeMs = fileStat.mtimeMs;
+          probe.newestSourcePath = entryPath;
+        }
+      })
+    );
+  }
+  await walk(root);
+  return probe;
+}
+async function probePiSourceFreshness() {
+  return walkJsonlFreshness(getPiSessionsDir(), "pi");
+}
+function sourceProviderFingerprint(probe) {
+  return `${probe.fileCount}:${probe.newestSourcePath || ""}`;
+}
+async function getStaleSourceProviders(catalog) {
+  if (!catalog) return [];
+  const staleProviders = [];
+  const piProbe = await probePiSourceFreshness();
+  const piFingerprint = sourceProviderFingerprint(piProbe);
+  const previousPiFingerprint = catalog.providerStates?.pi?.fingerprint;
+  const previousPiSessionCount = catalog.providerStates?.pi?.sessionCount;
+  const cachedPiSessionCount = catalog.sessions.filter(
+    (session) => session.provider === "pi"
+  ).length;
+  if (cachedPiSessionCount > 0 && typeof previousPiSessionCount === "number" && previousPiSessionCount !== cachedPiSessionCount) {
+    staleProviders.push("pi");
+  }
+  if (previousPiFingerprint) {
+    if (piFingerprint !== previousPiFingerprint) staleProviders.push("pi");
+    return [...new Set(staleProviders)];
+  }
+  const piDiscoveredAt = catalog.providerStates?.pi?.discoveredAt || catalog.discoveredAt || catalog.cachedAt;
+  const piDiscoveredMs = piDiscoveredAt ? Date.parse(piDiscoveredAt) : Number.NaN;
+  if (piProbe.fileCount > 0 && piProbe.newestSourceMtimeMs != null && (catalog.legacy || !Number.isFinite(piDiscoveredMs) || piProbe.newestSourceMtimeMs > piDiscoveredMs)) {
+    staleProviders.push("pi");
+  }
+  return [...new Set(staleProviders)];
+}
 function sourceSessionKey(provider, project, slug) {
   return `${provider}::${project}::${slug}`;
 }
@@ -11846,13 +12220,13 @@ async function buildSourcesResult(merged, baseDir, home, previousSources = [], c
   const projectExistsMap = /* @__PURE__ */ new Map();
   const projectIsGitMap = /* @__PURE__ */ new Map();
   for (const p of uniqueProjects) {
-    const resolved = p === "~" ? home : p.startsWith("~/") || p.startsWith("~\\") ? join22(home, p.slice(2)) : p;
+    const resolved = p === "~" ? home : p.startsWith("~/") || p.startsWith("~\\") ? join24(home, p.slice(2)) : p;
     try {
-      const s = await stat11(resolved);
+      const s = await stat12(resolved);
       projectExistsMap.set(p, s.isDirectory());
       if (s.isDirectory()) {
         try {
-          await stat11(join22(resolved, ".git"));
+          await stat12(join24(resolved, ".git"));
           projectIsGitMap.set(p, true);
         } catch {
           projectIsGitMap.set(p, false);
@@ -11896,6 +12270,7 @@ async function buildSourcesResult(merged, baseDir, home, previousSources = [], c
       hasSqlite: s.hasSqlite,
       hasSdk: s.hasSdk,
       gitBranch: s.gitBranch,
+      gitRepo: s.gitRepo,
       model: s.model,
       durationMsEst: s.durationMsEst,
       editCountEst: s.editCountEst,
@@ -11916,6 +12291,7 @@ async function buildSourcesResult(merged, baseDir, home, previousSources = [], c
         title: replay.title,
         provider: replay.provider,
         model: replay.model,
+        gitRepo: replay.gitRepo,
         project: replay.project,
         startTime: replay.startTime,
         endTime: replay.endTime,
@@ -11932,7 +12308,7 @@ async function buildSourcesResult(merged, baseDir, home, previousSources = [], c
   });
 }
 async function readClaudeSessionState(sessionId) {
-  const sessionsDir = join22(homedir19(), ".claude", "sessions");
+  const sessionsDir = join24(homedir20(), ".claude", "sessions");
   let files;
   try {
     files = await readdir12(sessionsDir);
@@ -11943,7 +12319,7 @@ async function readClaudeSessionState(sessionId) {
     if (!file.endsWith(".json")) continue;
     let data;
     try {
-      const content = await readFile22(join22(sessionsDir, file), "utf-8");
+      const content = await readFile24(join24(sessionsDir, file), "utf-8");
       data = JSON.parse(content);
     } catch {
       continue;
@@ -12002,10 +12378,48 @@ async function startServer(baseDir, opts) {
   const replaysCacheKey = `dashboard-replays-v1-${cacheKeySuffix}`;
   const scanResultsCacheKey = `dashboard-scan-results-v1-${cacheKeySuffix}`;
   const insightsCacheKey = `dashboard-insights-v1-${cacheKeySuffix}`;
+  const readSourcesCatalogCache = async () => normalizeSourceSessionCatalogCache(
+    await readFileCache2(sourcesCacheKey)
+  );
+  const writeDiscoveredSourcesCatalog = async (sessions, previous) => {
+    const discoveredAt = (/* @__PURE__ */ new Date()).toISOString();
+    const catalog = buildSourceSessionCatalogCache(sessions, discoveredAt, previous);
+    try {
+      const piProbe = await probeSourceRecordsFreshness(sessions, "pi");
+      const piSessionCount = sessions.filter((session) => session.provider === "pi").length;
+      catalog.providerStates = {
+        ...catalog.providerStates,
+        pi: {
+          ...catalog.providerStates?.pi || {
+            provider: "pi",
+            discoveredAt
+          },
+          provider: "pi",
+          discoveredAt,
+          sessionCount: piSessionCount,
+          newestSourceMtimeMs: piProbe.newestSourceMtimeMs,
+          newestSourcePath: piProbe.newestSourcePath,
+          fingerprint: sourceProviderFingerprint(piProbe)
+        }
+      };
+    } catch {
+    }
+    await writeFileCache2(sourcesCacheKey, catalog);
+    return catalog;
+  };
+  const writeUpdatedSourcesCatalog = async (previous, sessions) => {
+    await writeFileCache2(
+      sourcesCacheKey,
+      updateSourceSessionCatalogSessions(
+        previous,
+        mergeSourceCatalogSessionUpdates(previous.sessions, sessions)
+      )
+    );
+  };
   const refreshReplaysCache = async () => {
     try {
       const sessions = await scanSessions(baseDir);
-      await writeFileCache(replaysCacheKey, sessions);
+      await writeFileCache2(replaysCacheKey, sessions);
       return sessions;
     } catch {
       return null;
@@ -12013,11 +12427,11 @@ async function startServer(baseDir, opts) {
   };
   const syncSourcesCacheWithReplays = async (replays) => {
     try {
-      const cached = await readFileCache(sourcesCacheKey);
-      if (!cached?.data?.length) return;
+      const cached = await readSourcesCatalogCache();
+      if (!cached?.sessions.length) return;
       const { bySlug, bySessionId } = buildReplayMaps(replays);
       let changed = false;
-      const updated = cached.data.map((s) => {
+      const updated = cached.sessions.map((s) => {
         const replay = bySlug.get(s.slug) || (s.sessionId ? bySessionId.get(s.sessionId) : void 0);
         const hadReplay = !!s.existingReplay;
         const hasReplay = !!replay;
@@ -12048,7 +12462,7 @@ async function startServer(baseDir, opts) {
         };
       });
       if (changed) {
-        await writeFileCache(sourcesCacheKey, updated);
+        await writeUpdatedSourcesCatalog(cached, updated);
       }
     } catch {
     }
@@ -12155,12 +12569,28 @@ async function startServer(baseDir, opts) {
             processed: sourcesEnrichmentStatus.processed + 1
           };
           if (changed && sourcesEnrichmentStatus.processed % 5 === 0) {
-            await writeFileCache(sourcesCacheKey, enrichedSources);
+            const cached = await readSourcesCatalogCache();
+            await writeUpdatedSourcesCatalog(
+              cached || {
+                sessions: baseSources,
+                discoveredAt: sourcesEnrichmentStatus.startedAt,
+                cachedAt: sourcesEnrichmentStatus.startedAt
+              },
+              enrichedSources
+            );
           }
         }
       }
       if (changed) {
-        await writeFileCache(sourcesCacheKey, enrichedSources);
+        const cached = await readSourcesCatalogCache();
+        await writeUpdatedSourcesCatalog(
+          cached || {
+            sessions: baseSources,
+            discoveredAt: sourcesEnrichmentStatus.startedAt,
+            cachedAt: sourcesEnrichmentStatus.startedAt
+          },
+          enrichedSources
+        );
       }
       sourcesEnrichmentStatus = {
         ...sourcesEnrichmentStatus,
@@ -12186,8 +12616,8 @@ async function startServer(baseDir, opts) {
       }
     });
   };
-  const persistedScanResults = await readFileCache(scanResultsCacheKey);
-  const persistedInsights = await readFileCache(insightsCacheKey);
+  const persistedScanResults = await readFileCache2(scanResultsCacheKey);
+  const persistedInsights = await readFileCache2(insightsCacheKey);
   let scanState = {
     running: false,
     scanned: persistedScanResults?.data.length || 0,
@@ -12309,7 +12739,7 @@ async function startServer(baseDir, opts) {
       projectInsights: projects,
       computedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    await writeFileCache(insightsCacheKey, {
+    await writeFileCache2(insightsCacheKey, {
       userInsights: insightsCache.userInsights,
       projectInsights: [...insightsCache.projectInsights.entries()],
       computedAt: insightsCache.computedAt
@@ -12337,7 +12767,7 @@ async function startServer(baseDir, opts) {
           allSessions.push(...sessions);
         }
         const merged = mergeSameSessions(allSessions);
-        const home = homedir19();
+        const home = homedir20();
         for (const s of merged) {
           if (s.project.startsWith(home)) {
             s.project = `~${s.project.slice(home.length)}`;
@@ -12385,7 +12815,7 @@ async function startServer(baseDir, opts) {
           startedAt: scanState.startedAt,
           finishedAt: (/* @__PURE__ */ new Date()).toISOString()
         };
-        await writeFileCache(scanResultsCacheKey, results);
+        await writeFileCache2(scanResultsCacheKey, results);
         persistInsightsFromScan(results).then(() => autoSyncInsights()).catch(() => {
         });
         precomputeInsightsCache(results).catch(() => {
@@ -12451,7 +12881,7 @@ async function startServer(baseDir, opts) {
         await sendError(`Session not found: ${sessionId}`);
         return;
       }
-      const home = homedir19();
+      const home = homedir20();
       const projectFor = (info) => info.project.startsWith(home) ? `~${info.project.slice(home.length)}` : info.project;
       const watchers = [];
       const watchedPaths = /* @__PURE__ */ new Set();
@@ -12519,13 +12949,13 @@ async function startServer(baseDir, opts) {
         const cached = jsonlTail.get(filePath);
         let size;
         try {
-          size = (await stat11(filePath)).size;
+          size = (await stat12(filePath)).size;
         } catch {
           jsonlTail.delete(filePath);
           return cached?.lines ?? [];
         }
         if (!cached || size < cached.offset) {
-          const content = await readFile22(filePath);
+          const content = await readFile24(filePath);
           const { lines, partial } = splitDecodedLines(content);
           jsonlTail.set(filePath, { offset: content.length, partial, lines });
           return lines;
@@ -12592,7 +13022,8 @@ async function startServer(baseDir, opts) {
               name: "vibe-replay",
               version: CLI_VERSION,
               generatedAt: (/* @__PURE__ */ new Date()).toISOString()
-            }
+            },
+            gitRepo: info.gitRepo
           });
           if (isClaudeProvider) {
             lastLiveState = await readClaudeSessionState(sessionId);
@@ -12671,7 +13102,7 @@ async function startServer(baseDir, opts) {
         if (aborted) return;
         scheduleRebuild(0);
       }, RESOLVE_REFRESH_INTERVAL_MS);
-      await new Promise((resolve4) => {
+      await new Promise((resolve5) => {
         stream.onAbort(() => {
           aborted = true;
           if (pendingTimer) clearTimeout(pendingTimer);
@@ -12685,24 +13116,28 @@ async function startServer(baseDir, opts) {
             } catch {
             }
           }
-          resolve4();
+          resolve5();
         });
       });
     });
   });
-  app.get("/api/sessions/cached", async (c) => {
-    const cached = await readFileCache(replaysCacheKey);
+  const getCachedReplays = async (c) => {
+    const cached = await readFileCache2(replaysCacheKey);
     return c.json({
       sessions: cached?.data || [],
       cachedAt: cached?.updatedAt
     });
-  });
-  app.get("/api/sessions", async (c) => {
+  };
+  app.get("/api/sessions/cached", getCachedReplays);
+  app.get("/api/replays/cached", getCachedReplays);
+  const getReplays = async (c) => {
     const sessions = await scanSessions(baseDir);
-    await writeFileCache(replaysCacheKey, sessions);
+    await writeFileCache2(replaysCacheKey, sessions);
     return c.json(sessions);
-  });
-  app.patch("/api/sessions/:slug", async (c) => {
+  };
+  app.get("/api/sessions", getReplays);
+  app.get("/api/replays", getReplays);
+  const patchReplay = async (c) => {
     const slug = safeSlug(c.req.param("slug"));
     if (!slug) return c.json({ error: "invalid slug" }, 400);
     let body;
@@ -12717,8 +13152,8 @@ async function startServer(baseDir, opts) {
     try {
       const target = await loadSessionFromDisk(baseDir, slug);
       target.meta.title = normalizeTitle(body.title);
-      const targetDir = join22(baseDir, slug);
-      await writeFile7(join22(targetDir, "replay.json"), JSON.stringify(target), "utf-8");
+      const targetDir = join24(baseDir, slug);
+      await writeFile7(join24(targetDir, "replay.json"), JSON.stringify(target), "utf-8");
       await generateOutput(target, targetDir);
       const updatedReplays = await refreshReplaysCache();
       if (updatedReplays) await syncSourcesCacheWithReplays(updatedReplays);
@@ -12726,20 +13161,24 @@ async function startServer(baseDir, opts) {
     } catch (err) {
       return c.json({ error: getErrorMessage(err) }, 500);
     }
-  });
-  app.delete("/api/sessions/:slug", async (c) => {
+  };
+  app.patch("/api/sessions/:slug", patchReplay);
+  app.patch("/api/replays/:slug", patchReplay);
+  const deleteReplay = async (c) => {
     const slug = safeSlug(c.req.param("slug"));
     if (!slug) return c.json({ error: "invalid slug" }, 400);
     try {
       const { rm } = await import("fs/promises");
-      await rm(join22(baseDir, slug), { recursive: true });
+      await rm(join24(baseDir, slug), { recursive: true });
       const updatedReplays = await refreshReplaysCache();
       if (updatedReplays) await syncSourcesCacheWithReplays(updatedReplays);
       return c.json({ ok: true });
     } catch (err) {
       return c.json({ error: getErrorMessage(err) }, 500);
     }
-  });
+  };
+  app.delete("/api/sessions/:slug", deleteReplay);
+  app.delete("/api/replays/:slug", deleteReplay);
   app.get("/api/archived", async (c) => {
     const slugs = await getArchivedSlugs(baseDir);
     return c.json({ slugs: [...slugs] });
@@ -12756,25 +13195,33 @@ async function startServer(baseDir, opts) {
     await unarchiveSlug(baseDir, slug);
     return c.json({ ok: true });
   });
-  app.get("/api/sources/cached", async (c) => {
-    const cached = await readFileCache(sourcesCacheKey);
+  const getCachedSourceSessions = async (c) => {
+    const cached = await readSourcesCatalogCache();
+    const staleProviders = await getStaleSourceProviders(cached);
     return c.json({
-      sessions: cached?.data || [],
-      cachedAt: cached?.updatedAt
+      sessions: cached?.sessions || [],
+      cachedAt: cached?.cachedAt,
+      discoveredAt: cached?.discoveredAt,
+      stale: staleProviders.length > 0,
+      staleProviders
     });
-  });
-  app.get("/api/sources/enrichment-status", async (c) => {
+  };
+  app.get("/api/sources/cached", getCachedSourceSessions);
+  app.get("/api/source-sessions/cached", getCachedSourceSessions);
+  const getSourceSessionsEnrichmentStatus = async (c) => {
     return c.json(sourcesEnrichmentStatus);
-  });
-  app.post("/api/sources/enrich", async (c) => {
+  };
+  app.get("/api/sources/enrichment-status", getSourceSessionsEnrichmentStatus);
+  app.get("/api/source-sessions/enrichment-status", getSourceSessionsEnrichmentStatus);
+  const postSourceSessionsEnrich = async (c) => {
     const hints = enrichmentHintsFromBody(await c.req.json().catch(() => void 0));
-    const cached = await readFileCache(sourcesCacheKey);
-    if (!cached?.data?.length) {
+    const cached = await readSourcesCatalogCache();
+    if (!cached?.sessions.length) {
       return c.json({ ok: false, message: "No sources cache available" }, 404);
     }
     const cursorProvider2 = getProvider("cursor");
     if (!cursorProvider2) return c.json({ ok: false, message: "Cursor provider unavailable" }, 404);
-    const home = homedir19();
+    const home = homedir20();
     let cursorSessions = lastDiscoveredMergedSessions.filter(
       (session) => session.provider === "cursor"
     );
@@ -12789,14 +13236,16 @@ async function startServer(baseDir, opts) {
       ];
     }
     const wasRunning = sourcesEnrichmentStatus.running;
-    enrichCursorStatsInBackground(cursorSessions, cached.data, hints);
+    enrichCursorStatsInBackground(cursorSessions, cached.sessions, hints);
     return c.json({
       ok: true,
       running: sourcesEnrichmentStatus.running,
       queued: wasRunning
     });
-  });
-  app.get("/api/sources", async (c) => {
+  };
+  app.post("/api/sources/enrich", postSourceSessionsEnrich);
+  app.post("/api/source-sessions/enrich", postSourceSessionsEnrich);
+  const getSourceSessions = async (c) => {
     try {
       const providers2 = getAllProviders();
       const allSessions = [];
@@ -12805,23 +13254,31 @@ async function startServer(baseDir, opts) {
         allSessions.push(...sessions);
       }
       const merged = mergeSameSessions(allSessions);
-      lastDiscoveredMergedSessions = normalizeSessionProjectsForHome(merged, homedir19());
-      const previous = await readFileCache(sourcesCacheKey);
+      lastDiscoveredMergedSessions = normalizeSessionProjectsForHome(merged, homedir20());
+      const previous = await readSourcesCatalogCache();
       const result = await buildSourcesResult(
         merged,
         baseDir,
-        homedir19(),
-        previous?.data || [],
+        homedir20(),
+        previous?.sessions || [],
         cleanupPeriodDays
       );
-      await writeFileCache(sourcesCacheKey, result);
+      const catalog = await writeDiscoveredSourcesCatalog(result, previous);
       enrichCursorStatsInBackground(merged, result);
-      return c.json({ sessions: result, cleanupPeriodDays });
+      return c.json({
+        sessions: result,
+        cleanupPeriodDays,
+        discoveredAt: catalog.discoveredAt,
+        stale: false,
+        staleProviders: []
+      });
     } catch (err) {
       return c.json({ error: getErrorMessage(err) }, 500);
     }
-  });
-  app.get("/api/sources/stream", (c) => {
+  };
+  app.get("/api/sources", getSourceSessions);
+  app.get("/api/source-sessions", getSourceSessions);
+  const streamSourceSessions = (c) => {
     return streamSSE(c, async (stream) => {
       try {
         const providers2 = getAllProviders();
@@ -12840,19 +13297,26 @@ async function startServer(baseDir, opts) {
           }
         }
         const merged = mergeSameSessions(allSessions);
-        lastDiscoveredMergedSessions = normalizeSessionProjectsForHome(merged, homedir19());
-        const previous = await readFileCache(sourcesCacheKey);
+        lastDiscoveredMergedSessions = normalizeSessionProjectsForHome(merged, homedir20());
+        const previous = await readSourcesCatalogCache();
         const result = await buildSourcesResult(
           merged,
           baseDir,
-          homedir19(),
-          previous?.data || [],
+          homedir20(),
+          previous?.sessions || [],
           cleanupPeriodDays
         );
-        await writeFileCache(sourcesCacheKey, result);
+        const catalog = await writeDiscoveredSourcesCatalog(result, previous);
         enrichCursorStatsInBackground(merged, result);
         await stream.writeSSE({
-          data: JSON.stringify({ type: "complete", sessions: result, cleanupPeriodDays })
+          data: JSON.stringify({
+            type: "complete",
+            sessions: result,
+            cleanupPeriodDays,
+            discoveredAt: catalog.discoveredAt,
+            stale: false,
+            staleProviders: []
+          })
         });
       } catch (err) {
         await stream.writeSSE({
@@ -12860,7 +13324,9 @@ async function startServer(baseDir, opts) {
         });
       }
     });
-  });
+  };
+  app.get("/api/sources/stream", streamSourceSessions);
+  app.get("/api/source-sessions/stream", streamSourceSessions);
   app.post("/api/generate", async (c) => {
     try {
       const body = await c.req.json();
@@ -12880,15 +13346,17 @@ async function startServer(baseDir, opts) {
         return c.json({ error: "title must be a string" }, 400);
       }
       const parsed = await provider.parse(resolved.value.paths, resolved.value.sessionInfo);
-      const home = homedir19();
+      const home = homedir20();
       const rawProject = body.sessionProject || parsed.cwd;
       const project = rawProject.startsWith(home) ? `~${rawProject.slice(home.length)}` : rawProject;
+      const gitRepo = resolved.value.sessionInfo?.gitRepo || await readGitRepo(rawProject);
       const replay = transformToReplay(parsed, body.provider, project, {
         generator: {
           name: "vibe-replay",
           version: CLI_VERSION,
           generatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        }
+        },
+        gitRepo
       });
       if (typeof body.title === "string") {
         const normalizedCustomTitle = normalizeTitle(body.title);
@@ -12898,7 +13366,7 @@ async function startServer(baseDir, opts) {
       }
       const rawSlug = replay.meta.slug || replay.meta.sessionId.slice(0, 8);
       const slug = rawSlug.replace(/[^a-zA-Z0-9_-]/g, "-");
-      const outputDir = join22(baseDir, slug);
+      const outputDir = join24(baseDir, slug);
       await generateOutput(replay, outputDir);
       const updatedReplays = await refreshReplaysCache();
       if (updatedReplays) await syncSourcesCacheWithReplays(updatedReplays);
@@ -12941,7 +13409,7 @@ async function startServer(baseDir, opts) {
     for (const slug of entries) {
       if (slug.startsWith(".") || slug === "cache") continue;
       try {
-        const replayPath = join22(replaysDir, slug, "replay.json");
+        const replayPath = join24(replaysDir, slug, "replay.json");
         const raw = await readF(replayPath, "utf-8").catch(() => null);
         if (!raw) continue;
         const oldReplay = JSON.parse(raw);
@@ -12963,17 +13431,18 @@ async function startServer(baseDir, opts) {
         }
         const paths = [...sessionInfo.filePaths, ...sessionInfo.toolPaths || []];
         const parsed = await provider.parse(paths, sessionInfo);
-        const home = homedir19();
+        const home = homedir20();
         const project = sessionInfo.project.startsWith(home) ? `~${sessionInfo.project.slice(home.length)}` : sessionInfo.project;
         const replay = transformToReplay(parsed, providerName, project, {
           generator: {
             name: "vibe-replay",
             version: CLI_VERSION,
             generatedAt: (/* @__PURE__ */ new Date()).toISOString()
-          }
+          },
+          gitRepo: sessionInfo.gitRepo
         });
         if (oldReplay.meta?.title) replay.meta.title = oldReplay.meta.title;
-        const outputDir = join22(replaysDir, slug);
+        const outputDir = join24(replaysDir, slug);
         await generateOutput(replay, outputDir);
         results.push({ slug, status: "regenerated", scenes: replay.scenes.length });
       } catch (err) {
@@ -13014,7 +13483,8 @@ async function startServer(baseDir, opts) {
       results: scanState.results,
       running: scanState.running,
       scanned: scanState.scanned,
-      total: scanState.total
+      total: scanState.total,
+      finishedAt: scanState.finishedAt
     });
   });
   app.get("/api/insights", async (c) => {
@@ -13459,7 +13929,7 @@ async function startServer(baseDir, opts) {
   app.get("/api/gist-info", async (c) => {
     const result = requireSlug(c.req.query("slug"));
     if ("error" in result) return c.json({ error: result.error }, 400);
-    const targetDir = join22(baseDir, result.slug);
+    const targetDir = join24(baseDir, result.slug);
     const gist = await loadSavedGistInfo(targetDir);
     if (!gist) return c.json({ gist: null });
     return c.json({ gist });
@@ -13467,7 +13937,7 @@ async function startServer(baseDir, opts) {
   app.delete("/api/gist-info", async (c) => {
     const result = requireSlug(c.req.query("slug"));
     if ("error" in result) return c.json({ error: result.error }, 400);
-    const metaPath = join22(baseDir, result.slug, ".vibe-replay-gist.json");
+    const metaPath = join24(baseDir, result.slug, ".vibe-replay-gist.json");
     await unlink2(metaPath).catch(() => {
     });
     return c.json({ ok: true });
@@ -13475,7 +13945,7 @@ async function startServer(baseDir, opts) {
   app.get("/api/cloud-info", async (c) => {
     const result = requireSlug(c.req.query("slug"));
     if ("error" in result) return c.json({ error: result.error }, 400);
-    const targetDir = join22(baseDir, result.slug);
+    const targetDir = join24(baseDir, result.slug);
     const cloud = await loadSavedCloudInfo(targetDir);
     if (!cloud) return c.json({ cloud: null });
     return c.json({ cloud });
@@ -13483,10 +13953,10 @@ async function startServer(baseDir, opts) {
   app.post("/api/cloud-info", async (c) => {
     const result = requireSlug(c.req.query("slug"));
     if ("error" in result) return c.json({ error: result.error }, 400);
-    const targetDir = join22(baseDir, result.slug);
+    const targetDir = join24(baseDir, result.slug);
     const body = await c.req.json();
     if (!body.id || !body.url) return c.json({ error: "Missing id/url" }, 400);
-    const metaPath = join22(targetDir, ".vibe-replay-cloud.json");
+    const metaPath = join24(targetDir, ".vibe-replay-cloud.json");
     await writeFile7(
       metaPath,
       JSON.stringify(
@@ -13506,7 +13976,7 @@ async function startServer(baseDir, opts) {
   app.delete("/api/cloud-info", async (c) => {
     const result = requireSlug(c.req.query("slug"));
     if ("error" in result) return c.json({ error: result.error }, 400);
-    const metaPath = join22(baseDir, result.slug, ".vibe-replay-cloud.json");
+    const metaPath = join24(baseDir, result.slug, ".vibe-replay-cloud.json");
     await unlink2(metaPath).catch(() => {
     });
     return c.json({ ok: true });
@@ -13514,13 +13984,13 @@ async function startServer(baseDir, opts) {
   app.post("/api/publish/gist", async (c) => {
     const result = requireSlug(c.req.query("slug"));
     if ("error" in result) return c.json({ error: result.error }, 400);
-    const targetDir = join22(baseDir, result.slug);
+    const targetDir = join24(baseDir, result.slug);
     try {
       const rawSession = await loadSessionFromDisk(baseDir, result.slug);
       const overlaysData = await loadOverlays(baseDir, result.slug);
       const targetSession = sessionWithEffectiveContent(rawSession, overlaysData);
-      const replayPath = join22(targetDir, "replay.json");
-      const originalContent = await readFile22(replayPath, "utf-8");
+      const replayPath = join24(targetDir, "replay.json");
+      const originalContent = await readFile24(replayPath, "utf-8");
       await writeFile7(replayPath, JSON.stringify(targetSession), "utf-8");
       try {
         const title = targetSession.meta.title || targetSession.meta.slug;
@@ -13539,7 +14009,7 @@ async function startServer(baseDir, opts) {
   app.post("/api/publish/cloud", async (c) => {
     const result = requireSlug(c.req.query("slug"));
     if ("error" in result) return c.json({ error: result.error }, 400);
-    const targetDir = join22(baseDir, result.slug);
+    const targetDir = join24(baseDir, result.slug);
     try {
       const body = await c.req.json().catch(() => ({}));
       const cloudResult = await publishCloudWithOverlays(targetDir, {
@@ -13553,13 +14023,13 @@ async function startServer(baseDir, opts) {
   app.post("/api/export/html", async (c) => {
     const result = requireSlug(c.req.query("slug"));
     if ("error" in result) return c.json({ error: result.error }, 400);
-    const targetDir = join22(baseDir, result.slug);
+    const targetDir = join24(baseDir, result.slug);
     try {
       const rawSession = await loadSessionFromDisk(baseDir, result.slug);
       const overlaysData = await loadOverlays(baseDir, result.slug);
       const targetSession = sessionWithEffectiveContent(rawSession, overlaysData);
-      const replayPath = join22(targetDir, "replay.json");
-      const originalContent = await readFile22(replayPath, "utf-8");
+      const replayPath = join24(targetDir, "replay.json");
+      const originalContent = await readFile24(replayPath, "utf-8");
       try {
         const outputPath = await generateOutput(targetSession, targetDir);
         return c.json({ path: outputPath });
@@ -13573,23 +14043,23 @@ async function startServer(baseDir, opts) {
   app.get("/api/export/github/status", async (c) => {
     const result = requireSlug(c.req.query("slug"));
     if ("error" in result) return c.json({ error: result.error }, 400);
-    const targetDir = join22(baseDir, result.slug);
+    const targetDir = join24(baseDir, result.slug);
     try {
-      const svgPath = join22(targetDir, "session-preview.svg");
-      const mdPath = join22(targetDir, "github-summary.md");
-      const gifPath = join22(targetDir, "session-preview.gif");
+      const svgPath = join24(targetDir, "session-preview.svg");
+      const mdPath = join24(targetDir, "github-summary.md");
+      const gifPath = join24(targetDir, "session-preview.gif");
       const [svgContent, markdown, gifBuf] = await Promise.all([
-        readFile22(svgPath, "utf-8").catch(() => null),
-        readFile22(mdPath, "utf-8").catch(() => null),
-        readFile22(gifPath).catch(() => null)
+        readFile24(svgPath, "utf-8").catch(() => null),
+        readFile24(mdPath, "utf-8").catch(() => null),
+        readFile24(gifPath).catch(() => null)
       ]);
       if (!svgContent && !markdown && !gifBuf) return c.json({ exists: false });
       const gist = await loadSavedGistInfo(targetDir);
       const gifContent = gifBuf ? gifBuf.toString("base64") : null;
       const [gifMtime, svgMtime, mdMtime] = await Promise.all([
-        stat11(gifPath).then((s) => s.mtime.toISOString()).catch(() => null),
-        stat11(svgPath).then((s) => s.mtime.toISOString()).catch(() => null),
-        stat11(mdPath).then((s) => s.mtime.toISOString()).catch(() => null)
+        stat12(gifPath).then((s) => s.mtime.toISOString()).catch(() => null),
+        stat12(svgPath).then((s) => s.mtime.toISOString()).catch(() => null),
+        stat12(mdPath).then((s) => s.mtime.toISOString()).catch(() => null)
       ]);
       return c.json({
         exists: true,
@@ -13611,7 +14081,7 @@ async function startServer(baseDir, opts) {
   app.post("/api/export/github", async (c) => {
     const result = requireSlug(c.req.query("slug"));
     if ("error" in result) return c.json({ error: result.error }, 400);
-    const targetDir = join22(baseDir, result.slug);
+    const targetDir = join24(baseDir, result.slug);
     try {
       const rawSession = await loadSessionFromDisk(baseDir, result.slug);
       const overlaysData = await loadOverlays(baseDir, result.slug);
@@ -13619,14 +14089,14 @@ async function startServer(baseDir, opts) {
       const gist = await loadSavedGistInfo(targetDir);
       const replayUrl = gist?.viewerUrl || void 0;
       const svgContent = generateGitHubSvg(targetSession, { replayUrl });
-      const svgFilePath = join22(targetDir, "session-preview.svg");
+      const svgFilePath = join24(targetDir, "session-preview.svg");
       await writeFile7(svgFilePath, svgContent, "utf-8");
       let gifContent = null;
       let gifFilePath = null;
       let gifWarning;
       try {
         const gifBuffer = await generateGitHubGif(targetSession, { replayUrl });
-        gifFilePath = join22(targetDir, "session-preview.gif");
+        gifFilePath = join24(targetDir, "session-preview.gif");
         await writeFile7(gifFilePath, gifBuffer);
         gifContent = gifBuffer.toString("base64");
       } catch (err) {
@@ -13637,7 +14107,7 @@ async function startServer(baseDir, opts) {
         svgPath: "./session-preview.svg",
         gifPath: gifContent ? "./session-preview.gif" : void 0
       });
-      const mdFilePath = join22(targetDir, "github-summary.md");
+      const mdFilePath = join24(targetDir, "github-summary.md");
       await writeFile7(mdFilePath, markdown, "utf-8");
       const findings = scanForSecrets(JSON.stringify(targetSession));
       const warnings = findings.map((f) => `[${f.rule}] ${f.match}`);
@@ -13845,10 +14315,10 @@ async function startServer(baseDir, opts) {
       }
     }
   );
-  await new Promise((resolve4) => {
+  await new Promise((resolve5) => {
     process.on("SIGINT", () => {
       console.log(chalk.dim("\n  Server stopped.\n"));
-      resolve4();
+      resolve5();
       process.exit(0);
     });
   });
@@ -13914,7 +14384,7 @@ function scanInputFromSession(session) {
   return {
     sessionId: session.sessionId,
     provider: session.provider,
-    project: shortenPath(session.project),
+    project: shortenPath2(session.project),
     slug: session.slug,
     filePaths: session.filePaths,
     toolPaths: session.toolPaths,
@@ -13969,10 +14439,11 @@ function sessionInfoToMatch(session, terms = [], precomputedScore) {
     sessionId: session.sessionId,
     slug: session.slug,
     title: cleanPromptText(session.title || "") || void 0,
-    project: shortenPath(session.project),
-    cwd: shortenPath(session.cwd),
+    project: shortenPath2(session.project),
+    cwd: shortenPath2(session.cwd),
     timestamp: session.timestamp,
     gitBranch: session.gitBranch,
+    gitRepo: session.gitRepo,
     model: session.model,
     firstPrompt: cleanPromptText(session.firstPrompt),
     prompts: session.prompts?.map(cleanPromptText).filter(Boolean),
@@ -14206,21 +14677,22 @@ function formatDuration2(ms) {
 // src/index.ts
 init_utils();
 init_version();
+setFileCacheAppVersion(CLI_VERSION);
 async function runGitHubExport(replay, outputDir) {
-  const { join: join23 } = await import("path");
+  const { join: join25 } = await import("path");
   const { writeFile: writeFile8 } = await import("fs/promises");
   const savedGist = await loadSavedGistInfo(outputDir);
   const replayUrl = savedGist?.viewerUrl;
   const svgSpinner = ora("Generating animated SVG...").start();
   const svgContent = generateGitHubSvg(replay, { replayUrl });
-  const svgFilePath = join23(outputDir, "session-preview.svg");
+  const svgFilePath = join25(outputDir, "session-preview.svg");
   await writeFile8(svgFilePath, svgContent, "utf-8");
   svgSpinner.succeed(`SVG: ${svgFilePath}`);
   let gifGenerated = false;
   const gifSpinner = ora("Generating animated GIF...").start();
   try {
     const gifBuffer = await generateGitHubGif(replay, { replayUrl });
-    const gifFilePath = join23(outputDir, "session-preview.gif");
+    const gifFilePath = join25(outputDir, "session-preview.gif");
     await writeFile8(gifFilePath, gifBuffer);
     const gifSizeKB = Math.round(gifBuffer.length / 1024);
     gifSpinner.succeed(`GIF: ${gifFilePath} (${gifSizeKB} KB)`);
@@ -14234,7 +14706,7 @@ async function runGitHubExport(replay, outputDir) {
     svgPath: "./session-preview.svg",
     gifPath: gifGenerated ? "./session-preview.gif" : void 0
   });
-  const mdFilePath = join23(outputDir, "github-summary.md");
+  const mdFilePath = join25(outputDir, "github-summary.md");
   await writeFile8(mdFilePath, markdown, "utf-8");
   mdSpinner.succeed(`Markdown: ${mdFilePath}`);
   const redactionsSpinner = ora("Generating redaction report...").start();
@@ -14250,7 +14722,7 @@ async function runGitHubExport(replay, outputDir) {
       "leftoverFindings: regex matches in the final markdown \u2014 review these before sharing."
     ]
   };
-  const redactionsPath = join23(outputDir, "redactions.json");
+  const redactionsPath = join25(outputDir, "redactions.json");
   await writeFile8(redactionsPath, `${JSON.stringify(redactionsReport, null, 2)}
 `, "utf-8");
   const leftoverNote = leftoverFindings.length > 0 ? chalk2.yellow(`(${leftoverFindings.length} leftover finding(s) \u2014 review)`) : chalk2.dim("(no leftover findings)");
@@ -14259,7 +14731,7 @@ async function runGitHubExport(replay, outputDir) {
     markdown,
     outputDir,
     svgPath: svgFilePath,
-    gifPath: gifGenerated ? join23(outputDir, "session-preview.gif") : void 0,
+    gifPath: gifGenerated ? join25(outputDir, "session-preview.gif") : void 0,
     mdPath: mdFilePath,
     redactionsPath
   };
@@ -14337,10 +14809,10 @@ program.name("vibe-replay").description("AI Coding Session Replay & Sharing Tool
   console.log(chalk2.bold.cyan("\n  vibe-replay") + chalk2.dim(` v${CLI_VERSION}
 `));
   const { join: pathJoin } = await import("path");
-  const { homedir: homedir20 } = await import("os");
-  const replayBaseDir = pathJoin(homedir20(), ".vibe-replay");
+  const { homedir: homedir21 } = await import("os");
+  const replayBaseDir = pathJoin(homedir21(), ".vibe-replay");
   void discoverAllSessions().then(async (sessions) => {
-    await writeFileCache(SESSION_DISCOVERY_CACHE_KEY, sessions);
+    await writeFileCache2(SESSION_DISCOVERY_CACHE_KEY, sessions);
   }).catch(() => {
   });
   if (opts.dashboard) {
@@ -14380,14 +14852,14 @@ program.name("vibe-replay").description("AI Coding Session Replay & Sharing Tool
       return;
     }
     if (topChoice === "replays") {
-      const { readdir: readdir13, readFile: readFile23 } = await import("fs/promises");
+      const { readdir: readdir13, readFile: readFile25 } = await import("fs/promises");
       const replayEntries = [];
       try {
         const entries = await readdir13(replayBaseDir);
         for (const slug2 of entries) {
           if (slug2.startsWith(".") || slug2 === "cache") continue;
           try {
-            const raw = await readFile23(pathJoin(replayBaseDir, slug2, "replay.json"), "utf-8");
+            const raw = await readFile25(pathJoin(replayBaseDir, slug2, "replay.json"), "utf-8");
             const replay2 = JSON.parse(raw);
             const title = replay2.meta?.title || slug2;
             const provider2 = replay2.meta?.provider || "";
@@ -14430,19 +14902,19 @@ program.name("vibe-replay").description("AI Coding Session Replay & Sharing Tool
       return;
     }
     let displayedSessions = [];
-    const cached = await readFileCache(SESSION_DISCOVERY_CACHE_KEY);
+    const cached = await readFileCache2(SESSION_DISCOVERY_CACHE_KEY);
     const hasStaleCache = !!(cached && cached.data.length > 0);
     if (hasStaleCache && cached) {
       displayedSessions = cached.data.slice().sort((a, b) => b.timestamp.localeCompare(a.timestamp));
       discoverAllSessions().then(async (freshSessions) => {
-        await writeFileCache(SESSION_DISCOVERY_CACHE_KEY, freshSessions);
+        await writeFileCache2(SESSION_DISCOVERY_CACHE_KEY, freshSessions);
       }).catch(() => {
       });
     } else {
       const spinner2 = ora("Scanning sessions...").start();
       try {
         displayedSessions = await discoverAllSessions();
-        await writeFileCache(SESSION_DISCOVERY_CACHE_KEY, displayedSessions);
+        await writeFileCache2(SESSION_DISCOVERY_CACHE_KEY, displayedSessions);
       } finally {
         spinner2.stop();
       }
@@ -14509,7 +14981,7 @@ program.name("vibe-replay").description("AI Coding Session Replay & Sharing Tool
           const spinner2 = ora("Refreshing sessions...").start();
           try {
             displayedSessions = await discoverAllSessions();
-            await writeFileCache(SESSION_DISCOVERY_CACHE_KEY, displayedSessions);
+            await writeFileCache2(SESSION_DISCOVERY_CACHE_KEY, displayedSessions);
             spinner2.succeed(`Found ${displayedSessions.length} sessions`);
           } catch {
             spinner2.fail("Refresh failed, using previous list");
@@ -14539,12 +15011,14 @@ program.name("vibe-replay").description("AI Coding Session Replay & Sharing Tool
     spinner.text = "Transforming to replay...";
     const rawProject = sessionInfo?.project || parsed.cwd;
     const project = rawProject.startsWith(home) ? `~${rawProject.slice(home.length)}` : rawProject;
+    const gitRepo = sessionInfo?.gitRepo || await readGitRepo(rawProject);
     replay = transformToReplay(parsed, providerName, project, {
       generator: {
         name: "vibe-replay",
         version: CLI_VERSION,
         generatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      }
+      },
+      gitRepo
     });
     const thinkingStr = replay.meta.stats.thinkingBlocks ? `, ${replay.meta.stats.thinkingBlocks} thinking` : "";
     const sourceStr = replay.meta.dataSource ? chalk2.dim(` [${replay.meta.dataSource}]`) : "";
@@ -14573,10 +15047,10 @@ program.name("vibe-replay").description("AI Coding Session Replay & Sharing Tool
       replay.meta.title = normalizedUserTitle;
     }
   }
-  const { join: join23 } = await import("path");
+  const { join: join25 } = await import("path");
   const rawSlug = replay.meta.slug || replay.meta.sessionId.slice(0, 8);
   const slug = rawSlug.replace(/[^a-zA-Z0-9_-]/g, "-");
-  const outputDir = join23(home, ".vibe-replay", slug);
+  const outputDir = join25(home, ".vibe-replay", slug);
   const genSpinner = ora("Generating replay...").start();
   const outputPath = await generateOutput(replay, outputDir);
   const { stat: fsStat } = await import("fs/promises");
@@ -14668,7 +15142,7 @@ ${chalk2.bold.green("  Done!")}
   if (target === "local") {
     await publishLocal(outputPath);
   } else if (target === "editor") {
-    await startServer(join23(home, ".vibe-replay"), {
+    await startServer(join25(home, ".vibe-replay"), {
       openSlug: slug,
       ...getDevViewerOpts()
     });
@@ -14931,9 +15405,9 @@ authCmd.command("status").description("Show current authentication status").opti
 var VISIBILITIES = ["public", "unlisted", "private"];
 program.command("share").description("Share an existing replay via cloud (unlisted link, expires in 7 days)").argument("[path]", "Path to replay directory or replay.json").option("--visibility <type>", `Visibility: ${VISIBILITIES.join(", ")}`, "unlisted").option("--api-url <url>", `API base URL (default: ${DEFAULT_API_URL})`).action(async (pathArg, opts) => {
   const { existsSync: existsSync2, statSync } = await import("fs");
-  const { readFile: readFile23, readdir: readdir13 } = await import("fs/promises");
-  const { join: join23, dirname: dirname5, resolve: resolve4 } = await import("path");
-  const { homedir: homedir20 } = await import("os");
+  const { readFile: readFile25, readdir: readdir13 } = await import("fs/promises");
+  const { join: join25, dirname: dirname5, resolve: resolve5 } = await import("path");
+  const { homedir: homedir21 } = await import("os");
   if (opts.apiUrl) {
     process.env.VIBE_REPLAY_API_URL = opts.apiUrl.replace(/\/$/, "");
   }
@@ -14952,7 +15426,7 @@ program.command("share").description("Share an existing replay via cloud (unlist
   }
   let outputDir;
   if (pathArg) {
-    const abs = resolve4(pathArg);
+    const abs = resolve5(pathArg);
     if (!existsSync2(abs)) {
       console.error(chalk2.red(`
   \u2717 Path not found: ${abs}
@@ -14962,14 +15436,14 @@ program.command("share").description("Share an existing replay via cloud (unlist
     const s = statSync(abs);
     outputDir = s.isDirectory() ? abs : dirname5(abs);
   } else {
-    const replayBaseDir = join23(homedir20(), ".vibe-replay");
+    const replayBaseDir = join25(homedir21(), ".vibe-replay");
     const entries = await readdir13(replayBaseDir).catch(() => []);
     const replays = [];
     for (const slug of entries) {
       if (slug.startsWith(".") || slug === "cache") continue;
-      const jsonPath2 = join23(replayBaseDir, slug, "replay.json");
+      const jsonPath2 = join25(replayBaseDir, slug, "replay.json");
       try {
-        const raw = await readFile23(jsonPath2, "utf-8");
+        const raw = await readFile25(jsonPath2, "utf-8");
         const replay = JSON.parse(raw);
         const title = replay.meta?.title || slug;
         const startTime = replay.meta?.startTime || "";
@@ -14982,7 +15456,7 @@ program.command("share").description("Share an existing replay via cloud (unlist
         }) : "";
         replays.push({
           name: time ? `${chalk2.dim(`[${time}]`)} ${chalk2.white(title)}` : chalk2.white(title),
-          value: join23(replayBaseDir, slug),
+          value: join25(replayBaseDir, slug),
           time: startTime
         });
       } catch {
@@ -14998,7 +15472,7 @@ program.command("share").description("Share an existing replay via cloud (unlist
       choices: replays
     });
   }
-  const jsonPath = join23(outputDir, "replay.json");
+  const jsonPath = join25(outputDir, "replay.json");
   if (!existsSync2(jsonPath)) {
     console.error(chalk2.red(`
   \u2717 No replay.json found in ${outputDir}
@@ -15023,8 +15497,8 @@ program.command("share").description("Share an existing replay via cloud (unlist
 var LIVE_STALENESS_WARNING_MS = 5 * 6e4;
 program.command("live").description("Watch a running AI coding session live in the browser").option("-p, --provider <name>", "Provider name (default: auto-detect)").option("-s, --session <sessionId>", "Specific session ID to watch").action(async (opts, command) => {
   const { join: pathJoin } = await import("path");
-  const { homedir: homedir20 } = await import("os");
-  const replayBaseDir = pathJoin(homedir20(), ".vibe-replay");
+  const { homedir: homedir21 } = await import("os");
+  const replayBaseDir = pathJoin(homedir21(), ".vibe-replay");
   console.log(chalk2.bold.cyan("\n  vibe-replay live") + chalk2.dim(` v${CLI_VERSION}
 `));
   let target = null;
@@ -15118,8 +15592,10 @@ function formatSessionChoices(sessions, cleanupPeriodDays) {
   const projectEntries = [...byProject.entries()];
   for (let pi = 0; pi < projectEntries.length; pi++) {
     const [project, projectSessions] = projectEntries[pi];
+    const gitRepo = projectSessions[0]?.gitRepo;
+    const heading = gitRepo ? `${project} ${chalk2.dim(`(${gitRepo})`)}` : project;
     if (pi > 0) choices.push(new Separator(""));
-    choices.push(new Separator(chalk2.bold.white(`  \u2500\u2500\u2500 ${project} \u2500\u2500\u2500`)));
+    choices.push(new Separator(chalk2.bold.white(`  \u2500\u2500\u2500 ${heading} \u2500\u2500\u2500`)));
     for (const s of projectSessions) {
       const date = new Date(s.timestamp);
       const timeStr = date.toLocaleString("en-US", {