@yhong91/vibetime 0.1.55 → 0.1.57

package/bin/vibetime.mjs

@@ -884,9 +884,9 @@ var init_esm = __esm({
 
 // src/cli.ts
 import { spawn as spawn2, spawnSync } from "node:child_process";
-import { mkdir as mkdir5, open, rm, stat as stat14, writeFile as writeFile4 } from "node:fs/promises";
-import os12 from "node:os";
-import path25 from "node:path";
+import { mkdir as mkdir5, open, rm, stat as stat15, writeFile as writeFile4 } from "node:fs/promises";
+import os13 from "node:os";
+import path26 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // ../shared/src/index.ts
@@ -924,7 +924,7 @@ var TELEMETRY_EVENT_TYPES = [
   "agent.operation"
 ];
 var FILE_ACTIVITY_OPERATIONS = ["read", "search", "create", "write", "edit", "delete"];
-var BACKFILL_SOURCE_IDS = ["codex", "claude-code", "claude-cowork", "copilot", "opencode", "pi", "agy", "codebuddy", "qoder", "qoder-cn", "workbuddy", "zcode", "grok-build", "zed", "kimi-code"];
+var BACKFILL_SOURCE_IDS = ["codex", "claude-code", "claude-cowork", "copilot", "opencode", "pi", "agy", "codebuddy", "qoder", "qoder-cn", "workbuddy", "zcode", "grok-build", "zed", "kimi-code", "cursor"];
 function createWorkspaceId(input) {
   const basis = input.repoUrl || input.repoRoot || input.projectName || "unknown";
   return `workspace_${fnv1a(basis)}`;
@@ -2047,7 +2047,7 @@ function claudeStyleFileMetrics(tool, input) {
 }
 
 // src/lib/constants.ts
-var PACKAGE_VERSION = true ? "0.1.55" : "0.1.1";
+var PACKAGE_VERSION = true ? "0.1.57" : "0.1.1";
 var GENERATED_MARKER = "Generated by vibetime.";
 var DEFAULT_API_URL = "http://121.196.224.82:3001";
 var DEFAULT_BACKFILL_BATCH_SIZE = 50;
@@ -5011,8 +5011,8 @@ async function codebuddyBackfillFiles(sourceRoot, home, env) {
           }
           const filePath = path9.join(traceDir, entry);
           try {
-            const stat15 = await import("node:fs/promises").then((fs) => fs.stat(filePath));
-            files.push({ path: filePath, modifiedAt: stat15.mtime.toISOString(), groupId: pidDir.name });
+            const stat16 = await import("node:fs/promises").then((fs) => fs.stat(filePath));
+            files.push({ path: filePath, modifiedAt: stat16.mtime.toISOString(), groupId: pidDir.name });
           } catch {
           }
         }
@@ -6177,86 +6177,1292 @@ async function copilotBackfillFiles(sourceRoot, home = os5.homedir(), _env) {
   } catch {
     return [];
   }
-  for (const entry of entries) {
-    if (entry.startsWith("pending-session")) {
+  for (const entry of entries) {
+    if (entry.startsWith("pending-session")) {
+      continue;
+    }
+    const eventsPath = path12.join(sessionDir, entry, "events.jsonl");
+    const info = await stat6(eventsPath).catch(() => null);
+    if (info) {
+      results.push({ path: eventsPath, modifiedAt: info.mtime.toISOString() });
+    }
+  }
+  return results;
+}
+function copilotPluginContent() {
+  return `// Agent Time plugin for GitHub Copilot CLI
+// Generated by vibetime.
+// Copilot does not support hooks \u2014 this file is a placeholder for detection.
+// Backfill reads session data from ~/.copilot/session-state/*/events.jsonl.
+`;
+}
+function copilotHome(home, env) {
+  const override = env?.COPILOT_HOME;
+  if (override && override.trim()) {
+    return path12.resolve(override);
+  }
+  return path12.join(home, ".copilot");
+}
+function createCopilotAdapter() {
+  return {
+    id: "copilot",
+    label: "GitHub Copilot",
+    agentName: "copilot",
+    kind: "agent",
+    detectPath(home, env) {
+      return copilotHome(home, env);
+    },
+    installedPath(home, env) {
+      return path12.join(copilotHome(home, env), ".vibetime");
+    },
+    async isInstalled(home, env) {
+      try {
+        const { pathExists: pathExists2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
+        return await pathExists2(path12.join(copilotHome(home, env), ".vibetime"));
+      } catch {
+        return false;
+      }
+    },
+    installEntries(home, env) {
+      return [{
+        kind: "file",
+        path: path12.join(copilotHome(home, env), ".vibetime"),
+        content: copilotPluginContent()
+      }];
+    },
+    sourcePaths(home, env) {
+      return [path12.join(copilotHome(home, env), "session-state")];
+    },
+    parseSessionFile: parseCopilotSessionFile
+  };
+}
+
+// src/adapters/cursor.ts
+import { copyFile, readdir as readdir6, readFile as readFile8, stat as stat7 } from "node:fs/promises";
+import os6 from "node:os";
+import path13 from "node:path";
+
+// src/lib/cursor-hooks.ts
+function isCursorHooksFile(value) {
+  if (!isPlainObject(value)) {
+    return false;
+  }
+  if (value.version !== 1 && value.version !== void 0) {
+    return false;
+  }
+  return isPlainObject(value.hooks);
+}
+function hookCommandFromCursorEntry(entry) {
+  if (!isPlainObject(entry) || typeof entry.command !== "string" || !entry.command) {
+    return void 0;
+  }
+  return entry.command;
+}
+function hasCursorHookCommand(config, command) {
+  if (!isCursorHooksFile(config)) {
+    return false;
+  }
+  return Object.values(config.hooks).some(
+    (entries) => Array.isArray(entries) && entries.some((entry) => hookCommandFromCursorEntry(entry) === command)
+  );
+}
+function mergeCursorHooksJson(existing, addition) {
+  const mergedHooks = {};
+  const existingHooks = isCursorHooksFile(existing) ? existing.hooks : {};
+  for (const [event, entries] of Object.entries(existingHooks)) {
+    if (Array.isArray(entries)) {
+      mergedHooks[event] = [...entries];
+    }
+  }
+  for (const [event, entries] of Object.entries(addition.hooks)) {
+    const current = mergedHooks[event] ? [...mergedHooks[event]] : [];
+    for (const entry of entries) {
+      const command = hookCommandFromCursorEntry(entry);
+      if (!command) {
+        continue;
+      }
+      const alreadyPresent = current.some(
+        (existingEntry) => hookCommandFromCursorEntry(existingEntry) === command
+      );
+      if (!alreadyPresent) {
+        current.push(entry);
+      }
+    }
+    mergedHooks[event] = current;
+  }
+  const extra = isPlainObject(existing) ? Object.fromEntries(
+    Object.entries(existing).filter(([key]) => key !== "version" && key !== "hooks")
+  ) : {};
+  return {
+    ...extra,
+    version: 1,
+    hooks: mergedHooks
+  };
+}
+function stripCursorHookCommands(existing, commands) {
+  const next = structuredClone(isPlainObject(existing) ? existing : {});
+  if (!isPlainObject(next.hooks)) {
+    return { next, changed: false };
+  }
+  const hooks = { ...next.hooks };
+  let changed = false;
+  for (const [event, entries] of Object.entries(hooks)) {
+    if (!Array.isArray(entries)) {
+      continue;
+    }
+    const stripped = entries.filter((entry) => {
+      const command = hookCommandFromCursorEntry(entry);
+      return !command || !commands.has(command);
+    });
+    if (stripped.length !== entries.length) {
+      changed = true;
+    }
+    if (stripped.length === 0) {
+      delete hooks[event];
+    } else {
+      hooks[event] = stripped;
+    }
+  }
+  if (Object.keys(hooks).length === 0) {
+    delete next.hooks;
+    changed = true;
+  } else {
+    next.hooks = hooks;
+  }
+  return { next, changed };
+}
+function collectCursorHookCommands(content) {
+  const commands = /* @__PURE__ */ new Set();
+  for (const entries of Object.values(content.hooks)) {
+    for (const entry of entries) {
+      const command = hookCommandFromCursorEntry(entry);
+      if (command) {
+        commands.add(command);
+      }
+    }
+  }
+  return [...commands];
+}
+
+// src/adapters/cursor.ts
+init_fs();
+var SOURCE_ID = "cursor";
+var AGENT_NAME = "cursor";
+var HOOK_COMMAND = `vibetime hook --agent ${SOURCE_ID}`;
+var HOOK_TIMEOUT_SECONDS = 10;
+var BUBBLE_USER = 1;
+var CAPABILITY_TOOL = 15;
+var CURSOR_HOOK_EVENTS = [
+  "sessionStart",
+  "sessionEnd",
+  "beforeSubmitPrompt",
+  "preToolUse",
+  "postToolUse",
+  "postToolUseFailure",
+  "subagentStart",
+  "subagentStop",
+  "stop",
+  "afterFileEdit",
+  "afterShellExecution",
+  "preCompact"
+];
+function cursorHome(home, env) {
+  const override = env?.CURSOR_HOME;
+  if (override && override.trim()) {
+    return path13.resolve(override);
+  }
+  return path13.join(home, ".cursor");
+}
+function cursorHooksPath(home, env) {
+  return path13.join(cursorHome(home, env), "hooks.json");
+}
+function cursorProjectsDir(home, env) {
+  return path13.join(cursorHome(home, env), "projects");
+}
+function cursorChatsDir(home, env) {
+  return path13.join(cursorHome(home, env), "chats");
+}
+function cursorUserDir(home, env) {
+  const override = env?.CURSOR_USER_DIR;
+  if (override && override.trim()) {
+    return path13.resolve(override);
+  }
+  return void 0;
+}
+function cursorStateDbCandidates(home, env) {
+  const candidates = [];
+  const userDir = cursorUserDir(home, env);
+  if (userDir) {
+    candidates.push(path13.join(userDir, "globalStorage", "state.vscdb"));
+  }
+  const platform2 = process.platform;
+  if (platform2 === "darwin") {
+    candidates.push(path13.join(home, "Library", "Application Support", "Cursor", "User", "globalStorage", "state.vscdb"));
+  } else if (platform2 === "win32") {
+    const appdata = env?.APPDATA;
+    if (appdata && appdata.trim()) {
+      candidates.push(path13.join(path13.resolve(appdata), "Cursor", "User", "globalStorage", "state.vscdb"));
+    }
+    candidates.push(path13.join(home, "AppData", "Roaming", "Cursor", "User", "globalStorage", "state.vscdb"));
+  } else {
+    const xdgConfig = env?.XDG_CONFIG_HOME;
+    if (xdgConfig && xdgConfig.trim()) {
+      candidates.push(path13.join(path13.resolve(xdgConfig), "Cursor", "User", "globalStorage", "state.vscdb"));
+    }
+    candidates.push(path13.join(home, ".config", "Cursor", "User", "globalStorage", "state.vscdb"));
+  }
+  return candidates;
+}
+function decodeKv(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value instanceof Uint8Array) {
+    return new TextDecoder().decode(value);
+  }
+  return void 0;
+}
+function parseJsonObject(text) {
+  if (!text) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(text);
+    return isPlainObject(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parseMaybeJsonObject(value) {
+  if (isPlainObject(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    return parseJsonObject(value) || {};
+  }
+  return {};
+}
+function cleanId(value) {
+  return value.replace(/\s+/g, "_").slice(0, 200);
+}
+async function openCursorDb(dbPath) {
+  const { DatabaseSync } = await import("node:sqlite");
+  try {
+    return {
+      db: new DatabaseSync(dbPath, { readOnly: true }),
+      cleanup: async () => {
+      }
+    };
+  } catch {
+    const tmp = path13.join(os6.tmpdir(), `vibetime-cursor-${createStableHash(dbPath).slice(0, 12)}.db`);
+    await copyFile(dbPath, tmp);
+    for (const suffix of ["-wal", "-shm"]) {
+      await copyFile(`${dbPath}${suffix}`, `${tmp}${suffix}`).catch(() => void 0);
+    }
+    return {
+      db: new DatabaseSync(tmp, { readOnly: true }),
+      cleanup: async () => {
+        const { unlink } = await import("node:fs/promises");
+        await unlink(tmp).catch(() => void 0);
+        await unlink(`${tmp}-wal`).catch(() => void 0);
+        await unlink(`${tmp}-shm`).catch(() => void 0);
+      }
+    };
+  }
+}
+function listComposers(db) {
+  const dataById = /* @__PURE__ */ new Map();
+  const dataRows = db.prepare(
+    "SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'"
+  ).all();
+  for (const row of dataRows) {
+    const id = row.key.slice("composerData:".length);
+    const data = parseJsonObject(decodeKv(row.value));
+    if (id && data) {
+      dataById.set(id, data);
+    }
+  }
+  let headers = [];
+  try {
+    headers = db.prepare(
+      "SELECT composerId, createdAt, lastUpdatedAt, isSubagent, value FROM composerHeaders"
+    ).all();
+  } catch {
+    headers = [...dataById.entries()].map(([composerId, data]) => ({
+      composerId,
+      createdAt: numberField(data, "createdAt"),
+      lastUpdatedAt: numberField(data, "lastUpdatedAt"),
+      isSubagent: data.isBestOfNSubcomposer || data.isSubagent ? 1 : 0,
+      value: JSON.stringify(data)
+    }));
+  }
+  const composers = [];
+  for (const headerRow of headers) {
+    const composerId = headerRow.composerId;
+    if (!composerId || composerId === "empty-state-draft") {
+      continue;
+    }
+    const header = parseJsonObject(decodeKv(headerRow.value)) || parseMaybeJsonObject(headerRow.value);
+    const data = dataById.get(composerId) || header;
+    if (data.isDraft === true || data.isEphemeral === true || header.isDraft === true || header.isEphemeral === true) {
+      continue;
+    }
+    composers.push({
+      composerId,
+      createdAt: headerRow.createdAt ?? numberField(data, "createdAt") ?? numberField(header, "createdAt"),
+      lastUpdatedAt: headerRow.lastUpdatedAt ?? numberField(data, "lastUpdatedAt") ?? numberField(header, "lastUpdatedAt"),
+      isSubagent: Boolean(headerRow.isSubagent) || data.isBestOfNSubcomposer === true,
+      header,
+      data
+    });
+  }
+  return composers;
+}
+function loadBubbles(db, composerId) {
+  const rows = db.prepare(
+    "SELECT key, value FROM cursorDiskKV WHERE key LIKE ?"
+  ).all(`bubbleId:${composerId}:%`);
+  const bubbles = [];
+  for (const row of rows) {
+    const bubble = parseJsonObject(decodeKv(row.value));
+    if (bubble) {
+      bubbles.push(bubble);
+    }
+  }
+  bubbles.sort((a, b) => {
+    const aTs = stringField(a, "createdAt") || "";
+    const bTs = stringField(b, "createdAt") || "";
+    return aTs.localeCompare(bTs);
+  });
+  return bubbles;
+}
+function workspaceFromComposer(data) {
+  const ident = objectField(data, "workspaceIdentifier");
+  const uri = objectField(ident, "uri");
+  const cwd = stringField(uri, "fsPath") || stringField(uri, "path");
+  return {
+    cwd,
+    project: cwd ? path13.basename(cwd) : void 0
+  };
+}
+function modelFromComposer(data) {
+  const config = objectField(data, "modelConfig");
+  return stringField(config, "modelName") || stringField(config, "modelId");
+}
+function bubbleTs(bubble, fallback) {
+  return timestampFrom(bubble.createdAt) || stringField(bubble, "createdAt") || fallback;
+}
+function toolNameOf(raw) {
+  if (!raw) {
+    return "unknown";
+  }
+  return raw.replace(/_v\d+$/i, "");
+}
+function isShellTool(name) {
+  const lower = name.toLowerCase();
+  return lower === "shell" || lower === "bash" || lower === "run_terminal_cmd" || lower === "run_terminal_command";
+}
+function fileActivitiesFromCursorTool(toolName, input, ts, cwd) {
+  const lower = toolName.toLowerCase();
+  if (isShellTool(toolName)) {
+    const command = stringField(input, "command") || stringField(input, "cmd");
+    if (command) {
+      return fileActivitiesFromShellCommand(command, ts, cwd, cwd);
+    }
+    return [];
+  }
+  const target = stringField(input, "path") || stringField(input, "targetFile") || stringField(input, "target_file") || stringField(input, "file_path") || stringField(input, "filePath");
+  const display = target ? displayFilePath(target, cwd) : void 0;
+  if (lower === "read" || lower === "read_file" || lower === "readfile") {
+    if (!display) {
+      return [];
+    }
+    return [{ ts, path: display, operation: "read", confidence: "exact" }];
+  }
+  if (lower === "grep" || lower === "grep_search" || lower === "ripgrep" || lower === "glob" || lower === "glob_file_search" || lower === "globfilesearch") {
+    if (!display) {
+      return [];
+    }
+    return [{ ts, path: display, operation: "search", confidence: "exact" }];
+  }
+  if (lower === "delete" || lower === "delete_file") {
+    if (!display) {
+      return [];
+    }
+    return [{ ts, path: display, operation: "delete", confidence: "exact" }];
+  }
+  if (lower === "write" || lower === "write_file") {
+    if (!display) {
+      return [];
+    }
+    const content = stringField(input, "contents") || stringField(input, "content");
+    return [{
+      ts,
+      path: display,
+      operation: "write",
+      confidence: "exact",
+      linesAdded: countTextLines(content),
+      charsWritten: content?.length
+    }];
+  }
+  if (lower === "search_replace" || lower === "strreplace" || lower === "edit" || lower === "edit_file" || lower === "apply_patch" || lower === "applypatch") {
+    if (!display) {
+      return [];
+    }
+    const oldString = stringField(input, "old_string") || stringField(input, "oldString") || stringField(input, "old_str");
+    const newString = stringField(input, "new_string") || stringField(input, "newString") || stringField(input, "new_str") || stringField(input, "contents") || stringField(input, "content");
+    return [{
+      ts,
+      path: display,
+      operation: "edit",
+      confidence: "exact",
+      linesAdded: countTextLines(newString),
+      linesRemoved: countTextLines(oldString),
+      charsWritten: newString?.length
+    }];
+  }
+  return [];
+}
+function usageMetrics(tokenCount) {
+  const inputTokens = numberField(tokenCount, "inputTokens") || 0;
+  const outputTokens = numberField(tokenCount, "outputTokens") || 0;
+  const cached = numberField(tokenCount, "cacheReadTokens") || numberField(tokenCount, "cachedInputTokens") || 0;
+  const cacheCreation = numberField(tokenCount, "cacheWriteTokens") || numberField(tokenCount, "cacheCreationTokens") || 0;
+  if (inputTokens <= 0 && outputTokens <= 0 && cached <= 0 && cacheCreation <= 0) {
+    return void 0;
+  }
+  return {
+    tokensInput: inputTokens || void 0,
+    tokensOutput: outputTokens || void 0,
+    tokensCachedInput: cached + cacheCreation || void 0,
+    tokensCacheReadInput: cached || void 0,
+    tokensCacheCreationInput: cacheCreation || void 0,
+    tokensTotal: inputTokens + outputTokens || void 0,
+    modelCalls: 1
+  };
+}
+var CURSOR_TIMESTAMP_RE = /<timestamp>\s*([^<]+?)\s*<\/timestamp>/i;
+var CURSOR_USER_QUERY_RE = /<user_query>\s*([\s\S]*?)\s*<\/user_query>/i;
+var chatMetaIndexCache = /* @__PURE__ */ new Map();
+function isCursorTranscriptPath(filePath) {
+  return filePath.split(path13.sep).includes("agent-transcripts") && filePath.endsWith(".jsonl");
+}
+function cursorHomeFromTranscript(filePath) {
+  const parts = filePath.split(path13.sep);
+  const at = parts.lastIndexOf("agent-transcripts");
+  if (at >= 2 && parts[at - 2] === "projects") {
+    return parts.slice(0, at - 2).join(path13.sep);
+  }
+  return void 0;
+}
+function parseCursorClock(raw) {
+  const trimmed = raw.trim();
+  const direct = timestampFrom(trimmed);
+  if (direct) {
+    return direct;
+  }
+  const withoutWeekday = trimmed.replace(/^[A-Za-z]{3,9},\s*/, "");
+  const normalized = withoutWeekday.replace(/\((UTC[+-]\d{1,2}(?::\d{2})?)\)/i, "$1");
+  for (const candidate of [normalized, withoutWeekday, trimmed]) {
+    const parsed = Date.parse(candidate);
+    if (!Number.isNaN(parsed)) {
+      return new Date(parsed).toISOString();
+    }
+  }
+  return void 0;
+}
+function latestTimestamp(...values) {
+  let best;
+  for (const value of values) {
+    if (!value || Number.isNaN(Date.parse(value))) {
+      continue;
+    }
+    if (!best || value > best) {
+      best = value;
+    }
+  }
+  return best;
+}
+function timestampBetween(start, end, index, count) {
+  if (count <= 0 || index < 0) {
+    return start;
+  }
+  const startMs = Date.parse(start);
+  const endMs = Date.parse(end);
+  if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || endMs <= startMs) {
+    return start;
+  }
+  return new Date(startMs + Math.round((endMs - startMs) * (index + 1) / (count + 1))).toISOString();
+}
+function parseCursorUserText(text) {
+  const tsMatch = text.match(CURSOR_TIMESTAMP_RE);
+  const queryMatch = text.match(CURSOR_USER_QUERY_RE);
+  return {
+    ts: tsMatch?.[1] ? parseCursorClock(tsMatch[1]) : void 0,
+    prompt: (queryMatch?.[1] || text.replace(CURSOR_TIMESTAMP_RE, "")).trim()
+  };
+}
+function messageText(message) {
+  const content = message.content;
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return stringField(message, "text") || "";
+  }
+  const parts = [];
+  for (const item of content) {
+    if (isPlainObject(item) && stringField(item, "type") === "text") {
+      const text = stringField(item, "text");
+      if (text) {
+        parts.push(text);
+      }
+    }
+  }
+  return parts.join("\n");
+}
+function messageToolUses(message) {
+  const content = message.content;
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  const tools = [];
+  for (const item of content) {
+    if (!isPlainObject(item) || stringField(item, "type") !== "tool_use") {
+      continue;
+    }
+    tools.push({
+      name: stringField(item, "name") || "unknown",
+      id: stringField(item, "id"),
+      input: isPlainObject(item.input) ? item.input : parseMaybeJsonObject(item.input)
+    });
+  }
+  return tools;
+}
+async function indexCursorChatMeta(cursorHome2) {
+  const cached = chatMetaIndexCache.get(cursorHome2);
+  if (cached) {
+    return cached;
+  }
+  const pending = buildCursorChatMetaIndex(cursorHome2);
+  chatMetaIndexCache.set(cursorHome2, pending);
+  return pending;
+}
+async function buildCursorChatMetaIndex(cursorHome2) {
+  const index = /* @__PURE__ */ new Map();
+  const chatsDir = path13.join(cursorHome2, "chats");
+  const projectDirs = await readdir6(chatsDir, { withFileTypes: true }).catch(() => []);
+  for (const project of projectDirs) {
+    if (!project.isDirectory()) {
+      continue;
+    }
+    const sessions = await readdir6(path13.join(chatsDir, project.name), { withFileTypes: true }).catch(() => []);
+    for (const session of sessions) {
+      if (!session.isDirectory()) {
+        continue;
+      }
+      const sessionDir = path13.join(chatsDir, project.name, session.name);
+      const meta = await readJsonIfExists(path13.join(sessionDir, "meta.json"));
+      const fromMeta = isPlainObject(meta) ? meta : {};
+      const fromStore = await readCursorStoreMeta(path13.join(sessionDir, "store.db"));
+      const cwd = stringField(fromMeta, "cwd") || fromStore.cwd;
+      index.set(session.name, {
+        cwd,
+        project: cwd ? path13.basename(cwd) : void 0,
+        model: fromStore.model,
+        startedAt: timestampFrom(fromMeta.createdAtMs) || fromStore.startedAt,
+        endedAt: timestampFrom(fromMeta.updatedAtMs) || fromStore.endedAt
+      });
+    }
+  }
+  return index;
+}
+async function readCursorStoreMeta(storePath) {
+  const info = await stat7(storePath).catch(() => null);
+  if (!info) {
+    return {};
+  }
+  try {
+    const { DatabaseSync } = await import("node:sqlite");
+    const db = new DatabaseSync(storePath, { readOnly: true });
+    try {
+      const row = db.prepare("SELECT value FROM meta LIMIT 1").get();
+      const decoded = decodeStoreMetaValue(row?.value);
+      if (!decoded) {
+        return {};
+      }
+      const cwd = stringField(decoded, "cwd") || stringField(objectField(decoded, "workspace"), "path");
+      return {
+        cwd,
+        project: cwd ? path13.basename(cwd) : void 0,
+        model: stringField(decoded, "lastUsedModel") || stringField(decoded, "model"),
+        startedAt: timestampFrom(decoded.createdAt),
+        endedAt: timestampFrom(decoded.lastUpdatedAt) || timestampFrom(decoded.updatedAt)
+      };
+    } finally {
+      db.close();
+    }
+  } catch {
+    return {};
+  }
+}
+function decodeStoreMetaValue(value) {
+  if (typeof value !== "string" || !value) {
+    return void 0;
+  }
+  try {
+    const asJson = parseJsonObject(value);
+    if (asJson) {
+      return asJson;
+    }
+    return parseJsonObject(Buffer.from(value, "hex").toString("utf8"));
+  } catch {
+    return void 0;
+  }
+}
+async function resolveTranscriptContext(filePath, sessionId) {
+  const sibling = await readJsonIfExists(path13.join(path13.dirname(filePath), "meta.json"));
+  if (isPlainObject(sibling)) {
+    const cwd = stringField(sibling, "cwd");
+    return {
+      cwd,
+      project: cwd ? path13.basename(cwd) : void 0,
+      startedAt: timestampFrom(sibling.createdAtMs),
+      endedAt: timestampFrom(sibling.updatedAtMs)
+    };
+  }
+  const cursorHomePath = cursorHomeFromTranscript(filePath);
+  if (!cursorHomePath) {
+    return {};
+  }
+  const index = await indexCursorChatMeta(cursorHomePath);
+  return index.get(sessionId) || {};
+}
+async function parseCursorTranscriptFile(filePath, options) {
+  const text = await readFile8(filePath, "utf8").catch(() => "");
+  if (!text) {
+    return [];
+  }
+  const lines = text.split("\n").filter(Boolean);
+  const parsed = lines.map(parseJsonLine);
+  const hasConversation = parsed.some((raw) => raw && (raw.role === "user" || raw.role === "assistant"));
+  if (!hasConversation) {
+    return [];
+  }
+  const sessionId = path13.basename(filePath, ".jsonl");
+  const context = await resolveTranscriptContext(filePath, sessionId);
+  const fileInfo = await stat7(filePath).catch(() => null);
+  let cwd = context.cwd;
+  let project = context.project;
+  let model = context.model;
+  let lastTs = context.startedAt || (fileInfo ? fileInfo.mtime.toISOString() : void 0);
+  const fileMtime = fileInfo ? fileInfo.mtime.toISOString() : void 0;
+  const workspaceId = createWorkspaceId({ projectName: project, repoRoot: cwd });
+  const sourcePathHash = `sha256:${createStableHash(filePath)}`;
+  const events = [];
+  let lineNumber = 0;
+  let currentTurnId;
+  let currentTurnStartedAt;
+  let turnIndex = 0;
+  let sessionStarted = false;
+  let pendingTurnSuccess = true;
+  const pendingTools = [];
+  const push = (partial, topType) => {
+    lineNumber += 1;
+    const event = {
+      schemaVersion: AGENT_TIME_SCHEMA_VERSION,
+      source: SOURCE_ID,
+      agent: AGENT_NAME,
+      workspaceId,
+      project,
+      cwd,
+      model,
+      sessionId,
+      ...partial
+    };
+    events.push(withBackfillRefs(event, {
+      filePath,
+      sourcePathHash,
+      lineNumber,
+      topType,
+      payloadType: event.type,
+      options
+    }));
+  };
+  const ensureSessionStarted = (ts) => {
+    if (sessionStarted) {
+      return;
+    }
+    sessionStarted = true;
+    push({
+      ts,
+      type: "session.started",
+      confidence: "partial",
+      refs: stringRefs({ sourceId: `${sessionId}:started` })
+    }, "transcript");
+  };
+  const closeTurn = (endTs, success = pendingTurnSuccess) => {
+    if (!currentTurnId || !currentTurnStartedAt) {
+      pendingTools.length = 0;
+      pendingTurnSuccess = true;
+      return;
+    }
+    const turnId = currentTurnId;
+    const startedAt = currentTurnStartedAt;
+    const finishedAt = latestTimestamp(startedAt, endTs) || startedAt;
+    const toolCount = pendingTools.length;
+    for (const [index, item] of pendingTools.entries()) {
+      const ts = timestampBetween(startedAt, finishedAt, index, toolCount);
+      const fileActivities = fileActivitiesFromCursorTool(item.tool, item.input, ts, cwd);
+      push({
+        ts,
+        type: "tool.started",
+        turnId,
+        tool: item.tool,
+        operation: `${item.tool} started`,
+        model,
+        confidence: "exact",
+        fileActivities: fileActivities.length > 0 ? fileActivities : void 0,
+        refs: stringRefs({ sourceId: `${item.toolCallId}:started` })
+      }, "tool");
+      push({
+        ts,
+        type: "tool.completed",
+        turnId,
+        tool: item.tool,
+        operation: `${item.tool} completed`,
+        success,
+        model,
+        confidence: "exact",
+        metrics: { toolCalls: 1 },
+        refs: stringRefs({ sourceId: `${item.toolCallId}:completed` })
+      }, "tool");
+      if (item.command) {
+        push({
+          ts,
+          type: "command.started",
+          turnId,
+          tool: item.tool,
+          operation: "command started",
+          confidence: "derived",
+          refs: stringRefs({
+            sourceId: `${item.toolCallId}:command:started`,
+            commandHash: `sha256:${createStableHash(item.command)}`
+          })
+        }, "tool");
+        push({
+          ts,
+          type: "command.completed",
+          turnId,
+          tool: item.tool,
+          operation: "command completed",
+          success,
+          confidence: "derived",
+          metrics: { commandCalls: 1 },
+          refs: stringRefs({ sourceId: `${item.toolCallId}:command:completed` })
+        }, "tool");
+      }
+    }
+    pendingTools.length = 0;
+    push({
+      ts: finishedAt,
+      type: "turn.completed",
+      turnId,
+      model,
+      success,
+      confidence: "derived",
+      metrics: { durationMs: durationMsBetween(startedAt, finishedAt) },
+      refs: stringRefs({ sourceId: `${sessionId}:${turnId}:completed` })
+    }, "transcript");
+    currentTurnId = void 0;
+    currentTurnStartedAt = void 0;
+    pendingTurnSuccess = true;
+  };
+  for (const raw of parsed) {
+    if (!raw) {
+      continue;
+    }
+    const role = stringField(raw, "role");
+    const topType = stringField(raw, "type");
+    const message = objectField(raw, "message");
+    const body = Object.keys(message).length > 0 ? message : raw;
+    const rawText = messageText(body);
+    if (!cwd) {
+      const workspaceMatch = rawText.match(/Workspace Path:\s*(.+)/);
+      const found = workspaceMatch?.[1]?.trim();
+      if (found) {
+        cwd = found;
+        project = path13.basename(found);
+      }
+    }
+    if (role === "user") {
+      const userBits = parseCursorUserText(rawText);
+      const ts = timestampFrom(raw.timestamp) || userBits.ts;
+      if (!ts) {
+        continue;
+      }
+      lastTs = latestTimestamp(lastTs, ts) || ts;
+      ensureSessionStarted(ts);
+      closeTurn(ts);
+      turnIndex += 1;
+      currentTurnId = `turn_${turnIndex}`;
+      currentTurnStartedAt = ts;
+      pendingTurnSuccess = true;
+      push({
+        ts,
+        type: "turn.started",
+        turnId: currentTurnId,
+        model,
+        confidence: "partial",
+        refs: stringRefs({ sourceId: `${sessionId}:${currentTurnId}:started` })
+      }, "transcript");
+      if (userBits.prompt) {
+        push({
+          ts,
+          type: "prompt.submitted",
+          turnId: currentTurnId,
+          model,
+          confidence: "partial",
+          metrics: { prompts: 1, promptChars: userBits.prompt.length },
+          refs: stringRefs({
+            sourceId: `${sessionId}:${currentTurnId}:prompt`,
+            promptHash: `sha256:${createStableHash(userBits.prompt)}`
+          })
+        }, "transcript");
+      }
+      continue;
+    }
+    if (role === "assistant") {
+      if (!currentTurnId && lastTs) {
+        ensureSessionStarted(lastTs);
+        turnIndex += 1;
+        currentTurnId = `turn_${turnIndex}`;
+        currentTurnStartedAt = lastTs;
+      }
+      if (!currentTurnId) {
+        continue;
+      }
+      for (const [index, toolUse] of messageToolUses(body).entries()) {
+        const tool = toolNameOf(toolUse.name);
+        const command = isShellTool(tool) ? stringField(toolUse.input, "command") || stringField(toolUse.input, "cmd") : void 0;
+        pendingTools.push({
+          tool,
+          toolCallId: cleanId(
+            toolUse.id || `${sessionId}:${currentTurnId}:${pendingTools.length}:${index}`
+          ),
+          input: toolUse.input,
+          command
+        });
+      }
+      continue;
+    }
+    if (topType === "turn_ended") {
+      const status = (stringField(raw, "status") || "success").toLowerCase();
+      pendingTurnSuccess = status !== "error" && status !== "failed" && status !== "cancelled";
+    }
+  }
+  const endedAt = latestTimestamp(lastTs, context.endedAt, fileMtime);
+  if (endedAt) {
+    closeTurn(endedAt);
+    if (sessionStarted) {
+      push({
+        ts: endedAt,
+        type: "session.ended",
+        confidence: "derived",
+        refs: stringRefs({ sourceId: `${sessionId}:ended` })
+      }, "transcript");
+    }
+  }
+  return events;
+}
+async function listCursorComposerIds(dbPath) {
+  const ids = /* @__PURE__ */ new Set();
+  const info = await stat7(dbPath).catch(() => null);
+  if (!info) {
+    return ids;
+  }
+  try {
+    const opened = await openCursorDb(dbPath);
+    try {
+      for (const composer of listComposers(opened.db)) {
+        ids.add(composer.composerId);
+      }
+    } finally {
+      opened.db.close();
+      await opened.cleanup();
+    }
+  } catch {
+    return ids;
+  }
+  return ids;
+}
+async function collectCursorTranscriptFiles(root, skipSessionIds) {
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const filePath of await listJsonlFiles(root)) {
+    if (!isCursorTranscriptPath(filePath) && path13.basename(path13.dirname(filePath)) !== "agent-transcripts") {
+      continue;
+    }
+    const sessionId = path13.basename(filePath, ".jsonl");
+    if (!sessionId || seen.has(sessionId) || skipSessionIds?.has(sessionId)) {
+      continue;
+    }
+    seen.add(sessionId);
+    const info = await stat7(filePath).catch(() => null);
+    if (!info) {
+      continue;
+    }
+    files.push({ path: filePath, modifiedAt: info.mtime.toISOString() });
+  }
+  return files;
+}
+async function parseCursorSessionFile(filePath, options) {
+  const base = path13.basename(filePath);
+  if (base.endsWith(".jsonl")) {
+    return parseCursorTranscriptFile(filePath, options);
+  }
+  if (base === "store.db") {
+    return [];
+  }
+  if (base !== "state.vscdb" && !base.endsWith(".vscdb") && !base.endsWith(".db")) {
+    return [];
+  }
+  const opened = await openCursorDb(filePath);
+  const events = [];
+  const sourcePathHash = `sha256:${createStableHash(filePath)}`;
+  try {
+    const composers = listComposers(opened.db);
+    for (const composer of composers) {
+      events.push(...parseComposer(opened.db, composer, filePath, sourcePathHash, options));
+    }
+  } finally {
+    opened.db.close();
+    await opened.cleanup();
+  }
+  return events;
+}
+function parseComposer(db, composer, filePath, sourcePathHash, options) {
+  const sessionId = composer.composerId;
+  const data = composer.data;
+  const { cwd, project } = workspaceFromComposer(data);
+  const model = modelFromComposer(data);
+  const workspaceId = createWorkspaceId({ projectName: project, repoRoot: cwd });
+  const startedAt = timestampFrom(composer.createdAt) || timestampFrom(data.createdAt);
+  const endedAt = timestampFrom(composer.lastUpdatedAt) || timestampFrom(data.lastUpdatedAt) || startedAt;
+  if (!startedAt) {
+    return [];
+  }
+  const bubbles = loadBubbles(db, sessionId);
+  const events = [];
+  let lineNumber = 0;
+  let currentTurnId;
+  let currentTurnStartedAt;
+  let turnIndex = 0;
+  let hasFileLineData = false;
+  const push = (partial, topType) => {
+    lineNumber += 1;
+    const event = {
+      schemaVersion: AGENT_TIME_SCHEMA_VERSION,
+      source: SOURCE_ID,
+      agent: AGENT_NAME,
+      workspaceId,
+      project,
+      cwd,
+      model,
+      sessionId,
+      ...partial
+    };
+    events.push(withBackfillRefs(event, {
+      filePath,
+      sourcePathHash,
+      lineNumber,
+      topType,
+      payloadType: event.type,
+      options
+    }));
+  };
+  push({
+    ts: startedAt,
+    type: "session.started",
+    confidence: "partial",
+    refs: stringRefs({ sourceId: `${sessionId}:started` })
+  }, "composer");
+  for (const bubble of bubbles) {
+    const ts = bubbleTs(bubble, startedAt);
+    if (!ts) {
+      continue;
+    }
+    const bubbleId = stringField(bubble, "bubbleId") || `bubble_${lineNumber}`;
+    const bubbleType = numberField(bubble, "type");
+    const capabilityType = numberField(bubble, "capabilityType");
+    const toolFormer = objectField(bubble, "toolFormerData");
+    const bubbleModel = stringField(objectField(bubble, "modelInfo"), "modelName") || model;
+    if (bubbleType === BUBBLE_USER) {
+      if (currentTurnId && currentTurnStartedAt) {
+        push({
+          ts,
+          type: "turn.completed",
+          turnId: currentTurnId,
+          model: bubbleModel,
+          success: true,
+          confidence: "derived",
+          metrics: { durationMs: durationMsBetween(currentTurnStartedAt, ts) },
+          refs: stringRefs({ sourceId: `${sessionId}:${currentTurnId}:completed` })
+        }, "bubble");
+      }
+      turnIndex += 1;
+      currentTurnId = `turn_${turnIndex}`;
+      currentTurnStartedAt = ts;
+      const text = stringField(bubble, "text") || "";
+      push({
+        ts,
+        type: "turn.started",
+        turnId: currentTurnId,
+        model: bubbleModel,
+        confidence: "partial",
+        refs: stringRefs({ sourceId: `${sessionId}:${currentTurnId}:started` })
+      }, "bubble");
+      if (text) {
+        push({
+          ts,
+          type: "prompt.submitted",
+          turnId: currentTurnId,
+          model: bubbleModel,
+          confidence: "partial",
+          metrics: { prompts: 1, promptChars: text.length },
+          refs: stringRefs({
+            sourceId: `${sessionId}:${cleanId(bubbleId)}:prompt`,
+            promptHash: `sha256:${createStableHash(text)}`
+          })
+        }, "bubble");
+      }
+      continue;
+    }
+    if (capabilityType === CAPABILITY_TOOL && Object.keys(toolFormer).length > 0) {
+      const rawName = stringField(toolFormer, "name") || "unknown";
+      const tool = toolNameOf(rawName);
+      const toolCallId = cleanId(
+        stringField(toolFormer, "toolCallId") || `${sessionId}:${cleanId(bubbleId)}`
+      );
+      const status = (stringField(toolFormer, "status") || "completed").toLowerCase();
+      const success = status !== "error" && status !== "failed" && status !== "cancelled";
+      const input = parseMaybeJsonObject(toolFormer.rawArgs);
+      const params = parseMaybeJsonObject(toolFormer.params);
+      const mergedInput = { ...params, ...input };
+      const fileActivities = fileActivitiesFromCursorTool(tool, mergedInput, ts, cwd);
+      if (fileActivities.some((file) => (file.linesAdded || 0) > 0 || (file.linesRemoved || 0) > 0)) {
+        hasFileLineData = true;
+      }
+      push({
+        ts,
+        type: "tool.started",
+        turnId: currentTurnId,
+        tool,
+        operation: `${tool} started`,
+        model: bubbleModel,
+        confidence: "exact",
+        fileActivities: fileActivities.length > 0 ? fileActivities : void 0,
+        refs: stringRefs({ sourceId: `${toolCallId}:started` })
+      }, "tool");
+      push({
+        ts,
+        type: success ? "tool.completed" : "tool.failed",
+        turnId: currentTurnId,
+        tool,
+        operation: `${tool} completed`,
+        success,
+        model: bubbleModel,
+        confidence: "exact",
+        metrics: { toolCalls: 1 },
+        refs: stringRefs({ sourceId: `${toolCallId}:completed` })
+      }, "tool");
+      if (isShellTool(tool)) {
+        const command = stringField(mergedInput, "command") || stringField(mergedInput, "cmd");
+        if (command) {
+          push({
+            ts,
+            type: "command.started",
+            turnId: currentTurnId,
+            tool,
+            operation: "command started",
+            confidence: "derived",
+            refs: stringRefs({
+              sourceId: `${toolCallId}:command:started`,
+              commandHash: `sha256:${createStableHash(command)}`
+            })
+          }, "tool");
+          push({
+            ts,
+            type: success ? "command.completed" : "command.failed",
+            turnId: currentTurnId,
+            tool,
+            operation: "command completed",
+            success,
+            confidence: "derived",
+            metrics: { commandCalls: 1 },
+            refs: stringRefs({ sourceId: `${toolCallId}:command:completed` })
+          }, "tool");
+        }
+      }
+    }
+    const metrics = usageMetrics(objectField(bubble, "tokenCount"));
+    if (metrics) {
+      push({
+        ts,
+        type: "model.usage",
+        turnId: currentTurnId,
+        model: bubbleModel,
+        confidence: "partial",
+        metrics,
+        refs: stringRefs({ sourceId: `${sessionId}:${cleanId(bubbleId)}:usage` })
+      }, "bubble");
+    }
+  }
+  if (currentTurnId && endedAt) {
+    push({
+      ts: endedAt,
+      type: "turn.completed",
+      turnId: currentTurnId,
+      success: true,
+      confidence: "derived",
+      metrics: { durationMs: durationMsBetween(currentTurnStartedAt, endedAt) },
+      refs: stringRefs({ sourceId: `${sessionId}:${currentTurnId}:completed` })
+    }, "bubble");
+  }
+  const linesAdded = numberField(data, "totalLinesAdded");
+  const linesRemoved = numberField(data, "totalLinesRemoved");
+  if (!hasFileLineData && endedAt && ((linesAdded || 0) > 0 || (linesRemoved || 0) > 0)) {
+    push({
+      ts: endedAt,
+      type: "file.changed",
+      confidence: "partial",
+      metrics: {
+        linesAdded: linesAdded || void 0,
+        linesRemoved: linesRemoved || void 0
+      },
+      refs: stringRefs({ sourceId: `${sessionId}:lines` })
+    }, "composer");
+  }
+  if (endedAt) {
+    push({
+      ts: endedAt,
+      type: "session.ended",
+      confidence: "derived",
+      refs: stringRefs({ sourceId: `${sessionId}:ended` })
+    }, "composer");
+  }
+  return events;
+}
+async function cursorBackfillFiles(sourceRoot, home = os6.homedir(), env) {
+  if (sourceRoot) {
+    const info = await stat7(sourceRoot).catch(() => null);
+    if (!info) {
+      return [];
+    }
+    if (info.isDirectory()) {
+      const files2 = [];
+      for (const dbPath of await listFilesByExtensions(sourceRoot, [".vscdb", ".db"])) {
+        const base = path13.basename(dbPath);
+        if (base === "store.db" || base !== "state.vscdb" && !base.endsWith(".vscdb")) {
+          continue;
+        }
+        const dbInfo = await stat7(dbPath).catch(() => null);
+        if (dbInfo) {
+          files2.push({ path: dbPath, modifiedAt: dbInfo.mtime.toISOString() });
+        }
+      }
+      const skipIds2 = /* @__PURE__ */ new Set();
+      for (const file of files2) {
+        for (const id of await listCursorComposerIds(file.path)) {
+          skipIds2.add(id);
+        }
+      }
+      files2.push(...await collectCursorTranscriptFiles(sourceRoot, skipIds2));
+      return files2;
+    }
+    if (path13.basename(sourceRoot) === "store.db") {
+      return [];
+    }
+    return [{ path: sourceRoot, modifiedAt: info.mtime.toISOString() }];
+  }
+  const files = [];
+  const skipIds = /* @__PURE__ */ new Set();
+  for (const candidatePath of cursorStateDbCandidates(home, env)) {
+    const info = await stat7(candidatePath).catch(() => null);
+    if (!info) {
       continue;
     }
-    const eventsPath = path12.join(sessionDir, entry, "events.jsonl");
-    const info = await stat6(eventsPath).catch(() => null);
-    if (info) {
-      results.push({ path: eventsPath, modifiedAt: info.mtime.toISOString() });
+    files.push({ path: candidatePath, modifiedAt: info.mtime.toISOString() });
+    for (const id of await listCursorComposerIds(candidatePath)) {
+      skipIds.add(id);
     }
+    break;
   }
-  return results;
-}
-function copilotPluginContent() {
-  return `// Agent Time plugin for GitHub Copilot CLI
-// Generated by vibetime.
-// Copilot does not support hooks \u2014 this file is a placeholder for detection.
-// Backfill reads session data from ~/.copilot/session-state/*/events.jsonl.
-`;
+  files.push(...await collectCursorTranscriptFiles(cursorProjectsDir(home, env), skipIds));
+  return files;
 }
-function copilotHome(home, env) {
-  const override = env?.COPILOT_HOME;
-  if (override && override.trim()) {
-    return path12.resolve(override);
+function cursorHookConfig() {
+  const entry = { command: HOOK_COMMAND, timeout: HOOK_TIMEOUT_SECONDS };
+  const hooks = {};
+  for (const event of CURSOR_HOOK_EVENTS) {
+    hooks[event] = [entry];
   }
-  return path12.join(home, ".copilot");
+  return { version: 1, hooks };
 }
-function createCopilotAdapter() {
+function createCursorAdapter() {
   return {
-    id: "copilot",
-    label: "GitHub Copilot",
-    agentName: "copilot",
-    kind: "agent",
+    id: SOURCE_ID,
+    label: "Cursor",
+    agentName: AGENT_NAME,
+    kind: "ide",
     detectPath(home, env) {
-      return copilotHome(home, env);
+      return cursorHome(home, env);
     },
     installedPath(home, env) {
-      return path12.join(copilotHome(home, env), ".vibetime");
+      return cursorHooksPath(home, env);
     },
     async isInstalled(home, env) {
-      try {
-        const { pathExists: pathExists2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-        return await pathExists2(path12.join(copilotHome(home, env), ".vibetime"));
-      } catch {
-        return false;
-      }
+      const config = await readJsonIfExists(cursorHooksPath(home, env));
+      return hasCursorHookCommand(config, HOOK_COMMAND);
     },
     installEntries(home, env) {
       return [{
-        kind: "file",
-        path: path12.join(copilotHome(home, env), ".vibetime"),
-        content: copilotPluginContent()
+        kind: "cursor-hooks-json",
+        path: cursorHooksPath(home, env),
+        content: cursorHookConfig()
       }];
     },
     sourcePaths(home, env) {
-      return [path12.join(copilotHome(home, env), "session-state")];
+      return [
+        ...cursorStateDbCandidates(home, env),
+        cursorProjectsDir(home, env),
+        cursorChatsDir(home, env)
+      ];
     },
-    parseSessionFile: parseCopilotSessionFile
+    parseSessionFile: parseCursorSessionFile
   };
 }
 
 // src/adapters/grok-build.ts
-import { readdir as readdir6, readFile as readFile8, stat as stat7 } from "node:fs/promises";
-import path13 from "node:path";
+import { readdir as readdir7, readFile as readFile9, stat as stat8 } from "node:fs/promises";
+import path14 from "node:path";
 init_fs();
 var GROK_COST_TICKS_PER_USD = 1e9;
-var SOURCE_ID = "grok-build";
-var AGENT_NAME = "grok-build";
-var HOOK_COMMAND = `vibetime hook --agent ${SOURCE_ID}`;
+var SOURCE_ID2 = "grok-build";
+var AGENT_NAME2 = "grok-build";
+var HOOK_COMMAND2 = `vibetime hook --agent ${SOURCE_ID2}`;
 function grokHome(home, env) {
   const override = env?.GROK_HOME;
   if (override && override.trim()) {
-    return path13.resolve(override);
+    return path14.resolve(override);
   }
-  return path13.join(home, ".grok");
+  return path14.join(home, ".grok");
 }
 function grokHooksPath(home, env) {
-  return path13.join(grokHome(home, env), "hooks", "vibetime.json");
+  return path14.join(grokHome(home, env), "hooks", "vibetime.json");
 }
 function grokSessionsDir(home, env) {
-  return path13.join(grokHome(home, env), "sessions");
+  return path14.join(grokHome(home, env), "sessions");
 }
 async function grokBackfillFiles(sourceRoot, home, env) {
   const root = sourceRoot || grokSessionsDir(home, env);
@@ -6264,12 +7470,12 @@ async function grokBackfillFiles(sourceRoot, home, env) {
   async function walk(dir) {
     let entries;
     try {
-      entries = await readdir6(dir, { withFileTypes: true });
+      entries = await readdir7(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const entryPath = path13.join(dir, entry.name);
+      const entryPath = path14.join(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(entryPath);
         continue;
@@ -6278,7 +7484,7 @@ async function grokBackfillFiles(sourceRoot, home, env) {
         continue;
       }
       try {
-        const info = await stat7(entryPath);
+        const info = await stat8(entryPath);
         files.push({ path: entryPath, modifiedAt: info.mtime.toISOString() });
       } catch {
       }
@@ -6292,18 +7498,18 @@ async function parseGrokSessionFile(filePath, options) {
   if (!sessionDir) {
     return [];
   }
-  const summaryPath = path13.join(sessionDir, "summary.json");
-  const eventsPath = path13.join(sessionDir, "events.jsonl");
-  const signalsPath = path13.join(sessionDir, "signals.json");
-  const updatesPath = path13.join(sessionDir, "updates.jsonl");
+  const summaryPath = path14.join(sessionDir, "summary.json");
+  const eventsPath = path14.join(sessionDir, "events.jsonl");
+  const signalsPath = path14.join(sessionDir, "signals.json");
+  const updatesPath = path14.join(sessionDir, "updates.jsonl");
   const summary = await readJsonIfExists(summaryPath);
   if (!isPlainObject(summary)) {
     return [];
   }
   const info = objectField(summary, "info");
-  const sessionId = stringField(info, "id") || path13.basename(sessionDir);
+  const sessionId = stringField(info, "id") || path14.basename(sessionDir);
   const cwd = stringField(info, "cwd");
-  const project = cwd ? path13.basename(cwd) : void 0;
+  const project = cwd ? path14.basename(cwd) : void 0;
   const workspaceId = createWorkspaceId({ projectName: project, repoRoot: cwd });
   const model = stringField(summary, "current_model_id");
   const createdAt = timestampFrom(summary.created_at) || timestampFrom(summary.createdAt);
@@ -6330,8 +7536,8 @@ async function parseGrokSessionFile(filePath, options) {
   };
   const base = (partial) => ({
     schemaVersion: AGENT_TIME_SCHEMA_VERSION,
-    source: SOURCE_ID,
-    agent: AGENT_NAME,
+    source: SOURCE_ID2,
+    agent: AGENT_NAME2,
     workspaceId,
     project,
     cwd,
@@ -6351,7 +7557,7 @@ async function parseGrokSessionFile(filePath, options) {
   const pendingTools = /* @__PURE__ */ new Map();
   let eventsText = "";
   try {
-    eventsText = await readFile8(eventsPath, "utf8");
+    eventsText = await readFile9(eventsPath, "utf8");
   } catch {
   }
   const lines = eventsText.split("\n").filter(Boolean);
@@ -6429,7 +7635,7 @@ async function parseGrokSessionFile(filePath, options) {
         fileActivities: fileActivities.length > 0 ? fileActivities : void 0,
         refs: stringRefs({ sourceId: `${toolId}:started` })
       }), lineNumber, type, "tool.started");
-      if (isShellTool(toolName)) {
+      if (isShellTool2(toolName)) {
         const command = stringField(knownInput?.input || {}, "command");
         if (command) {
           push(base({
@@ -6470,7 +7676,7 @@ async function parseGrokSessionFile(filePath, options) {
         },
         refs: stringRefs({ sourceId: `${toolId}:completed` })
       }), lineNumber, type, "tool.completed");
-      if (isShellTool(pending?.name || toolName)) {
+      if (isShellTool2(pending?.name || toolName)) {
         push(base({
           ts,
           type: success ? "command.completed" : "command.failed",
@@ -6527,7 +7733,7 @@ async function parseGrokSessionFile(filePath, options) {
       nextLine += 1;
     }
   }
-  const hunkPath = path13.join(sessionDir, "hunk_records.jsonl");
+  const hunkPath = path14.join(sessionDir, "hunk_records.jsonl");
   const hunkActivities = await loadHunkFileActivities(hunkPath, cwd);
   if (hunkActivities.length > 0) {
     for (const event of events) {
@@ -6591,9 +7797,9 @@ async function parseGrokSessionFile(filePath, options) {
   return events;
 }
 function resolveSessionDir(filePath) {
-  const base = path13.basename(filePath);
+  const base = path14.basename(filePath);
   if (base === "summary.json" || base === "events.jsonl" || base === "signals.json") {
-    return path13.dirname(filePath);
+    return path14.dirname(filePath);
   }
   if (/^[0-9a-f]{8}-[0-9a-f-]{27,}$/i.test(base)) {
     return filePath;
@@ -6616,7 +7822,7 @@ function findPendingToolId(pending, toolName) {
   }
   return void 0;
 }
-function isShellTool(name) {
+function isShellTool2(name) {
   if (!name) {
     return false;
   }
@@ -6625,7 +7831,7 @@ function isShellTool(name) {
 }
 function fileActivitiesFromTool(toolName, input, ts, cwd) {
   const lower = toolName.toLowerCase();
-  if (isShellTool(toolName)) {
+  if (isShellTool2(toolName)) {
     const command = stringField(input, "command");
     if (command) {
       return fileActivitiesFromShellCommand(command, ts, cwd, cwd);
@@ -6679,17 +7885,17 @@ function fileActivitiesFromTool(toolName, input, ts, cwd) {
   return [];
 }
 function displayPath(filePath, cwd) {
-  if (!cwd || !path13.isAbsolute(filePath)) {
+  if (!cwd || !path14.isAbsolute(filePath)) {
     return filePath;
   }
-  const relative = path13.relative(cwd, filePath);
-  return relative && !relative.startsWith("..") && !path13.isAbsolute(relative) ? relative : filePath;
+  const relative = path14.relative(cwd, filePath);
+  return relative && !relative.startsWith("..") && !path14.isAbsolute(relative) ? relative : filePath;
 }
 async function loadToolInputsFromUpdates(updatesPath) {
   const map = /* @__PURE__ */ new Map();
   let text = "";
   try {
-    text = await readFile8(updatesPath, "utf8");
+    text = await readFile9(updatesPath, "utf8");
   } catch {
     return map;
   }
@@ -6760,7 +7966,7 @@ async function loadTurnUsagesFromUpdates(updatesPath) {
   const turns = [];
   let text = "";
   try {
-    text = await readFile8(updatesPath, "utf8");
+    text = await readFile9(updatesPath, "utf8");
   } catch {
     return turns;
   }
@@ -6849,7 +8055,7 @@ async function loadHunkFileActivities(hunkPath, cwd) {
   const activities = [];
   let text = "";
   try {
-    text = await readFile8(hunkPath, "utf8");
+    text = await readFile9(hunkPath, "utf8");
   } catch {
     return activities;
   }
@@ -6891,7 +8097,7 @@ async function loadHunkFileActivities(hunkPath, cwd) {
   }
   return activities;
 }
-var grokHandler = (msg) => hookHandler(SOURCE_ID, msg);
+var grokHandler = (msg) => hookHandler(SOURCE_ID2, msg);
 function hookConfig5() {
   const anyTool = [{ matcher: ".*", hooks: [grokHandler("Reporting tool activity")] }];
   return {
@@ -6913,9 +8119,9 @@ function hookConfig5() {
 }
 function createGrokBuildAdapter() {
   return {
-    id: SOURCE_ID,
+    id: SOURCE_ID2,
     label: "Grok Build",
-    agentName: AGENT_NAME,
+    agentName: AGENT_NAME2,
     kind: "agent",
     detectPath(home, env) {
       return grokHome(home, env);
@@ -6924,7 +8130,7 @@ function createGrokBuildAdapter() {
       return grokHooksPath(home, env);
     },
     async isInstalled(home, env) {
-      return isHooksJsonInstalled(grokHooksPath(home, env), HOOK_COMMAND);
+      return isHooksJsonInstalled(grokHooksPath(home, env), HOOK_COMMAND2);
     },
     installEntries(home, env) {
       return [{
@@ -6941,8 +8147,8 @@ function createGrokBuildAdapter() {
 }
 
 // src/adapters/kimi-code.ts
-import { readFile as readFile9 } from "node:fs/promises";
-import path14 from "node:path";
+import { readFile as readFile10 } from "node:fs/promises";
+import path15 from "node:path";
 
 // src/lib/toml-hooks.ts
 init_fs();
@@ -7089,20 +8295,20 @@ function tomlNumberField(body, key) {
 }
 
 // src/adapters/kimi-code.ts
-var HOOK_COMMAND2 = "vibetime hook --agent kimi-code";
-var HOOK_TIMEOUT_SECONDS = 10;
+var HOOK_COMMAND3 = "vibetime hook --agent kimi-code";
+var HOOK_TIMEOUT_SECONDS2 = 10;
 function kimiCodeHome(home, env) {
   const override = env?.KIMI_CODE_HOME || env?.KIMI_HOME;
   if (override && override.trim()) {
-    return path14.resolve(override);
+    return path15.resolve(override);
   }
-  return path14.join(home, ".kimi-code");
+  return path15.join(home, ".kimi-code");
 }
 function kimiCodeSessionsDir(home, env) {
-  return path14.join(kimiCodeHome(home, env), "sessions");
+  return path15.join(kimiCodeHome(home, env), "sessions");
 }
 function kimiCodeConfigPath(home, env) {
-  return path14.join(kimiCodeHome(home, env), "config.toml");
+  return path15.join(kimiCodeHome(home, env), "config.toml");
 }
 function kimiHookRules() {
   const events = [
@@ -7119,8 +8325,8 @@ function kimiHookRules() {
   ];
   return events.map((event) => ({
     event,
-    command: HOOK_COMMAND2,
-    timeout: HOOK_TIMEOUT_SECONDS
+    command: HOOK_COMMAND3,
+    timeout: HOOK_TIMEOUT_SECONDS2
   }));
 }
 function baseKimiEvent(event) {
@@ -7179,10 +8385,10 @@ function sessionIdFromWirePath(filePath) {
   return match?.[1];
 }
 async function readSessionState(filePath) {
-  const sessionDir = path14.dirname(path14.dirname(path14.dirname(filePath)));
-  const statePath = path14.join(sessionDir, "state.json");
+  const sessionDir = path15.dirname(path15.dirname(path15.dirname(filePath)));
+  const statePath = path15.join(sessionDir, "state.json");
   try {
-    const text = await readFile9(statePath, "utf8");
+    const text = await readFile10(statePath, "utf8");
     const raw = JSON.parse(text);
     if (!isPlainObject(raw)) {
       return {};
@@ -7197,15 +8403,15 @@ async function readSessionState(filePath) {
   }
 }
 async function parseKimiCodeSessionFile(filePath, options) {
-  if (path14.basename(filePath) !== "wire.jsonl") {
+  if (path15.basename(filePath) !== "wire.jsonl") {
     return [];
   }
-  const text = await readFile9(filePath, "utf8");
+  const text = await readFile10(filePath, "utf8");
   const lines = text.split("\n").filter(Boolean);
   const stateMeta = await readSessionState(filePath);
   let sessionId = stateMeta.sessionId || sessionIdFromWirePath(filePath);
   let cwd = stateMeta.cwd;
-  let project = cwd ? path14.basename(cwd) : void 0;
+  let project = cwd ? path15.basename(cwd) : void 0;
   let model;
   let provider;
   let reasoningEffort;
@@ -7251,7 +8457,7 @@ async function parseKimiCodeSessionFile(filePath, options) {
       const disclosedCwd = stringField(disclosure, "cwd");
       if (disclosedCwd) {
         cwd = disclosedCwd;
-        project = path14.basename(disclosedCwd);
+        project = path15.basename(disclosedCwd);
       }
       continue;
     }
@@ -7565,7 +8771,7 @@ function createKimiCodeAdapter() {
       return kimiCodeConfigPath(home, env);
     },
     async isInstalled(home, env) {
-      return hasTomlHookCommand(kimiCodeConfigPath(home, env), HOOK_COMMAND2);
+      return hasTomlHookCommand(kimiCodeConfigPath(home, env), HOOK_COMMAND3);
     },
     installEntries(home, env) {
       return [{
@@ -7582,8 +8788,8 @@ function createKimiCodeAdapter() {
 }
 
 // src/adapters/opencode.ts
-import os6 from "node:os";
-import path15 from "node:path";
+import os7 from "node:os";
+import path16 from "node:path";
 async function parseOpenCodeSessionFile(dbPath, options) {
   const { DatabaseSync } = await import("node:sqlite");
   if (!dbPath.endsWith(".db")) {
@@ -7642,7 +8848,7 @@ async function parseOpenCodeSessionFile(dbPath, options) {
       const isSubagent = sessionId !== rawSessionId;
       const sessionEventStart = events.length;
       const cwd = session.directory || session.path || void 0;
-      const project = cwd ? path15.basename(cwd) : void 0;
+      const project = cwd ? path16.basename(cwd) : void 0;
       const sessionTs = msToIso(session.time_created);
       events.push(baseOpenCodeEvent({
         ts: sessionTs,
@@ -7750,7 +8956,7 @@ async function parseOpenCodeSessionFile(dbPath, options) {
           const provider = currentProvider;
           const pathObj = objectField(info, "path");
           const assistantCwd = stringField(pathObj, "cwd") || cwd;
-          const assistantProject = assistantCwd ? path15.basename(assistantCwd) : project;
+          const assistantProject = assistantCwd ? path16.basename(assistantCwd) : project;
           const completedTs = numberField(objectField(info, "time"), "completed");
           const createdTs = timeCreated;
           const tokens = opencodeUsageFromInfo(info);
@@ -8024,33 +9230,33 @@ function opencodeUsageFromInfo(info) {
 function opencodeConfigDir(home, env) {
   const override = env?.OPENCODE_CONFIG_DIR;
   if (override && override.trim()) {
-    return path15.resolve(override);
+    return path16.resolve(override);
   }
   const xdgConfig = env?.XDG_CONFIG_HOME;
   if (xdgConfig && xdgConfig.trim()) {
-    return path15.join(path15.resolve(xdgConfig), "opencode");
+    return path16.join(path16.resolve(xdgConfig), "opencode");
   }
-  return path15.join(home, ".config", "opencode");
+  return path16.join(home, ".config", "opencode");
 }
 function opencodeDataCandidates(home, env) {
   const xdgData = env?.XDG_DATA_HOME;
-  const primary = xdgData && xdgData.trim() ? path15.join(path15.resolve(xdgData), "opencode", "opencode.db") : path15.join(home, ".local", "share", "opencode", "opencode.db");
-  return [primary, path15.join(home, ".opencode", "opencode.db")];
+  const primary = xdgData && xdgData.trim() ? path16.join(path16.resolve(xdgData), "opencode", "opencode.db") : path16.join(home, ".local", "share", "opencode", "opencode.db");
+  return [primary, path16.join(home, ".opencode", "opencode.db")];
 }
-async function opencodeBackfillFiles(sourceRoot, home = os6.homedir(), env) {
-  const { stat: stat15 } = await import("node:fs/promises");
+async function opencodeBackfillFiles(sourceRoot, home = os7.homedir(), env) {
+  const { stat: stat16 } = await import("node:fs/promises");
   if (sourceRoot) {
     if (!sourceRoot.endsWith(".db")) {
       return [];
     }
-    const info = await stat15(sourceRoot).catch(() => null);
+    const info = await stat16(sourceRoot).catch(() => null);
     if (!info) {
       return [];
     }
     return [{ path: sourceRoot, modifiedAt: info.mtime.toISOString() }];
   }
   for (const candidatePath of opencodeDataCandidates(home, env)) {
-    const info = await stat15(candidatePath).catch(() => null);
+    const info = await stat16(candidatePath).catch(() => null);
     if (info) {
       return [{ path: candidatePath, modifiedAt: info.mtime.toISOString() }];
     }
@@ -8125,12 +9331,12 @@ function createOpenCodeAdapter() {
       return opencodeConfigDir(home, env);
     },
     installedPath(home, env) {
-      return path15.join(opencodeConfigDir(home, env), PLUGIN_PATH);
+      return path16.join(opencodeConfigDir(home, env), PLUGIN_PATH);
     },
     async isInstalled(home, env) {
       try {
         const { pathExists: pathExists2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-        return await pathExists2(path15.join(opencodeConfigDir(home, env), PLUGIN_PATH)) || await pathExists2(path15.join(".opencode", PLUGIN_PATH));
+        return await pathExists2(path16.join(opencodeConfigDir(home, env), PLUGIN_PATH)) || await pathExists2(path16.join(".opencode", PLUGIN_PATH));
       } catch {
         return false;
       }
@@ -8138,7 +9344,7 @@ function createOpenCodeAdapter() {
     installEntries(home, env) {
       return [{
         kind: "file",
-        path: path15.join(opencodeConfigDir(home, env), PLUGIN_PATH),
+        path: path16.join(opencodeConfigDir(home, env), PLUGIN_PATH),
         content: opencodePluginContent()
       }];
     },
@@ -8150,14 +9356,37 @@ function createOpenCodeAdapter() {
 }
 
 // src/adapters/pi.ts
-import { readdir as readdir7, readFile as readFile10, stat as stat8 } from "node:fs/promises";
-import os7 from "node:os";
-import path16 from "node:path";
+import { readdir as readdir8, readFile as readFile11, stat as stat9 } from "node:fs/promises";
+import os8 from "node:os";
+import path17 from "node:path";
 init_fs();
+function piHostSessionIdFromBasename(basename) {
+  const withoutExt = basename.endsWith(".jsonl") ? basename.slice(0, -".jsonl".length) : basename;
+  if (!withoutExt || withoutExt === "session") {
+    return void 0;
+  }
+  const underscore = withoutExt.indexOf("_");
+  if (underscore <= 0 || underscore === withoutExt.length - 1) {
+    return withoutExt;
+  }
+  return withoutExt.slice(underscore + 1);
+}
+function resolvePiBackfillGroupId(filePath) {
+  const normalized = filePath.replaceAll("\\", "/");
+  const base = path17.basename(filePath);
+  const nest = normalized.match(/([^/]+)\/[^/]+\/run-\d+\/session\.jsonl$/);
+  if (nest) {
+    return piHostSessionIdFromBasename(nest[1]);
+  }
+  if (base.endsWith(".jsonl") && base !== "session.jsonl") {
+    return piHostSessionIdFromBasename(base);
+  }
+  return void 0;
+}
 function parsePiSubagentLink(filePath, headerParentSession) {
   if (headerParentSession) {
-    const parentFile = path16.isAbsolute(headerParentSession) ? headerParentSession : void 0;
-    const parentSessionId2 = parentFile ? path16.basename(parentFile, ".jsonl") : headerParentSession;
+    const parentFile = path17.isAbsolute(headerParentSession) ? headerParentSession : void 0;
+    const parentSessionId2 = parentFile ? path17.basename(parentFile, ".jsonl") : headerParentSession;
     return { parentSessionId: parentSessionId2, parentSessionFile: parentFile, explicit: true };
   }
   const normalized = filePath.replaceAll("\\", "/");
@@ -8170,20 +9399,20 @@ function parsePiSubagentLink(filePath, headerParentSession) {
     return void 0;
   }
   const parentSessionId = parentBasename.endsWith(".jsonl") ? parentBasename.slice(0, -".jsonl".length) : parentBasename;
-  const parentDir = path16.dirname(path16.dirname(path16.dirname(filePath)));
-  const parentSessionFile = path16.join(path16.dirname(parentDir), `${parentBasename}.jsonl`);
+  const parentDir = path17.dirname(path17.dirname(path17.dirname(filePath)));
+  const parentSessionFile = path17.join(path17.dirname(parentDir), `${parentBasename}.jsonl`);
   return { parentSessionId, parentSessionFile, explicit: false };
 }
 async function resolveParentContext(link, options) {
   if (link.parentSessionFile) {
     try {
-      const text = await readFile10(link.parentSessionFile, "utf8");
+      const text = await readFile11(link.parentSessionFile, "utf8");
       const firstLine = text.split("\n").find((line) => line.trim().length > 0);
       const raw = firstLine ? parseJsonLine(firstLine) : void 0;
       if (raw) {
         const id = stringField(raw, "id");
         const cwd = stringField(raw, "cwd");
-        const project = cwd ? path16.basename(cwd) : void 0;
+        const project = cwd ? path17.basename(cwd) : void 0;
         if (id || cwd || project) {
           return { sessionId: id, cwd, project };
         }
@@ -8232,7 +9461,7 @@ function rebuildEventIdentity2(event) {
   };
 }
 async function parsePiSessionFile(filePath, options) {
-  const text = await readFile10(filePath, "utf8");
+  const text = await readFile11(filePath, "utf8");
   const lines = text.split("\n").filter(Boolean);
   let sessionId;
   let cwd;
@@ -8264,7 +9493,7 @@ async function parsePiSessionFile(filePath, options) {
       sessionId = stringField(raw, "id") || state.sessionId;
       state.sessionId = sessionId || state.sessionId;
       cwd = stringField(raw, "cwd") || cwd;
-      project = cwd ? path16.basename(cwd) : project;
+      project = cwd ? path17.basename(cwd) : project;
       headerParentSession = stringField(raw, "parentSession") || headerParentSession;
       continue;
     }
@@ -8471,7 +9700,7 @@ async function parsePiFile(filePath, options) {
 async function parsePiWorkflowRunFile(filePath, options) {
   let raw;
   try {
-    raw = JSON.parse(await readFile10(filePath, "utf8"));
+    raw = JSON.parse(await readFile11(filePath, "utf8"));
   } catch {
     return [];
   }
@@ -8539,17 +9768,17 @@ async function parsePiWorkflowRunFile(filePath, options) {
   return state.events.filter((event) => matchesBackfillFilters(event, options));
 }
 async function findPiSessionFileById(sessionId, options) {
-  const sessionsDir = piSessionDir(path16.resolve(stringOption(options.home) || os7.homedir()));
+  const sessionsDir = piSessionDir(path17.resolve(stringOption(options.home) || os8.homedir()));
   try {
-    const projectDirs = await readdir7(sessionsDir, { withFileTypes: true });
+    const projectDirs = await readdir8(sessionsDir, { withFileTypes: true });
     for (const dir of projectDirs) {
       if (!dir.isDirectory()) {
         continue;
       }
-      const names = await readdir7(path16.join(sessionsDir, dir.name));
+      const names = await readdir8(path17.join(sessionsDir, dir.name));
       const hit = names.find((name) => name.endsWith(`_${sessionId}.jsonl`));
       if (hit) {
-        return path16.join(sessionsDir, dir.name, hit);
+        return path17.join(sessionsDir, dir.name, hit);
       }
     }
   } catch {
@@ -8791,29 +10020,48 @@ export default function (pi: ExtensionAPI) {
 function piAgentDir(home, env) {
   const override = env?.PI_CODING_AGENT_DIR;
   if (override && override.trim()) {
-    return path16.resolve(override);
+    return path17.resolve(override);
   }
-  return path16.join(home, ".pi", "agent");
+  return path17.join(home, ".pi", "agent");
 }
 function piSessionDir(home, env) {
   const override = env?.PI_CODING_AGENT_SESSION_DIR;
   if (override && override.trim()) {
-    return path16.resolve(override);
+    return path17.resolve(override);
   }
-  return path16.join(piAgentDir(home, env), "sessions");
+  return path17.join(piAgentDir(home, env), "sessions");
 }
 function piWorkflowProjectsDir(home) {
-  return path16.join(home, ".pi", "workflows", "projects");
+  return path17.join(home, ".pi", "workflows", "projects");
+}
+async function workflowRunGroupId(filePath) {
+  try {
+    const raw = JSON.parse(await readFile11(filePath, "utf8"));
+    if (!isPlainObject(raw)) {
+      return void 0;
+    }
+    return stringField(raw, "sessionId");
+  } catch {
+    return void 0;
+  }
 }
-async function piBackfillFiles(sourceRoot, home = os7.homedir(), env) {
+async function piBackfillFiles(sourceRoot, home = os8.homedir(), env) {
   const lists = sourceRoot ? [await listFilesByExtensions(sourceRoot, [".jsonl", ".json"])] : await Promise.all([
     listFilesByExtensions(piSessionDir(home, env), [".jsonl"]),
     listFilesByExtensions(piWorkflowProjectsDir(home), [".json"])
   ]);
   const files = lists.flat().sort();
   return Promise.all(files.map(async (filePath) => {
-    const info = await stat8(filePath);
-    return { path: filePath, modifiedAt: info.mtime.toISOString() };
+    const info = await stat9(filePath);
+    let groupId = resolvePiBackfillGroupId(filePath);
+    if (!groupId && filePath.endsWith(".json")) {
+      groupId = await workflowRunGroupId(filePath);
+    }
+    return {
+      path: filePath,
+      modifiedAt: info.mtime.toISOString(),
+      ...groupId ? { groupId } : {}
+    };
   }));
 }
 function createPiAdapter() {
@@ -8826,12 +10074,12 @@ function createPiAdapter() {
       return piAgentDir(home, env);
     },
     installedPath(home, env) {
-      return path16.join(piAgentDir(home, env), "extensions", "vibetime.ts");
+      return path17.join(piAgentDir(home, env), "extensions", "vibetime.ts");
     },
     async isInstalled(home, env) {
       try {
         const { pathExists: pathExists2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-        return await pathExists2(path16.join(piAgentDir(home, env), "extensions", "vibetime.ts"));
+        return await pathExists2(path17.join(piAgentDir(home, env), "extensions", "vibetime.ts"));
       } catch {
         return false;
       }
@@ -8839,7 +10087,7 @@ function createPiAdapter() {
     installEntries(home, env) {
       return [{
         kind: "file",
-        path: path16.join(piAgentDir(home, env), "extensions", "vibetime.ts"),
+        path: path17.join(piAgentDir(home, env), "extensions", "vibetime.ts"),
         content: piExtensionContent()
       }];
     },
@@ -8851,14 +10099,14 @@ function createPiAdapter() {
 }
 
 // src/adapters/qoder-cn.ts
-import { readdir as readdir8, readFile as readFile11, stat as stat9 } from "node:fs/promises";
-import os9 from "node:os";
-import path18 from "node:path";
+import { readdir as readdir9, readFile as readFile12, stat as stat10 } from "node:fs/promises";
+import os10 from "node:os";
+import path19 from "node:path";
 
 // src/adapters/qoder-local-db.ts
 import { access } from "node:fs/promises";
-import os8 from "node:os";
-import path17 from "node:path";
+import os9 from "node:os";
+import path18 from "node:path";
 function takeQoderDbModelCall(calls, requestId, blockStart) {
   if (requestId) {
     const call = calls.byRequestId.get(requestId)?.shift();
@@ -8875,14 +10123,14 @@ function takeQoderDbModelCall(calls, requestId, blockStart) {
   }
   return calls.ordered.shift();
 }
-function appDataRoot(appDirName, home = os8.homedir()) {
+function appDataRoot(appDirName, home = os9.homedir()) {
   if (process.platform === "darwin") {
-    return path17.join(home, "Library", "Application Support", appDirName);
+    return path18.join(home, "Library", "Application Support", appDirName);
   }
   if (process.platform === "win32") {
-    return path17.join(process.env.APPDATA || path17.join(home, "AppData", "Roaming"), appDirName);
+    return path18.join(process.env.APPDATA || path18.join(home, "AppData", "Roaming"), appDirName);
   }
-  return path17.join(home, ".config", appDirName);
+  return path18.join(home, ".config", appDirName);
 }
 function qoderLocalDbCandidates(appDirName) {
   const candidates = [];
@@ -8892,8 +10140,8 @@ function qoderLocalDbCandidates(appDirName) {
   }
   const configRoot = appDataRoot(appDirName);
   candidates.push(
-    path17.join(configRoot, "SharedClientCache", "cache", "db", "local.db"),
-    path17.join(configRoot, "SharedClientCache", "db", "local.db")
+    path18.join(configRoot, "SharedClientCache", "cache", "db", "local.db"),
+    path18.join(configRoot, "SharedClientCache", "db", "local.db")
   );
   return candidates;
 }
@@ -8902,7 +10150,7 @@ async function loadQoderIdeModelCatalog(appDirName, home) {
   try {
     const { DatabaseSync } = await import("node:sqlite");
     const db = new DatabaseSync(
-      path17.join(appDataRoot(appDirName, home), "User", "globalStorage", "state.vscdb"),
+      path18.join(appDataRoot(appDirName, home), "User", "globalStorage", "state.vscdb"),
       { readOnly: true }
     );
     try {
@@ -9044,7 +10292,7 @@ function resolveSessionPreferredModel(db, sessionId, modelMap) {
 
 // src/adapters/qoder-cn.ts
 function parseQoderCnPaths(filePath) {
-  const parts = filePath.split(path18.sep);
+  const parts = filePath.split(path19.sep);
   const subagentsIdx = parts.lastIndexOf("subagents");
   let sessionId = "";
   let projectName = "";
@@ -9054,17 +10302,17 @@ function parseQoderCnPaths(filePath) {
     sessionId = parts[subagentsIdx - 1];
     projectName = parts[subagentsIdx - 2];
     const projectsIdx = parts.lastIndexOf("projects");
-    configDir2 = parts.slice(0, projectsIdx).join(path18.sep);
-    mainTranscriptPath = [...parts.slice(0, subagentsIdx - 1), `${sessionId}.jsonl`].join(path18.sep);
+    configDir2 = parts.slice(0, projectsIdx).join(path19.sep);
+    mainTranscriptPath = [...parts.slice(0, subagentsIdx - 1), `${sessionId}.jsonl`].join(path19.sep);
   } else {
     const filename = parts.at(-1) || "";
-    sessionId = path18.basename(filename, ".jsonl");
+    sessionId = path19.basename(filename, ".jsonl");
     projectName = parts.at(-2) || "";
     if (projectName === "transcript") {
       projectName = parts.at(-3) || "";
     }
     const projectsIdx = parts.lastIndexOf("projects");
-    configDir2 = parts.slice(0, projectsIdx).join(path18.sep);
+    configDir2 = parts.slice(0, projectsIdx).join(path19.sep);
   }
   return { configDir: configDir2, projectName, sessionId, mainTranscriptPath };
 }
@@ -9087,7 +10335,7 @@ function rebuildEventIdentity3(event) {
 }
 async function parseModelNamesFromDynamicTexts(dynamicTextsPath) {
   try {
-    const content = await readFile11(dynamicTextsPath, "utf8");
+    const content = await readFile12(dynamicTextsPath, "utf8");
     const json = JSON.parse(content);
     const texts = json.texts || {};
     const map = {};
@@ -9103,10 +10351,10 @@ async function parseModelNamesFromDynamicTexts(dynamicTextsPath) {
   }
 }
 async function loadQoderCnModelNames(configDir2, home) {
-  const map = await parseModelNamesFromDynamicTexts(path18.join(configDir2, ".auth", "dynamic-texts.json"));
+  const map = await parseModelNamesFromDynamicTexts(path19.join(configDir2, ".auth", "dynamic-texts.json"));
   const siblingConfigDir = configDir2.replace(/\.qoder-cn$/, ".qoder");
   if (siblingConfigDir !== configDir2) {
-    const siblingMap = await parseModelNamesFromDynamicTexts(path18.join(siblingConfigDir, ".auth", "dynamic-texts.json"));
+    const siblingMap = await parseModelNamesFromDynamicTexts(path19.join(siblingConfigDir, ".auth", "dynamic-texts.json"));
     for (const [key, val] of Object.entries(siblingMap)) {
       if (!(key in map)) {
         map[key] = val;
@@ -9125,15 +10373,15 @@ async function loadQoderCnModelNames(configDir2, home) {
 }
 async function loadQoderCnSegmentModelCalls(filePath, isSubagentSession, modelMap) {
   const { configDir: configDir2, projectName, sessionId } = parseQoderCnPaths(filePath);
-  const segmentsPath = path18.join(configDir2, "logs", "sessions", projectName, sessionId, "segments");
+  const segmentsPath = path19.join(configDir2, "logs", "sessions", projectName, sessionId, "segments");
   const modelCalls = [];
   try {
-    const files = await readdir8(segmentsPath);
+    const files = await readdir9(segmentsPath);
     for (const file of files) {
       if (!file.endsWith(".jsonl")) {
         continue;
       }
-      const content = await readFile11(path18.join(segmentsPath, file), "utf8");
+      const content = await readFile12(path19.join(segmentsPath, file), "utf8");
       let currentTurnIsSubagent = false;
       for (const line of content.split("\n").filter(Boolean)) {
         const raw = parseJsonLine(line);
@@ -9167,7 +10415,7 @@ async function loadQoderCnSegmentModelCalls(filePath, isSubagentSession, modelMa
   return modelCalls.filter((call) => call.isSubagent === isSubagentSession);
 }
 async function parseQoderCnSessionFile(filePath, options) {
-  const text = await readFile11(filePath, "utf8");
+  const text = await readFile12(filePath, "utf8");
   const lines = text.split("\n").filter(Boolean);
   const parsedPaths = parseQoderCnPaths(filePath);
   const { configDir: configDir2 } = parsedPaths;
@@ -9178,7 +10426,7 @@ async function parseQoderCnSessionFile(filePath, options) {
   let cwd;
   let project = projectContext.project;
   let model;
-  const home = path18.resolve(stringOption(options.home) || os9.homedir());
+  const home = path19.resolve(stringOption(options.home) || os10.homedir());
   const modelMap = await loadQoderCnModelNames(configDir2, home);
   const isSubagentSession = filePath.includes("subagents");
   const segmentModelCalls = await loadQoderCnSegmentModelCalls(filePath, isSubagentSession, modelMap);
@@ -9213,7 +10461,7 @@ async function parseQoderCnSessionFile(filePath, options) {
     sessionId = stringField(raw, "sessionId") || sessionId;
     state.sessionId = sessionId;
     cwd = stringField(raw, "cwd") || cwd;
-    project = projectContext.project || (cwd ? path18.basename(cwd) : project || await qoderCnProjectFromFilePath(filePath, options));
+    project = projectContext.project || (cwd ? path19.basename(cwd) : project || await qoderCnProjectFromFilePath(filePath, options));
     if (!ts) {
       continue;
     }
@@ -9532,10 +10780,11 @@ async function parseQoderCnSessionFile(filePath, options) {
     const { sessionId: parentSessionId, mainTranscriptPath } = parseQoderCnPaths(filePath);
     if (parentSessionId && mainTranscriptPath) {
       const parentSourcePathHash = `sha256:${createStableHash(mainTranscriptPath)}`;
-      return validEvents.map((event) => {
+      return withoutSubagentTurnEvents(validEvents).map((event) => {
         const mapped = {
           ...event,
           sessionId: parentSessionId,
+          turnId: void 0,
           refs: {
             ...event.refs,
             sourcePathHash: parentSourcePathHash,
@@ -9548,11 +10797,12 @@ async function parseQoderCnSessionFile(filePath, options) {
   }
   dbModelCalls ??= await loadQoderDbModelCalls("QoderCN", parsedPaths.sessionId, modelMap);
   if (dbModelCalls.rootSessionId) {
-    const parentPath = path18.join(path18.dirname(filePath), `${dbModelCalls.rootSessionId}.jsonl`);
+    const parentPath = path19.join(path19.dirname(filePath), `${dbModelCalls.rootSessionId}.jsonl`);
     const parentSourcePathHash = `sha256:${createStableHash(parentPath)}`;
-    return validEvents.map((event) => rebuildEventIdentity3({
+    return withoutSubagentTurnEvents(validEvents).map((event) => rebuildEventIdentity3({
       ...event,
       sessionId: dbModelCalls.rootSessionId,
+      turnId: void 0,
       refs: {
         ...event.refs,
         sourcePathHash: parentSourcePathHash,
@@ -9700,28 +10950,28 @@ function extractQoderAttachedPrompt(content) {
 }
 async function qoderCnProjectContextFromLines(filePath, lines, options, configDir2) {
   const { projectName: projectDir, sessionId } = parseQoderCnPaths(filePath);
-  const isSubagent = filePath.includes(`${path18.sep}subagents${path18.sep}`);
+  const isSubagent = filePath.includes(`${path19.sep}subagents${path19.sep}`);
   const inherited = isSubagent ? await readPersistedSessionContextFromOptions(options, sessionId) : void 0;
   let cwds = [];
   for (const line of lines) {
     const raw = parseJsonLine(line);
     const cwd = raw ? stringField(raw, "cwd") : void 0;
-    if (cwd && path18.isAbsolute(cwd)) {
+    if (cwd && path19.isAbsolute(cwd)) {
       cwds.push(cwd);
     }
   }
   if (isSubagent) {
-    if (inherited?.cwd && path18.isAbsolute(inherited.cwd)) {
+    if (inherited?.cwd && path19.isAbsolute(inherited.cwd)) {
       cwds = [inherited.cwd];
     } else {
-      const parentSessionPath = path18.join(configDir2, "projects", projectDir, `${sessionId}.jsonl`);
+      const parentSessionPath = path19.join(configDir2, "projects", projectDir, `${sessionId}.jsonl`);
       try {
-        const parentText = await readFile11(parentSessionPath, "utf8");
+        const parentText = await readFile12(parentSessionPath, "utf8");
         const parentCwds = [];
         for (const line of parentText.split("\n").filter(Boolean)) {
           const raw = parseJsonLine(line);
           const cwd = raw ? stringField(raw, "cwd") : void 0;
-          if (cwd && path18.isAbsolute(cwd)) {
+          if (cwd && path19.isAbsolute(cwd)) {
             parentCwds.push(cwd);
           }
         }
@@ -9733,7 +10983,7 @@ async function qoderCnProjectContextFromLines(filePath, lines, options, configDi
     }
   }
   const root = await gitRootFromCwds2(cwds) || qoderCnProjectRootFromCwds(projectDir, cwds);
-  const project = inherited?.project || (cwds.length > 0 ? path18.basename(cwds[0]) : root ? path18.basename(root) : await qoderCnProjectFromFilePath(filePath, options));
+  const project = inherited?.project || (cwds.length > 0 ? path19.basename(cwds[0]) : root ? path19.basename(root) : await qoderCnProjectFromFilePath(filePath, options));
   return {
     project,
     workspaceId: createWorkspaceId({ projectName: project, repoRoot: root })
@@ -9742,15 +10992,15 @@ async function qoderCnProjectContextFromLines(filePath, lines, options, configDi
 async function gitRootFromCwds2(cwds) {
   const seen = /* @__PURE__ */ new Set();
   for (const cwd of cwds) {
-    let current = path18.resolve(cwd);
+    let current = path19.resolve(cwd);
     while (!seen.has(current)) {
       seen.add(current);
       try {
-        await stat9(path18.join(current, ".git"));
+        await stat10(path19.join(current, ".git"));
         return current;
       } catch {
       }
-      const parent = path18.dirname(current);
+      const parent = path19.dirname(current);
       if (parent === current) {
         break;
       }
@@ -9761,12 +11011,12 @@ async function gitRootFromCwds2(cwds) {
 }
 function qoderCnProjectRootFromCwds(projectDir, cwds) {
   for (const cwd of cwds) {
-    let current = path18.resolve(cwd);
+    let current = path19.resolve(cwd);
     while (true) {
       if (encodeQoderCnProjectPath(current) === projectDir) {
         return current;
       }
-      const parent = path18.dirname(current);
+      const parent = path19.dirname(current);
       if (parent === current) {
         break;
       }
@@ -9776,14 +11026,14 @@ function qoderCnProjectRootFromCwds(projectDir, cwds) {
   return void 0;
 }
 function encodeQoderCnProjectPath(value) {
-  return path18.resolve(value).split(path18.sep).join("-").replaceAll("_", "-");
+  return path19.resolve(value).split(path19.sep).join("-").replaceAll("_", "-");
 }
 async function qoderCnProjectFromFilePath(filePath, options) {
-  const projectDir = path18.basename(path18.dirname(filePath));
-  const home = options ? path18.resolve(stringOption(options.home) || os9.homedir()) : os9.homedir();
+  const projectDir = path19.basename(path19.dirname(filePath));
+  const home = options ? path19.resolve(stringOption(options.home) || os10.homedir()) : os10.homedir();
   const resolved = await resolveQoderCnProjectPath(projectDir, home);
   if (resolved) {
-    return path18.basename(resolved);
+    return path19.basename(resolved);
   }
   const homePrefix = `${encodeQoderCnProjectPath(home)}-`;
   if (projectDir.startsWith(homePrefix)) {
@@ -9803,12 +11053,12 @@ async function resolveQoderCnProjectPath(projectDir, home) {
   while (projectDir.startsWith(`${currentEncoded}-`)) {
     let matchedChild;
     try {
-      const entries = await readdir8(current, { withFileTypes: true });
+      const entries = await readdir9(current, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) {
           continue;
         }
-        const candidate = path18.join(current, entry.name);
+        const candidate = path19.join(current, entry.name);
         const encoded = encodeQoderCnProjectPath(candidate);
         if (encoded === projectDir) {
           return candidate;
@@ -9853,9 +11103,9 @@ function hookConfig6() {
 function qoderCnConfigDir(home, env) {
   const override = env?.QODER_CN_CONFIG_DIR;
   if (override && override.trim()) {
-    return path18.resolve(override);
+    return path19.resolve(override);
   }
-  return path18.join(home, ".qoder-cn");
+  return path19.join(home, ".qoder-cn");
 }
 function createQoderCnAdapter() {
   return {
@@ -9867,27 +11117,27 @@ function createQoderCnAdapter() {
       return qoderCnConfigDir(home, env);
     },
     installedPath(home, env) {
-      return path18.join(qoderCnConfigDir(home, env), "settings.json");
+      return path19.join(qoderCnConfigDir(home, env), "settings.json");
     },
     async isInstalled(home, env) {
       return isHooksJsonInstalled(
-        path18.join(qoderCnConfigDir(home, env), "settings.json"),
+        path19.join(qoderCnConfigDir(home, env), "settings.json"),
         "vibetime hook --agent qoder-cn"
       );
     },
     installEntries(home, env) {
       return [{
         kind: "hooks-json",
-        path: path18.join(qoderCnConfigDir(home, env), "settings.json"),
+        path: path19.join(qoderCnConfigDir(home, env), "settings.json"),
         content: hookConfig6()
       }];
     },
     sourcePaths(home, env) {
       const base = qoderCnConfigDir(home, env);
       return [
-        path18.join(base, "projects"),
-        path18.join(base, ".qoder.json"),
-        path18.join(home, ".qoder.json")
+        path19.join(base, "projects"),
+        path19.join(base, ".qoder.json"),
+        path19.join(home, ".qoder.json")
       ];
     },
     parseSessionFile: parseQoderCnSessionFile
@@ -9896,11 +11146,11 @@ function createQoderCnAdapter() {
 
 // src/adapters/qoder.ts
 import { existsSync } from "node:fs";
-import { readdir as readdir9, readFile as readFile12, stat as stat10 } from "node:fs/promises";
-import os10 from "node:os";
-import path19 from "node:path";
+import { readdir as readdir10, readFile as readFile13, stat as stat11 } from "node:fs/promises";
+import os11 from "node:os";
+import path20 from "node:path";
 function parseQoderPaths(filePath) {
-  const parts = filePath.split(path19.sep);
+  const parts = filePath.split(path20.sep);
   const subagentsIdx = parts.lastIndexOf("subagents");
   let sessionId = "";
   let projectName = "";
@@ -9910,17 +11160,17 @@ function parseQoderPaths(filePath) {
     sessionId = parts[subagentsIdx - 1];
     projectName = parts[subagentsIdx - 2];
     const projectsIdx = parts.lastIndexOf("projects");
-    configDir2 = parts.slice(0, projectsIdx).join(path19.sep);
-    mainTranscriptPath = [...parts.slice(0, subagentsIdx - 1), `${sessionId}.jsonl`].join(path19.sep);
+    configDir2 = parts.slice(0, projectsIdx).join(path20.sep);
+    mainTranscriptPath = [...parts.slice(0, subagentsIdx - 1), `${sessionId}.jsonl`].join(path20.sep);
   } else {
     const filename = parts.at(-1) || "";
-    sessionId = path19.basename(filename, ".jsonl");
+    sessionId = path20.basename(filename, ".jsonl");
     projectName = parts.at(-2) || "";
     if (projectName === "transcript") {
       projectName = parts.at(-3) || "";
     }
     const projectsIdx = parts.lastIndexOf("projects");
-    configDir2 = parts.slice(0, projectsIdx).join(path19.sep);
+    configDir2 = parts.slice(0, projectsIdx).join(path20.sep);
   }
   return { configDir: configDir2, projectName, sessionId, mainTranscriptPath };
 }
@@ -9943,7 +11193,7 @@ function rebuildEventIdentity4(event) {
 }
 async function parseModelNamesFromDynamicTexts2(dynamicTextsPath) {
   try {
-    const content = await readFile12(dynamicTextsPath, "utf8");
+    const content = await readFile13(dynamicTextsPath, "utf8");
     const json = JSON.parse(content);
     const texts = json.texts || {};
     const map = {};
@@ -9959,10 +11209,10 @@ async function parseModelNamesFromDynamicTexts2(dynamicTextsPath) {
   }
 }
 async function loadQoderModelNames(configDir2, home) {
-  const map = await parseModelNamesFromDynamicTexts2(path19.join(configDir2, ".auth", "dynamic-texts.json"));
+  const map = await parseModelNamesFromDynamicTexts2(path20.join(configDir2, ".auth", "dynamic-texts.json"));
   const siblingConfigDir = configDir2.replace(/\.qoder$/, ".qoder-cn");
   if (siblingConfigDir !== configDir2) {
-    const siblingMap = await parseModelNamesFromDynamicTexts2(path19.join(siblingConfigDir, ".auth", "dynamic-texts.json"));
+    const siblingMap = await parseModelNamesFromDynamicTexts2(path20.join(siblingConfigDir, ".auth", "dynamic-texts.json"));
     for (const [key, val] of Object.entries(siblingMap)) {
       if (!(key in map)) {
         map[key] = val;
@@ -9970,11 +11220,11 @@ async function loadQoderModelNames(configDir2, home) {
     }
   }
   if (isQwenworkConfigRoot(configDir2)) {
-    for (const dir of [path19.join(home, ".qoder"), path19.join(home, ".qoder-cn")]) {
-      if (path19.resolve(dir) === path19.resolve(configDir2)) {
+    for (const dir of [path20.join(home, ".qoder"), path20.join(home, ".qoder-cn")]) {
+      if (path20.resolve(dir) === path20.resolve(configDir2)) {
         continue;
       }
-      const fallbackMap = await parseModelNamesFromDynamicTexts2(path19.join(dir, ".auth", "dynamic-texts.json"));
+      const fallbackMap = await parseModelNamesFromDynamicTexts2(path20.join(dir, ".auth", "dynamic-texts.json"));
       for (const [key, val] of Object.entries(fallbackMap)) {
         if (!(key in map)) {
           map[key] = val;
@@ -9993,25 +11243,25 @@ async function loadQoderModelNames(configDir2, home) {
   return map;
 }
 function isQwenworkConfigRoot(configDir2) {
-  const name = path19.basename(path19.resolve(configDir2));
+  const name = path20.basename(path20.resolve(configDir2));
   if (name === ".qwenworkcn" || name === ".qwenwork") {
     return true;
   }
   const override = process.env.QWENWORK_CONFIG_DIR;
-  return Boolean(override && override.trim() && path19.basename(path19.resolve(override)) === name);
+  return Boolean(override && override.trim() && path20.basename(path20.resolve(override)) === name);
 }
 var FAILED_SEGMENT_STOP_REASONS = /* @__PURE__ */ new Set(["cancelled", "canceled", "error", "failed", "refusal"]);
 async function loadQoderSegmentModelCalls(filePath, isSubagentSession, modelMap) {
   const { configDir: configDir2, projectName, sessionId } = parseQoderPaths(filePath);
-  const segmentsPath = path19.join(configDir2, "logs", "sessions", projectName, sessionId, "segments");
+  const segmentsPath = path20.join(configDir2, "logs", "sessions", projectName, sessionId, "segments");
   const modelCalls = [];
   try {
-    const files = await readdir9(segmentsPath);
+    const files = await readdir10(segmentsPath);
     for (const file of files) {
       if (!file.endsWith(".jsonl")) {
         continue;
       }
-      const content = await readFile12(path19.join(segmentsPath, file), "utf8");
+      const content = await readFile13(path20.join(segmentsPath, file), "utf8");
       let currentTurnIsSubagent = false;
       for (const line of content.split("\n").filter(Boolean)) {
         const raw = parseJsonLine(line);
@@ -10045,7 +11295,7 @@ async function loadQoderSegmentModelCalls(filePath, isSubagentSession, modelMap)
   return modelCalls.filter((call) => call.isSubagent === isSubagentSession);
 }
 async function parseQoderSessionFile(filePath, options) {
-  const text = await readFile12(filePath, "utf8");
+  const text = await readFile13(filePath, "utf8");
   const lines = text.split("\n").filter(Boolean);
   const parsedPaths = parseQoderPaths(filePath);
   const { configDir: configDir2 } = parsedPaths;
@@ -10056,7 +11306,7 @@ async function parseQoderSessionFile(filePath, options) {
   let cwd;
   let project = projectContext.project;
   let model;
-  const home = path19.resolve(stringOption(options.home) || os10.homedir());
+  const home = path20.resolve(stringOption(options.home) || os11.homedir());
   const modelMap = await loadQoderModelNames(configDir2, home);
   const qwenworkRoot = isQwenworkConfigRoot(configDir2);
   const isSubagentSession = filePath.includes("subagents");
@@ -10092,7 +11342,7 @@ async function parseQoderSessionFile(filePath, options) {
     sessionId = stringField(raw, "sessionId") || sessionId;
     state.sessionId = sessionId;
     cwd = stringField(raw, "cwd") || cwd;
-    project = projectContext.project || (cwd ? path19.basename(cwd) : project || await qoderProjectFromFilePath(filePath, options));
+    project = projectContext.project || (cwd ? path20.basename(cwd) : project || await qoderProjectFromFilePath(filePath, options));
     if (!ts) {
       continue;
     }
@@ -10386,10 +11636,11 @@ async function parseQoderSessionFile(filePath, options) {
     const { sessionId: parentSessionId, mainTranscriptPath } = parseQoderPaths(filePath);
     if (parentSessionId && mainTranscriptPath) {
       const parentSourcePathHash = `sha256:${createStableHash(mainTranscriptPath)}`;
-      return validEvents.map((event) => {
+      return withoutSubagentTurnEvents(validEvents).map((event) => {
         const mapped = {
           ...event,
           sessionId: parentSessionId,
+          turnId: void 0,
           refs: {
             ...event.refs,
             sourcePathHash: parentSourcePathHash,
@@ -10402,11 +11653,12 @@ async function parseQoderSessionFile(filePath, options) {
   }
   dbModelCalls ??= await loadQoderDbModelCalls("Qoder", parsedPaths.sessionId, modelMap);
   if (dbModelCalls.rootSessionId) {
-    const parentPath = path19.join(path19.dirname(filePath), `${dbModelCalls.rootSessionId}.jsonl`);
+    const parentPath = path20.join(path20.dirname(filePath), `${dbModelCalls.rootSessionId}.jsonl`);
     const parentSourcePathHash = `sha256:${createStableHash(parentPath)}`;
-    return validEvents.map((event) => rebuildEventIdentity4({
+    return withoutSubagentTurnEvents(validEvents).map((event) => rebuildEventIdentity4({
       ...event,
       sessionId: dbModelCalls.rootSessionId,
+      turnId: void 0,
       refs: {
         ...event.refs,
         sourcePathHash: parentSourcePathHash,
@@ -10518,41 +11770,41 @@ function qoderExtractText(value) {
 }
 async function qoderProjectContextFromLines(filePath, lines, options, configDir2) {
   const { projectName: projectDir, sessionId } = parseQoderPaths(filePath);
-  const isSubagent = filePath.includes(`${path19.sep}subagents${path19.sep}`);
+  const isSubagent = filePath.includes(`${path20.sep}subagents${path20.sep}`);
   const inherited = isSubagent ? await readPersistedSessionContextFromOptions(options, sessionId) : void 0;
   let cwds = [];
   const workspaceDirs = [];
   for (const line of lines) {
     const raw = parseJsonLine(line);
     const cwd = raw ? stringField(raw, "cwd") : void 0;
-    if (cwd && path19.isAbsolute(cwd)) {
+    if (cwd && path20.isAbsolute(cwd)) {
       cwds.push(cwd);
     }
     if (raw && stringField(raw, "type") === "workspace-directories") {
       for (const dir of arrayField5(raw, "directories")) {
-        if (typeof dir === "string" && path19.isAbsolute(dir)) {
+        if (typeof dir === "string" && path20.isAbsolute(dir)) {
           workspaceDirs.push(dir);
         }
       }
     }
   }
   if (isSubagent) {
-    if (inherited?.cwd && path19.isAbsolute(inherited.cwd)) {
+    if (inherited?.cwd && path20.isAbsolute(inherited.cwd)) {
       cwds = [inherited.cwd];
     } else {
-      const parentSessionPath = path19.join(configDir2, "projects", projectDir, `${sessionId}.jsonl`);
+      const parentSessionPath = path20.join(configDir2, "projects", projectDir, `${sessionId}.jsonl`);
       try {
-        const parentText = await readFile12(parentSessionPath, "utf8");
+        const parentText = await readFile13(parentSessionPath, "utf8");
         const parentCwds = [];
         for (const line of parentText.split("\n").filter(Boolean)) {
           const raw = parseJsonLine(line);
           const cwd = raw ? stringField(raw, "cwd") : void 0;
-          if (cwd && path19.isAbsolute(cwd)) {
+          if (cwd && path20.isAbsolute(cwd)) {
             parentCwds.push(cwd);
           }
           if (workspaceDirs.length === 0 && raw && stringField(raw, "type") === "workspace-directories") {
             for (const dir of arrayField5(raw, "directories")) {
-              if (typeof dir === "string" && path19.isAbsolute(dir)) {
+              if (typeof dir === "string" && path20.isAbsolute(dir)) {
                 workspaceDirs.push(dir);
               }
             }
@@ -10572,29 +11824,29 @@ async function qoderProjectContextFromLines(filePath, lines, options, configDir2
     }
   }
   const root = await gitRootFromCwds3(cwds) || qoderProjectRootFromCwds(projectDir, cwds);
-  const project = inherited?.project || (cwds.length > 0 ? path19.basename(cwds[0]) : root ? path19.basename(root) : await qoderProjectFromFilePath(filePath, options));
+  const project = inherited?.project || (cwds.length > 0 ? path20.basename(cwds[0]) : root ? path20.basename(root) : await qoderProjectFromFilePath(filePath, options));
   return {
     project,
     workspaceId: createWorkspaceId({ projectName: project, repoRoot: root })
   };
 }
 function pathInsideDir(candidate, dir) {
-  const resolvedDir = path19.resolve(dir);
-  const resolved = path19.resolve(candidate);
-  return resolved === resolvedDir || resolved.startsWith(`${resolvedDir}${path19.sep}`);
+  const resolvedDir = path20.resolve(dir);
+  const resolved = path20.resolve(candidate);
+  return resolved === resolvedDir || resolved.startsWith(`${resolvedDir}${path20.sep}`);
 }
 async function gitRootFromCwds3(cwds) {
   const seen = /* @__PURE__ */ new Set();
   for (const cwd of cwds) {
-    let current = path19.resolve(cwd);
+    let current = path20.resolve(cwd);
     while (!seen.has(current)) {
       seen.add(current);
       try {
-        await stat10(path19.join(current, ".git"));
+        await stat11(path20.join(current, ".git"));
         return current;
       } catch {
       }
-      const parent = path19.dirname(current);
+      const parent = path20.dirname(current);
       if (parent === current) {
         break;
       }
@@ -10605,12 +11857,12 @@ async function gitRootFromCwds3(cwds) {
 }
 function qoderProjectRootFromCwds(projectDir, cwds) {
   for (const cwd of cwds) {
-    let current = path19.resolve(cwd);
+    let current = path20.resolve(cwd);
     while (true) {
       if (qoderEncodedVariants(current).includes(projectDir)) {
         return current;
       }
-      const parent = path19.dirname(current);
+      const parent = path20.dirname(current);
       if (parent === current) {
         break;
       }
@@ -10620,7 +11872,7 @@ function qoderProjectRootFromCwds(projectDir, cwds) {
   return void 0;
 }
 function rawQoderProjectPath(value) {
-  return path19.resolve(value).split(path19.sep).join("-");
+  return path20.resolve(value).split(path20.sep).join("-");
 }
 function qoderEncodedVariants(value) {
   const raw = rawQoderProjectPath(value);
@@ -10641,11 +11893,11 @@ function qoderEncodedProjectSuffix(projectDir, home) {
   return void 0;
 }
 async function qoderProjectFromFilePath(filePath, options) {
-  const projectDir = path19.basename(path19.dirname(filePath));
-  const home = options ? path19.resolve(stringOption(options.home) || os10.homedir()) : os10.homedir();
+  const projectDir = path20.basename(path20.dirname(filePath));
+  const home = options ? path20.resolve(stringOption(options.home) || os11.homedir()) : os11.homedir();
   const resolved = await resolveQoderProjectPath(projectDir, home);
   if (resolved) {
-    return path19.basename(resolved);
+    return path20.basename(resolved);
   }
   const suffix = qoderEncodedProjectSuffix(projectDir, home);
   if (suffix) {
@@ -10666,12 +11918,12 @@ async function resolveQoderProjectPath(projectDir, home) {
   while (currentEncodedVariants.some((prefix) => projectDir.startsWith(`${prefix}-`))) {
     let matchedChild;
     try {
-      const entries = await readdir9(current, { withFileTypes: true });
+      const entries = await readdir10(current, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) {
           continue;
         }
-        const candidate = path19.join(current, entry.name);
+        const candidate = path20.join(current, entry.name);
         const candidateVariants = qoderEncodedVariants(candidate);
         if (candidateVariants.includes(projectDir)) {
           return candidate;
@@ -10716,19 +11968,19 @@ function hookConfig7() {
 function qoderConfigDir(home, env) {
   const override = env?.QODER_CONFIG_DIR;
   if (override && override.trim()) {
-    return path19.resolve(override);
+    return path20.resolve(override);
   }
-  return path19.join(home, ".qoder");
+  return path20.join(home, ".qoder");
 }
 function qwenworkConfigDir(home, env) {
   const override = env?.QWENWORK_CONFIG_DIR;
   if (override && override.trim()) {
-    return path19.resolve(override);
+    return path20.resolve(override);
   }
-  return path19.join(home, ".qwenworkcn");
+  return path20.join(home, ".qwenworkcn");
 }
 function qoderConfigDirs(home, env) {
-  return [...new Set([qoderConfigDir(home, env), qwenworkConfigDir(home, env)].map((dir) => path19.resolve(dir)))];
+  return [...new Set([qoderConfigDir(home, env), qwenworkConfigDir(home, env)].map((dir) => path20.resolve(dir)))];
 }
 function createQoderAdapter() {
   return {
@@ -10740,11 +11992,11 @@ function createQoderAdapter() {
       return qoderConfigDir(home, env);
     },
     installedPath(home, env) {
-      return path19.join(qoderConfigDir(home, env), "settings.json");
+      return path20.join(qoderConfigDir(home, env), "settings.json");
     },
     async isInstalled(home, env) {
       return isHooksJsonInstalled(
-        path19.join(qoderConfigDir(home, env), "settings.json"),
+        path20.join(qoderConfigDir(home, env), "settings.json"),
         "vibetime hook --agent qoder"
       );
     },
@@ -10753,16 +12005,16 @@ function createQoderAdapter() {
       const targets = [primary, ...variants.filter((dir) => existsSync(dir))];
       return targets.map((base) => ({
         kind: "hooks-json",
-        path: path19.join(base, "settings.json"),
+        path: path20.join(base, "settings.json"),
         content: hookConfig7()
       }));
     },
     sourcePaths(home, env) {
-      const paths = qoderConfigDirs(home, env).map((base2) => path19.join(base2, "projects"));
+      const paths = qoderConfigDirs(home, env).map((base2) => path20.join(base2, "projects"));
       const base = qoderConfigDir(home, env);
       paths.push(
-        path19.join(base, ".qoder.json"),
-        path19.join(home, ".qoder.json")
+        path20.join(base, ".qoder.json"),
+        path20.join(home, ".qoder.json")
       );
       return paths;
     },
@@ -10798,27 +12050,27 @@ function normalizeId(id) {
 }
 
 // src/adapters/workbuddy.ts
-import { readdir as readdir10, readFile as readFile13, stat as stat11 } from "node:fs/promises";
-import path20 from "node:path";
+import { readdir as readdir11, readFile as readFile14, stat as stat12 } from "node:fs/promises";
+import path21 from "node:path";
 function workbuddyProjectsDir(home, env) {
   const override = env?.WORKBUDDY_PROJECTS_DIR || env?.WORKBUDDY_HOME;
   if (override && override.trim()) {
-    return path20.resolve(override, override.endsWith("projects") ? "" : "projects");
+    return path21.resolve(override, override.endsWith("projects") ? "" : "projects");
   }
-  return path20.join(home, ".workbuddy", "projects");
+  return path21.join(home, ".workbuddy", "projects");
 }
 function workbuddyBaseDir(home, env) {
   const override = env?.WORKBUDDY_HOME;
   if (override && override.trim()) {
-    return path20.resolve(override);
+    return path21.resolve(override);
   }
-  return path20.join(home, ".workbuddy");
+  return path21.join(home, ".workbuddy");
 }
 function projectFromCwd(cwd, fallback) {
   if (!cwd) {
     return fallback;
   }
-  return path20.basename(cwd) || fallback;
+  return path21.basename(cwd) || fallback;
 }
 function sourceHash(filePath) {
   return `sha256:${createStableHash(filePath)}`;
@@ -10936,7 +12188,7 @@ function toolCallFailed(record) {
   return status === "failed" || status === "incomplete" || record.is_error === true || providerData.error != null || providerData.isError === true;
 }
 async function readWorkbuddyLines(filePath) {
-  const text = await readFile13(filePath, "utf8");
+  const text = await readFile14(filePath, "utf8");
   return text.split(/\r?\n/).map((line, index) => {
     if (!line.trim()) {
       return void 0;
@@ -10956,8 +12208,8 @@ async function parseWorkbuddySessionFile(filePath, options) {
   }
   const events = [];
   const first = lines[0].record;
-  const sessionId = stringField(first, "sessionId") || path20.basename(filePath, ".jsonl");
-  const fallbackProject = path20.basename(path20.dirname(filePath));
+  const sessionId = stringField(first, "sessionId") || path21.basename(filePath, ".jsonl");
+  const fallbackProject = path21.basename(path21.dirname(filePath));
   const cwd = lines.map((line) => stringField(line.record, "cwd")).find(Boolean);
   const project = projectFromCwd(cwd, fallbackProject);
   const workspaceId = createWorkspaceId({ projectName: project, repoRoot: cwd });
@@ -11241,17 +12493,17 @@ async function workbuddyBackfillFiles(sourceRoot, home, env) {
   const base = sourceRoot || workbuddyProjectsDir(home, env);
   const files = [];
   try {
-    const projects = await readdir10(base, { withFileTypes: true });
+    const projects = await readdir11(base, { withFileTypes: true });
     for (const project of projects) {
       if (!project.isDirectory()) {
         continue;
       }
-      const projectDir = path20.join(base, project.name);
-      const entries = await readdir10(projectDir, { withFileTypes: true });
+      const projectDir = path21.join(base, project.name);
+      const entries = await readdir11(projectDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isFile() && entry.name.endsWith(".jsonl")) {
-          const filePath = path20.join(projectDir, entry.name);
-          const info = await stat11(filePath);
+          const filePath = path21.join(projectDir, entry.name);
+          const info = await stat12(filePath);
           files.push({ path: filePath, modifiedAt: info.mtime.toISOString() });
         }
       }
@@ -11288,18 +12540,18 @@ function createWorkbuddyAdapter() {
       return workbuddyProjectsDir(home, env);
     },
     installedPath(home, env) {
-      return path20.join(workbuddyBaseDir(home, env), "settings.json");
+      return path21.join(workbuddyBaseDir(home, env), "settings.json");
     },
     async isInstalled(home, env) {
       return isHooksJsonInstalled(
-        path20.join(workbuddyBaseDir(home, env), "settings.json"),
+        path21.join(workbuddyBaseDir(home, env), "settings.json"),
         "vibetime hook --agent workbuddy"
       );
     },
     installEntries(home, env) {
       return [{
         kind: "hooks-json",
-        path: path20.join(workbuddyBaseDir(home, env), "settings.json"),
+        path: path21.join(workbuddyBaseDir(home, env), "settings.json"),
         content: hookConfig8()
       }];
     },
@@ -11312,26 +12564,26 @@ function createWorkbuddyAdapter() {
 
 // src/adapters/zcode.ts
 import { execFile } from "node:child_process";
-import { readFile as readFile14, stat as stat12 } from "node:fs/promises";
-import path21 from "node:path";
+import { readFile as readFile15, stat as stat13 } from "node:fs/promises";
+import path22 from "node:path";
 import { promisify as promisify2 } from "node:util";
 init_fs();
 var execFileAsync = promisify2(execFile);
 function zcodeCliDir(home, env) {
   const override = env?.ZCODE_CLI_DIR || env?.ZCODE_HOME;
   if (override && override.trim()) {
-    return path21.resolve(override, override.endsWith("cli") ? "" : "cli");
+    return path22.resolve(override, override.endsWith("cli") ? "" : "cli");
   }
-  return path21.join(home, ".zcode", "cli");
+  return path22.join(home, ".zcode", "cli");
 }
 function zcodeDbPath(home, env) {
-  return path21.join(zcodeCliDir(home, env), "db", "db.sqlite");
+  return path22.join(zcodeCliDir(home, env), "db", "db.sqlite");
 }
 var providerNameCache = null;
 async function loadProviderNames(configPath2) {
   let fileMtime = 0;
   try {
-    const info = await stat12(configPath2);
+    const info = await stat13(configPath2);
     fileMtime = info.mtimeMs;
   } catch {
     return /* @__PURE__ */ new Map();
@@ -11341,7 +12593,7 @@ async function loadProviderNames(configPath2) {
   }
   const map = /* @__PURE__ */ new Map();
   try {
-    const raw = await readFile14(configPath2, "utf-8");
+    const raw = await readFile15(configPath2, "utf-8");
     const config = JSON.parse(raw);
     const providers = config?.provider;
     if (isPlainObject(providers)) {
@@ -11359,7 +12611,7 @@ function sourceHash2(filePath) {
   return `sha256:${createStableHash(filePath)}`;
 }
 function projectFromDirectory(directory) {
-  return directory ? path21.basename(directory) || "zcode" : "zcode";
+  return directory ? path22.basename(directory) || "zcode" : "zcode";
 }
 function isoFromMs(value) {
   return timestampFrom(typeof value === "number" ? value : Number(value));
@@ -11543,16 +12795,16 @@ async function parseZCodeDb(filePath, options) {
   if (rows.length === 0) {
     return [];
   }
-  let candidate = path21.resolve(filePath);
+  let candidate = path22.resolve(filePath);
   let configPath2 = "";
   for (let i = 0; i < 12; i++) {
-    const probe = path21.join(candidate, ".zcode", "v2", "config.json");
+    const probe = path22.join(candidate, ".zcode", "v2", "config.json");
     try {
-      await stat12(probe);
+      await stat13(probe);
       configPath2 = probe;
       break;
     } catch {
-      const parent = path21.dirname(candidate);
+      const parent = path22.dirname(candidate);
       if (parent === candidate) break;
       candidate = parent;
     }
@@ -11772,9 +13024,9 @@ async function parseZCodeDb(filePath, options) {
 }
 async function zcodeBackfillFiles(sourceRoot, home, env) {
   const candidate = sourceRoot || zcodeDbPath(home, env);
-  const filePath = candidate.endsWith(".sqlite") ? candidate : path21.join(candidate, "db", "db.sqlite");
+  const filePath = candidate.endsWith(".sqlite") ? candidate : path22.join(candidate, "db", "db.sqlite");
   try {
-    const info = await stat12(filePath);
+    const info = await stat13(filePath);
     return [{ path: filePath, modifiedAt: info.mtime.toISOString() }];
   } catch {
     return [];
@@ -11806,50 +13058,50 @@ function createZCodeAdapter() {
 }
 
 // src/adapters/zed.ts
-import os11 from "node:os";
-import path22 from "node:path";
+import os12 from "node:os";
+import path23 from "node:path";
 function zedThreadsCandidates(home, env) {
   const candidates = [];
   const platform2 = process.platform;
   if (platform2 === "darwin") {
-    candidates.push(path22.join(home, "Library", "Application Support", "Zed", "threads", "threads.db"));
+    candidates.push(path23.join(home, "Library", "Application Support", "Zed", "threads", "threads.db"));
   } else if (platform2 === "win32") {
     const appdata = env?.APPDATA;
     if (appdata && appdata.trim()) {
-      candidates.push(path22.join(path22.resolve(appdata), "Zed", "threads", "threads.db"));
+      candidates.push(path23.join(path23.resolve(appdata), "Zed", "threads", "threads.db"));
     }
-    candidates.push(path22.join(home, "AppData", "Roaming", "Zed", "threads", "threads.db"));
+    candidates.push(path23.join(home, "AppData", "Roaming", "Zed", "threads", "threads.db"));
   } else {
     const xdgData = env?.XDG_DATA_HOME;
     if (xdgData && xdgData.trim()) {
-      candidates.push(path22.join(path22.resolve(xdgData), "zed", "threads", "threads.db"));
+      candidates.push(path23.join(path23.resolve(xdgData), "zed", "threads", "threads.db"));
     }
-    candidates.push(path22.join(home, ".local", "share", "zed", "threads", "threads.db"));
+    candidates.push(path23.join(home, ".local", "share", "zed", "threads", "threads.db"));
     const xdgConfig = env?.XDG_CONFIG_HOME;
     if (xdgConfig && xdgConfig.trim()) {
-      candidates.push(path22.join(path22.resolve(xdgConfig), "zed", "threads", "threads.db"));
+      candidates.push(path23.join(path23.resolve(xdgConfig), "zed", "threads", "threads.db"));
     }
-    candidates.push(path22.join(home, ".config", "zed", "threads", "threads.db"));
+    candidates.push(path23.join(home, ".config", "zed", "threads", "threads.db"));
   }
   return candidates;
 }
 function zedConfigDir(home, env) {
   const platform2 = process.platform;
   if (platform2 === "darwin") {
-    return path22.join(home, "Library", "Application Support", "Zed");
+    return path23.join(home, "Library", "Application Support", "Zed");
   }
   if (platform2 === "win32") {
     const appdata = env?.APPDATA;
     if (appdata && appdata.trim()) {
-      return path22.join(path22.resolve(appdata), "Zed");
+      return path23.join(path23.resolve(appdata), "Zed");
     }
-    return path22.join(home, "AppData", "Roaming", "Zed");
+    return path23.join(home, "AppData", "Roaming", "Zed");
   }
   const xdgConfig = env?.XDG_CONFIG_HOME;
   if (xdgConfig && xdgConfig.trim()) {
-    return path22.join(path22.resolve(xdgConfig), "zed");
+    return path23.join(path23.resolve(xdgConfig), "zed");
   }
-  return path22.join(home, ".config", "zed");
+  return path23.join(home, ".config", "zed");
 }
 function baseZedEvent(event) {
   return {
@@ -11913,7 +13165,7 @@ async function parseZedSessionFile(dbPath, options) {
       const folderRaw = row.folder_paths || "";
       const folder = folderRaw.split(/[\n,]/).map((s) => s.trim()).find(Boolean);
       const cwd = folder || void 0;
-      const project = cwd ? path22.basename(cwd) : row.summary ? row.summary.slice(0, 40) : void 0;
+      const project = cwd ? path23.basename(cwd) : row.summary ? row.summary.slice(0, 40) : void 0;
       let json;
       try {
         const bytes = row.data_type === "zstd" ? decompress2(new Uint8Array(row.data)) : new Uint8Array(row.data);
@@ -12158,20 +13410,20 @@ async function parseZedSessionFile(dbPath, options) {
   }
   return events.filter((event) => matchesBackfillFilters(event, options));
 }
-async function zedBackfillFiles(sourceRoot, home = os11.homedir(), env) {
-  const { stat: stat15 } = await import("node:fs/promises");
+async function zedBackfillFiles(sourceRoot, home = os12.homedir(), env) {
+  const { stat: stat16 } = await import("node:fs/promises");
   if (sourceRoot) {
     if (!sourceRoot.endsWith(".db")) {
       return [];
     }
-    const info = await stat15(sourceRoot).catch(() => null);
+    const info = await stat16(sourceRoot).catch(() => null);
     if (!info) {
       return [];
     }
     return [{ path: sourceRoot, modifiedAt: info.mtime.toISOString() }];
   }
   for (const candidatePath of zedThreadsCandidates(home, env)) {
-    const info = await stat15(candidatePath).catch(() => null);
+    const info = await stat16(candidatePath).catch(() => null);
     if (info) {
       return [{ path: candidatePath, modifiedAt: info.mtime.toISOString() }];
     }
@@ -12188,7 +13440,7 @@ function createZedAdapter() {
       return zedConfigDir(home, env);
     },
     installedPath(home, env) {
-      return path22.join(zedConfigDir(home, env), "vibetime-marker");
+      return path23.join(zedConfigDir(home, env), "vibetime-marker");
     },
     async isInstalled() {
       return false;
@@ -12563,6 +13815,10 @@ async function installEntry(entry, options) {
     await mergeHooksJson(entry.path, entry.content, options);
     return;
   }
+  if (entry.kind === "cursor-hooks-json" && typeof entry.content === "object") {
+    await mergeCursorHooksFile(entry.path, entry.content, options);
+    return;
+  }
   if (entry.kind === "hooks-toml" && typeof entry.content === "object") {
     await mergeHooksToml(entry.path, entry.content, options);
     return;
@@ -12577,6 +13833,10 @@ async function uninstallEntry(entry, options) {
     await uninstallHooksToml(entry.path, entry.content, options);
     return;
   }
+  if (entry.kind === "cursor-hooks-json" && typeof entry.content === "object") {
+    await uninstallCursorHooksFile(entry.path, entry.content, options);
+    return;
+  }
   if (entry.kind === "hooks-json" && typeof entry.content === "object") {
     await uninstallHooksJson(entry.path, entry.content, options);
     return;
@@ -12609,6 +13869,67 @@ async function mergeHooksJson(filePath, content, { dryRun, force, onWrite }) {
   await writeFile5(filePath, nextText, "utf8");
   onWrite(`Installed ${filePath}`);
 }
+async function mergeCursorHooksFile(filePath, content, { dryRun, force, onWrite }) {
+  const { mkdir: mkdir6, writeFile: writeFile5 } = await import("node:fs/promises");
+  const pathMod = await import("node:path");
+  if (dryRun) {
+    onWrite(`Would merge ${filePath}`);
+    return;
+  }
+  const existingText = await readTextIfExists(filePath);
+  const existing = existingText ? JSON.parse(existingText) : {};
+  if (existingText !== null && !isPlainObject(existing) && !force) {
+    throw new Error(
+      `Refusing to update non-object JSON file: ${filePath}. Re-run with --force if this is intentional.`
+    );
+  }
+  const merged = mergeCursorHooksJson(existing, content);
+  const nextText = `${JSON.stringify(merged, null, 2)}
+`;
+  if (existingText === nextText) {
+    onWrite(`Already installed ${filePath}`);
+    return;
+  }
+  await mkdir6(pathMod.dirname(filePath), { recursive: true });
+  await writeFile5(filePath, nextText, "utf8");
+  onWrite(`Installed ${filePath}`);
+}
+async function uninstallCursorHooksFile(filePath, content, { dryRun, onWrite }) {
+  const existingText = await readTextIfExists(filePath);
+  if (existingText === null) {
+    onWrite(`Already uninstalled ${filePath}`);
+    return;
+  }
+  let existing;
+  try {
+    existing = JSON.parse(existingText);
+  } catch {
+    onWrite(`Skipped non-JSON file ${filePath}`);
+    return;
+  }
+  if (!isPlainObject(existing)) {
+    onWrite(`Skipped non-object JSON file ${filePath}`);
+    return;
+  }
+  const commands = new Set(collectCursorHookCommands(content));
+  if (commands.size === 0) {
+    onWrite(`Already uninstalled ${filePath}`);
+    return;
+  }
+  const { next, changed } = stripCursorHookCommands(existing, commands);
+  if (!changed) {
+    onWrite(`Already uninstalled ${filePath}`);
+    return;
+  }
+  if (dryRun) {
+    onWrite(`Would uninstall ${filePath}`);
+    return;
+  }
+  const { writeFile: writeFile5 } = await import("node:fs/promises");
+  await writeFile5(filePath, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+  onWrite(`Uninstalled ${filePath}`);
+}
 function mergeAgyHooksJson(existing, addition) {
   const merged = structuredClone(isPlainObject(existing) ? existing : {});
   const additionObject = isPlainObject(addition) ? addition : {};
@@ -12896,15 +14217,15 @@ async function uninstallGeneratedFile(filePath, { dryRun, onWrite }) {
 import { randomUUID } from "node:crypto";
 import { existsSync as existsSync2, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { homedir, hostname } from "node:os";
-import path23 from "node:path";
+import path24 from "node:path";
 function configDir(home = homedir()) {
-  return path23.join(home, ".vibetime");
+  return path24.join(home, ".vibetime");
 }
 function configPath(home = homedir()) {
-  return path23.join(configDir(home), "config.json");
+  return path24.join(configDir(home), "config.json");
 }
 function machineIdPath(home = homedir()) {
-  return path23.join(configDir(home), "machine-id");
+  return path24.join(configDir(home), "machine-id");
 }
 function readConfig(home = homedir()) {
   const file = configPath(home);
@@ -12951,15 +14272,15 @@ function defaultMachineName() {
 init_fs();
 
 // src/lib/logger.ts
-import { appendFile, mkdir as mkdir4, rename, stat as stat13 } from "node:fs/promises";
+import { appendFile, mkdir as mkdir4, rename, stat as stat14 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import path24 from "node:path";
+import path25 from "node:path";
 var MAX_BYTES = 1 * 1024 * 1024;
 function logDir(home = homedir2()) {
-  return path24.join(home, ".vibetime", "logs");
+  return path25.join(home, ".vibetime", "logs");
 }
 function logPath(home = homedir2(), name = "cli.log") {
-  return path24.join(logDir(home), name);
+  return path25.join(logDir(home), name);
 }
 function serializeError(error) {
   if (error instanceof Error) {
@@ -12969,7 +14290,7 @@ function serializeError(error) {
 }
 async function rotateIfNeeded(file) {
   try {
-    const info = await stat13(file);
+    const info = await stat14(file);
     if (info.size > MAX_BYTES) {
       await rename(file, `${file}.1`).catch(() => {
       });
@@ -13134,8 +14455,8 @@ function buildHeaders(token, machine) {
     ...machine?.platform ? { "x-machine-platform": machine.platform } : {}
   };
 }
-function joinUrl(base, path26) {
-  return new URL(path26, base.endsWith("/") ? base : `${base}/`).toString();
+function joinUrl(base, path27) {
+  return new URL(path27, base.endsWith("/") ? base : `${base}/`).toString();
 }
 async function postRollupBatch(remote, rollups, options = {}) {
   const response = await remote.fetchImpl(joinUrl(remote.baseUrl, "/v3/agent/ingest"), {
@@ -13205,7 +14526,7 @@ async function deleteMachine(remote, id) {
 }
 
 // src/lib/types.ts
-var BACKFILL_STATE_SCHEMA_VERSION = 6;
+var BACKFILL_STATE_SCHEMA_VERSION = 7;
 
 // src/cli.ts
 function createRegistry() {
@@ -13225,6 +14546,7 @@ function createRegistry() {
   registry.register(createGrokBuildAdapter());
   registry.register(createZedAdapter());
   registry.register(createKimiCodeAdapter());
+  registry.register(createCursorAdapter());
   return registry;
 }
 var defaultContext = {
@@ -13782,6 +15104,9 @@ async function listBackfillSourceFiles(source, options, ctx) {
   if (source.id === "zed") {
     return zedBackfillFiles(stringOption(options["source-root"]), resolveHome3(options, ctx), ctx.env);
   }
+  if (source.id === "cursor") {
+    return cursorBackfillFiles(stringOption(options["source-root"]), resolveHome3(options, ctx), ctx.env);
+  }
   if (source.id === "pi") {
     return piBackfillFiles(stringOption(options["source-root"]), resolveHome3(options, ctx), ctx.env);
   }
@@ -13789,7 +15114,7 @@ async function listBackfillSourceFiles(source, options, ctx) {
   const fileLists = await Promise.all(roots.map((r) => listJsonlFiles(r)));
   const files = fileLists.flat().sort().slice(0, numberOption(options.limit) || void 0);
   return Promise.all(files.map(async (filePath) => {
-    const info = await stat14(filePath);
+    const info = await stat15(filePath);
     return { path: filePath, modifiedAt: info.mtime.toISOString() };
   }));
 }
@@ -14121,13 +15446,13 @@ function selectBackfillFilesForImport(files, watermarkTs) {
   return picked;
 }
 function backfillIncrementalStatePath(home) {
-  return path25.join(home, ".vibetime", "backfill-state.json");
+  return path26.join(home, ".vibetime", "backfill-state.json");
 }
 function syncLocalTriggerStatePath(home) {
-  return path25.join(home, ".vibetime", "sync-local-trigger.json");
+  return path26.join(home, ".vibetime", "sync-local-trigger.json");
 }
 function syncLocalTriggerLockPath(home) {
-  return path25.join(home, ".vibetime", "sync-local-trigger.lock");
+  return path26.join(home, ".vibetime", "sync-local-trigger.lock");
 }
 function backfillRemoteKey(baseUrl) {
   try {
@@ -14189,7 +15514,7 @@ async function readBackfillIncrementalStateFile(home, ctx) {
 }
 async function writeBackfillIncrementalStateFile(home, file) {
   const statePath = backfillIncrementalStatePath(home);
-  await mkdir5(path25.dirname(statePath), { recursive: true });
+  await mkdir5(path26.dirname(statePath), { recursive: true });
   await writeFile4(statePath, `${JSON.stringify(file, null, 2)}
 `, "utf8");
 }
@@ -14238,7 +15563,7 @@ async function readSyncLocalTriggerState(statePath) {
   return nextState;
 }
 async function writeSyncLocalTriggerState(statePath, state) {
-  await mkdir5(path25.dirname(statePath), { recursive: true });
+  await mkdir5(path26.dirname(statePath), { recursive: true });
   await writeFile4(statePath, `${JSON.stringify(state, null, 2)}
 `, "utf8");
 }
@@ -14253,12 +15578,12 @@ async function readSyncLocalLock(lockPath) {
   return { pid: lock.pid, startedAt: lock.startedAt };
 }
 async function writeSyncLocalLock(lockPath, lock) {
-  await mkdir5(path25.dirname(lockPath), { recursive: true });
+  await mkdir5(path26.dirname(lockPath), { recursive: true });
   await writeFile4(lockPath, `${JSON.stringify(lock, null, 2)}
 `, "utf8");
 }
 async function acquireSyncLocalLock(lockPath, lock) {
-  await mkdir5(path25.dirname(lockPath), { recursive: true });
+  await mkdir5(path26.dirname(lockPath), { recursive: true });
   try {
     const handle = await open(lockPath, "wx");
     try {
@@ -14338,10 +15663,10 @@ function syncLocalRunnerEntryArgs(cliPath) {
   if (cliPath.endsWith(".ts")) {
     return ["--import", "tsx", cliPath];
   }
-  return [path25.resolve(path25.dirname(cliPath), "../bin/vibetime.mjs")];
+  return [path26.resolve(path26.dirname(cliPath), "../bin/vibetime.mjs")];
 }
 function resolveHome3(options, ctx) {
-  return path25.resolve(stringOption(options.home) || ctx.env.HOME || os12.homedir());
+  return path26.resolve(stringOption(options.home) || ctx.env.HOME || os13.homedir());
 }
 function requestedTargets(options) {
   const value = options.target || options.targets;