agentel 0.2.0 → 0.2.3

package/src/importers.js

@@ -15,11 +15,14 @@ const { DISABLED_IMPORT_SOURCE_MESSAGES, IMPORT_SOURCE_ORDER } = require("./sour
 const { parseAiderHistoryFile } = require("./importers/aider");
 const { extractClaudeMessagesFromEvent, updateClaudeParseContext } = require("./importers/claude");
 const { readClineCheckpointDiffs } = require("./importers/cline");
-const { parseGeminiCliJson, parseGeminiCliJsonl } = require("./importers/gemini");
+const { parseGeminiCliJsonSessions, parseGeminiCliJsonlSessions } = require("./importers/gemini");
 const { importSourceWithAdapter, providerAdapterForSource, providerAdapterSources } = require("./importers/providers");
 const { parseSince } = require("./importers/shared");
 const { canonicalWebProvider, derivedAccountId, getWebAccount, upsertWebAccount } = require("./web-accounts");
 
+const WEB_TOKEN_ESTIMATE_CHARS = 4;
+const WEB_CHAT_TOKEN_ESTIMATION_METHOD = "web-message-parts-chars-v1";
+
 function importCliHistory(options = {}, env = process.env) {
   const source = options.source || "all";
   const since = parseSince(options.since || "30d");
@@ -451,6 +454,8 @@ function importCursorProvider(provider, since, options = {}, env = process.env)
           sourceFiles: session.sourceFiles || [session.sourcePath, session.dbPath].filter(Boolean),
           sourceType,
           title: session.title,
+          composerId: cursorSessionComposerId(session) || undefined,
+          parentComposerId: session.parentComposerId || undefined,
           sharedRawFiles: cursorSessionUsesSharedRawFiles(sourceType),
           replaceSourcePathCopies: sourceType === "cursor-agent-transcripts"
         },
@@ -534,6 +539,10 @@ function importStructuredProvider(provider, sessions, since, options = {}, env =
           sourceFiles: session.sourceFiles || [session.sourcePath].filter(Boolean),
           sourceType,
           title: session.title,
+          sessionSummary: session.sessionSummary,
+          providerConversationId: session.providerConversationId,
+          rawReferences: session.rawReferences,
+          sharedRawFiles: structuredSessionUsesSharedRawFiles(provider, sourceType),
           replaceSourcePathCopies: structuredSessionReplaceSourcePathCopies(provider, sourceType)
         },
         env
@@ -554,6 +563,10 @@ function structuredSessionReplaceSourcePathCopies(provider, sourceType) {
   return undefined;
 }
 
+function structuredSessionUsesSharedRawFiles(provider, sourceType) {
+  return provider === "opencode" && sourceType === "opencode-sqlite-history";
+}
+
 function parseAgentJsonl(file, provider) {
   const text = readTextMaybeZstd(file);
   const messages = [];
@@ -1342,6 +1355,7 @@ function importWebChat(providerInput, file, options = {}, env = process.env) {
           sourceType,
           parserVersion: parserVersionForSource(sourceType),
           title: conversation.title,
+          sessionSummary: conversation.sessionSummary,
           providerConversationId: conversation.id,
           chatAccountId: account.accountId,
           chatUsername: account.username,
@@ -1351,6 +1365,7 @@ function importWebChat(providerInput, file, options = {}, env = process.env) {
           chatDisplayPath: displayPath,
           conversationKind: conversation.kind || "conversation",
           pinned: Boolean(conversation.pinned),
+          timeStatus: conversation.timeStatus || "",
           replaceSourcePathCopies: false
         },
         env
@@ -1372,6 +1387,17 @@ function importWebChat(providerInput, file, options = {}, env = process.env) {
   return summary;
 }
 
+function importWindsurfTrajectoryExport(target, options = {}, env = process.env) {
+  const since = parseSince(options.since || "all");
+  return importStructuredProvider(
+    "windsurf",
+    readWindsurfTrajectoryExport(target, options),
+    since,
+    { ...options, repos: options.repos || [] },
+    env
+  );
+}
+
 function readExportJson(file) {
   const bundle = readExportBundle(file);
   const conversations = bundle.entries.find((entry) => /(^|\/)conversations\.json$/i.test(entry.name));
@@ -1458,11 +1484,13 @@ function readExportFile(file) {
 
 function exportEntry(name, text, sourcePath) {
   const data = parseExportText(text, name);
+  const stat = safeStat(String(sourcePath || "").split("#")[0]);
   return {
     name,
     sourcePath,
     data,
     size: Buffer.byteLength(text),
+    mtime: stat?.mtimeMs ? new Date(stat.mtimeMs).toISOString() : "",
     sha256: crypto.createHash("sha256").update(text).digest("hex")
   };
 }
@@ -1571,16 +1599,16 @@ function chatgptRawConversations(data) {
 function chatgptMessages(conversation) {
   if (conversation.mapping && typeof conversation.mapping === "object") {
     const nodes = chatgptMainPathNodes(conversation);
-    return nodes.map((node) => node && node.message).filter(Boolean).map((message) => ({
-      role: normalizeEventRole(message.author?.role) || "unknown",
-      content: extractChatGptContent(message.content),
-      timestamp: toIso(message.create_time || message.update_time),
-      metadata: {
-        source: "chatgpt-export",
-        messageId: message.id || undefined,
-        model: firstString(message.metadata?.model_slug, message.metadata?.model, message.metadata?.default_model_slug) || undefined
-      }
-    }));
+    return nodes.map((node) => node && node.message).filter(Boolean).map((message) => {
+      const role = normalizeEventRole(message.author?.role) || "unknown";
+      const content = extractChatGptContent(message.content);
+      return {
+        role,
+        content,
+        timestamp: toIso(message.create_time || message.update_time),
+        metadata: chatgptMessageMetadata(message, role, content)
+      };
+    });
   }
   return genericConversationMessages(conversation, "chatgpt-export");
 }
@@ -1610,6 +1638,221 @@ function extractChatGptContent(content) {
   return extractText(content);
 }
 
+function chatgptMessageMetadata(message, role, content) {
+  return webWithUsage({
+    source: "chatgpt-export",
+    messageId: message.id || undefined,
+    model: firstString(message.metadata?.model_slug, message.metadata?.model, message.metadata?.default_model_slug) || undefined
+  }, webMessageUsage(message, role, { inputText: content, outputText: content }));
+}
+
+function webWithUsage(metadata, usage) {
+  if (!usage) return metadata;
+  return { ...metadata, usage };
+}
+
+function webMessageUsage(message, role, parts = {}) {
+  const providerUsage = webProviderUsage(...webUsageCandidates(message));
+  if (providerUsage) return webUsageWithRoleDirection(providerUsage, role);
+  const normalizedRole = String(role || "").toLowerCase();
+  return webEstimatedMessageUsage({
+    inputText: normalizedRole === "assistant" ? "" : parts.inputText,
+    outputText: normalizedRole === "assistant" ? parts.outputText : "",
+    reasoningText: normalizedRole === "assistant" ? parts.reasoningText : ""
+  });
+}
+
+function webUsageWithRoleDirection(usage, role) {
+  if (!usage || usage.inputTokens || usage.outputTokens || usage.totalInputTokens || usage.totalOutputTokens) return usage;
+  const totalTokens = webPositiveTokenNumber(usage.totalTokens);
+  if (!totalTokens) return usage;
+  const directionalTokens = Math.max(
+    0,
+    totalTokens -
+      webPositiveTokenNumber(usage.cacheInputTokens) -
+      webPositiveTokenNumber(usage.reasoningOutputTokens) -
+      webPositiveTokenNumber(usage.toolUsePromptTokens)
+  );
+  if (!directionalTokens) return usage;
+  if (String(role || "").toLowerCase() === "assistant") return { ...usage, outputTokens: directionalTokens };
+  return { ...usage, inputTokens: directionalTokens };
+}
+
+function webUsageCandidates(message) {
+  if (!message || typeof message !== "object") return [];
+  const metadata = message.metadata && typeof message.metadata === "object" ? message.metadata : {};
+  return [
+    message.usage,
+    message.token_usage,
+    message.tokenUsage,
+    message.token_counts,
+    message.tokenCounts,
+    message.token_count,
+    message.tokenCount,
+    message.tokens,
+    metadata.usage,
+    metadata.token_usage,
+    metadata.tokenUsage,
+    metadata.token_counts,
+    metadata.tokenCounts,
+    metadata.token_count,
+    metadata.tokenCount,
+    metadata.tokens,
+    message
+  ];
+}
+
+function webProviderUsage(...candidates) {
+  for (const candidate of candidates) {
+    const usage = normalizeWebProviderUsage(candidate);
+    if (usage) return usage;
+  }
+  return null;
+}
+
+function normalizeWebProviderUsage(usage) {
+  if (usage == null || usage === "") return null;
+  if (typeof usage !== "object") {
+    const totalTokens = webPositiveTokenNumber(usage);
+    return totalTokens ? { totalTokens } : null;
+  }
+  const inputTokens = webPositiveTokenNumber(numericValue(
+    usage.inputTokens,
+    usage.input_tokens,
+    usage.promptTokens,
+    usage.prompt_tokens,
+    usage.promptTokenCount,
+    usage.prompt_token_count,
+    usage.inputTokenCount,
+    usage.input_token_count,
+    usage.input,
+    usage.prompt
+  ));
+  const outputTokens = webPositiveTokenNumber(numericValue(
+    usage.outputTokens,
+    usage.output_tokens,
+    usage.completionTokens,
+    usage.completion_tokens,
+    usage.completionTokenCount,
+    usage.completion_token_count,
+    usage.outputTokenCount,
+    usage.output_token_count,
+    usage.output,
+    usage.completion
+  ));
+  const totalInputTokens = webPositiveTokenNumber(numericValue(
+    usage.totalInputTokens,
+    usage.total_input_tokens,
+    usage.totalPromptTokens,
+    usage.total_prompt_tokens,
+    usage.totalPromptTokenCount,
+    usage.total_prompt_token_count
+  ));
+  const totalOutputTokens = webPositiveTokenNumber(numericValue(
+    usage.totalOutputTokens,
+    usage.total_output_tokens,
+    usage.totalCompletionTokens,
+    usage.total_completion_tokens,
+    usage.totalCompletionTokenCount,
+    usage.total_completion_token_count
+  ));
+  const cacheInputTokens = webSumTokenNumbers(
+    usage.cacheInputTokens,
+    usage.cache_input_tokens,
+    usage.cacheCreationInputTokens,
+    usage.cache_creation_input_tokens,
+    usage.cacheReadInputTokens,
+    usage.cache_read_input_tokens,
+    usage.cacheReadTokens,
+    usage.cache_read_tokens,
+    usage.cachedContentTokenCount,
+    usage.cached_content_token_count,
+    usage.cachedTokens,
+    usage.cached_tokens,
+    usage.prompt_tokens_details?.cached_tokens,
+    usage.promptTokensDetails?.cachedTokens
+  );
+  const reasoningOutputTokens = webSumTokenNumbers(
+    usage.reasoningOutputTokens,
+    usage.reasoning_output_tokens,
+    usage.reasoningTokens,
+    usage.reasoning_tokens,
+    usage.reasoningTokenCount,
+    usage.reasoning_token_count,
+    usage.thoughtsTokens,
+    usage.thoughts_tokens,
+    usage.thoughtsTokenCount,
+    usage.thoughts_token_count,
+    usage.completion_tokens_details?.reasoning_tokens,
+    usage.completionTokensDetails?.reasoningTokens,
+    usage.output_tokens_details?.reasoning_tokens,
+    usage.outputTokensDetails?.reasoningTokens
+  );
+  const toolUsePromptTokens = webSumTokenNumbers(
+    usage.toolUsePromptTokens,
+    usage.tool_use_prompt_tokens,
+    usage.toolUsePromptTokenCount,
+    usage.tool_use_prompt_token_count
+  );
+  const explicitTotalTokens = webPositiveTokenNumber(numericValue(
+    usage.totalTokens,
+    usage.total_tokens,
+    usage.totalTokenCount,
+    usage.total_token_count,
+    usage.tokenCount,
+    usage.token_count,
+    usage.tokens,
+    usage.total
+  ));
+  const totalTokens = explicitTotalTokens ||
+    inputTokens + outputTokens + cacheInputTokens + reasoningOutputTokens + toolUsePromptTokens ||
+    totalInputTokens + totalOutputTokens;
+  if (!totalTokens) return null;
+  const result = { totalTokens };
+  if (inputTokens) result.inputTokens = inputTokens;
+  if (outputTokens) result.outputTokens = outputTokens;
+  if (totalInputTokens) result.totalInputTokens = totalInputTokens;
+  if (totalOutputTokens) result.totalOutputTokens = totalOutputTokens;
+  if (cacheInputTokens) result.cacheInputTokens = cacheInputTokens;
+  if (reasoningOutputTokens) result.reasoningOutputTokens = reasoningOutputTokens;
+  if (toolUsePromptTokens) result.toolUsePromptTokens = toolUsePromptTokens;
+  return result;
+}
+
+function webEstimatedMessageUsage(parts = {}) {
+  const inputTokens = webEstimatedTokenCount(parts.inputText);
+  const outputTokens = webEstimatedTokenCount(parts.outputText);
+  const reasoningOutputTokens = webEstimatedTokenCount(parts.reasoningText);
+  const totalTokens = inputTokens + outputTokens + reasoningOutputTokens;
+  if (!totalTokens) return null;
+  const usage = {
+    totalTokens,
+    estimated: true,
+    estimationMethod: WEB_CHAT_TOKEN_ESTIMATION_METHOD,
+    charsPerToken: WEB_TOKEN_ESTIMATE_CHARS
+  };
+  if (inputTokens) usage.inputTokens = inputTokens;
+  if (outputTokens) usage.outputTokens = outputTokens;
+  if (reasoningOutputTokens) usage.reasoningOutputTokens = reasoningOutputTokens;
+  return usage;
+}
+
+function webEstimatedTokenCount(value) {
+  const text = String(value || "");
+  if (!text.trim()) return 0;
+  return Math.max(1, Math.ceil(text.length / WEB_TOKEN_ESTIMATE_CHARS));
+}
+
+function webPositiveTokenNumber(value) {
+  const number = Number(value);
+  if (!Number.isFinite(number) || number <= 0) return 0;
+  return Math.round(number);
+}
+
+function webSumTokenNumbers(...values) {
+  return values.reduce((sum, value) => sum + webPositiveTokenNumber(value), 0);
+}
+
 function normalizeClaudeWebExport(source) {
   const projectMap = claudeProjectMap(source);
   const conversations = [];
@@ -1643,7 +1886,11 @@ function claudeConversationsFromEntry(entry, projectMap = new Map()) {
   return values.map((conversation, index) => {
     const id = firstString(conversation.uuid, conversation.id, conversation.conversation_uuid, conversation.conversation_id) || `claude-${hashId(`${entry.name}:${index}`)}`;
     const title = firstString(conversation.name, conversation.title, conversation.summary) || "Claude conversation";
-    const messages = claudeMessages(conversation).filter((message) => message.content.trim());
+    const sessionSummary = claudeConversationSessionSummary(conversation);
+    const messages = [
+      ...claudeConversationSummaryMessages(conversation),
+      ...claudeMessages(conversation)
+    ].filter((message) => message.content.trim());
     const sorted = sortConversationMessages(messages);
     return {
       id,
@@ -1655,7 +1902,8 @@ function claudeConversationsFromEntry(entry, projectMap = new Map()) {
       projectPath: claudeConversationProjectPath(conversation, projectPath, projectMap),
       entryPath: entry.name,
       sourceType: "claude-web-export",
-      kind: "conversation"
+      kind: "conversation",
+      sessionSummary
     };
   });
 }
@@ -1701,16 +1949,158 @@ function claudeProjectPath(entry) {
 
 function claudeMessages(conversation) {
   const messages = conversation.chat_messages || conversation.messages || conversation.children || [];
-  return messages.map((message) => ({
-    role: normalizeEventRole(message.sender || message.role || message.author?.role || message.author) || "unknown",
-    content: extractText(message.text || message.content || message.message),
-    timestamp: toIso(message.created_at || message.createdAt || message.updated_at || message.updatedAt || message.timestamp),
+  return messages.flatMap(claudeMessageRows);
+}
+
+function claudeConversationSessionSummary(conversation) {
+  const summary = firstString(conversation.summary, conversation.conversation_summary, conversation.conversationSummary);
+  if (!summary) return undefined;
+  return {
+    source: "claude-web-export",
+    summary,
+    updatedAt: toIso(conversation.updated_at || conversation.updatedAt) || undefined
+  };
+}
+
+function claudeConversationSummaryMessages(conversation) {
+  const summary = firstString(conversation.summary, conversation.conversation_summary, conversation.conversationSummary);
+  if (!summary) return [];
+  return [{
+    role: "assistant",
+    content: claudeSupplementContent("Claude conversation summary", summary),
+    timestamp: toIso(conversation.created_at || conversation.createdAt || conversation.updated_at || conversation.updatedAt) || "",
     metadata: {
       source: "claude-web-export",
-      messageId: firstString(message.uuid, message.id) || undefined,
-      model: firstString(message.model, message.model_name, message.modelName) || undefined
+      eventType: "claude-conversation-summary",
+      supplementary: true,
+      summaryKind: "conversation_summary"
     }
-  }));
+  }];
+}
+
+function claudeMessageRows(message) {
+  const role = normalizeEventRole(message.sender || message.role || message.author?.role || message.author) || "unknown";
+  const fallbackTimestamp = toIso(message.created_at || message.createdAt || message.updated_at || message.updatedAt || message.timestamp);
+  const metadata = claudeWebMessageMetadata(message);
+  if (role === "assistant") return claudeAssistantMessageRows(message, fallbackTimestamp, metadata);
+  const content = claudeVisibleMessageText(message);
+  return [{
+    role,
+    content,
+    timestamp: fallbackTimestamp,
+    metadata: webWithUsage(metadata, webMessageUsage(message, role, { inputText: content }))
+  }];
+}
+
+function claudeAssistantMessageRows(message, fallbackTimestamp, metadata) {
+  const parts = claudeContentParts(message.content);
+  if (!parts.length) {
+    const content = extractText(message.text || message.content || message.message);
+    return [{
+      role: "assistant",
+      content,
+      timestamp: fallbackTimestamp,
+      metadata: webWithUsage(metadata, webMessageUsage(message, "assistant", { outputText: content }))
+    }];
+  }
+  const thinkingParts = claudeThinkingParts(parts);
+  const visibleParts = claudeVisibleParts(parts);
+  const thinking = claudeThinkingText(thinkingParts);
+  const visible = claudeVisibleText(visibleParts);
+  const usage = webMessageUsage(message, "assistant", { outputText: visible, reasoningText: thinking });
+  const rows = [];
+  if (thinking) {
+    const thinkingSummaries = claudeThinkingSummaries(thinkingParts);
+    rows.push({
+      role: "assistant",
+      content: claudeSupplementContent("Claude thinking", thinking),
+      timestamp: claudePartsTimestamp(thinkingParts, fallbackTimestamp),
+      metadata: webWithUsage({
+        ...metadata,
+        eventType: "claude-thinking",
+        supplementary: true,
+        summaryKind: "thinking",
+        thinkingSummaries: thinkingSummaries.length ? thinkingSummaries : undefined
+      }, visible ? null : usage)
+    });
+  }
+  if (visible) {
+    rows.push({
+      role: "assistant",
+      content: visible,
+      timestamp: claudePartsTimestamp(visibleParts, fallbackTimestamp),
+      metadata: webWithUsage(metadata, usage)
+    });
+  }
+  return rows;
+}
+
+function claudeWebMessageMetadata(message) {
+  return {
+    source: "claude-web-export",
+    messageId: firstString(message.uuid, message.id) || undefined,
+    model: firstString(message.model, message.model_name, message.modelName) || undefined
+  };
+}
+
+function claudeContentParts(content) {
+  return Array.isArray(content) ? content.filter((part) => part && typeof part === "object") : [];
+}
+
+function claudeVisibleMessageText(message) {
+  const parts = claudeContentParts(message.content);
+  if (parts.length) return claudeVisibleText(claudeVisibleParts(parts));
+  return extractText(message.text || message.content || message.message);
+}
+
+function claudeVisibleParts(parts) {
+  return parts.filter((part) => {
+    const type = String(part.type || part.kind || "").toLowerCase();
+    return !/(tool_use|tool_result|function_call|function_result|thinking|redacted_thinking)/.test(type);
+  });
+}
+
+function claudeThinkingParts(parts) {
+  return parts.filter((part) => /thinking/.test(String(part.type || part.kind || "").toLowerCase()));
+}
+
+function claudeVisibleText(parts) {
+  return parts.map((part) => extractText(part)).filter(Boolean).join("\n").trim();
+}
+
+function claudeThinkingText(parts) {
+  return parts
+    .map((part) => firstString(part.thinking, part.text, part.content, part.summary, extractText(part.content)))
+    .filter(Boolean)
+    .join("\n\n")
+    .trim();
+}
+
+function claudeThinkingSummaries(parts) {
+  return parts.flatMap((part) => Array.isArray(part.summaries)
+    ? part.summaries.map((summary) => firstString(summary.summary, summary.text, summary.content))
+    : []
+  ).filter(Boolean);
+}
+
+function claudePartsTimestamp(parts, fallbackTimestamp) {
+  const timestamps = parts
+    .map((part) => toIso(
+      part.stop_timestamp ||
+        part.stopTimestamp ||
+        part.end_timestamp ||
+        part.endTimestamp ||
+        part.start_timestamp ||
+        part.startTimestamp ||
+        part.created_at ||
+        part.createdAt
+    ))
+    .filter(Boolean);
+  return timestamps[timestamps.length - 1] || fallbackTimestamp || "";
+}
+
+function claudeSupplementContent(title, content) {
+  return `### ${title}\n\n${String(content || "").trim()}`;
 }
 
 function claudeMemoryConversations(entry, projectMap = new Map()) {
@@ -1718,7 +2108,7 @@ function claudeMemoryConversations(entry, projectMap = new Map()) {
   const conversations = [];
   for (const row of rows) {
     const rootContent = renderClaudeConversationMemory(row);
-    if (rootContent.trim()) conversations.push(claudeMemoryConversation("memory", "Claude Memory", rootContent, "memory", entry.name));
+    if (rootContent.trim()) conversations.push(claudeMemoryConversation("memory", "Claude Memory", rootContent, "memory", entry));
     const projectMemories = row && typeof row === "object" && row.project_memories && typeof row.project_memories === "object"
       ? row.project_memories
       : {};
@@ -1727,14 +2117,14 @@ function claudeMemoryConversations(entry, projectMap = new Map()) {
       if (!content.trim()) continue;
       const project = projectMap.get(projectId);
       const projectTitle = project?.title || project?.path || sanitizeProjectPath(projectId) || projectId;
-      conversations.push(claudeMemoryConversation(`memory-${projectId}`, `Claude Project Memory: ${projectTitle}`, content, "memory", entry.name));
+      conversations.push(claudeMemoryConversation(`memory-${projectId}`, `Claude Project Memory: ${projectTitle}`, content, "memory", entry));
     }
   }
   return conversations;
 }
 
-function claudeMemoryConversation(id, title, content, projectPath, entryPath) {
-  const timestamp = new Date().toISOString();
+function claudeMemoryConversation(id, title, content, projectPath, entry) {
+  const timestamp = claudeMemorySyntheticTimestamp(entry);
   return {
     id,
     title,
@@ -1743,13 +2133,23 @@ function claudeMemoryConversation(id, title, content, projectPath, entryPath) {
     endedAt: timestamp,
     updatedAt: timestamp,
     projectPath: projectPath || "",
-    entryPath,
+    entryPath: entry?.name || "",
     sourceType: "claude-web-memory",
     kind: "memory",
-    pinned: true
+    pinned: true,
+    timeStatus: "recovered-time-unknown",
+    sessionSummary: {
+      source: "claude-web-memory",
+      timeStatus: "recovered-time-unknown",
+      note: "Claude memory exports do not include reliable memory creation or update timestamps."
+    }
   };
 }
 
+function claudeMemorySyntheticTimestamp(entry) {
+  return toIso(entry?.mtime) || "1970-01-01T00:00:00.000Z";
+}
+
 function renderClaudeConversationMemory(data) {
   if (data && typeof data === "object" && typeof data.conversations_memory === "string") {
     return data.conversations_memory;
@@ -1781,12 +2181,16 @@ function renderClaudeMemoryItem(item) {
 
 function genericConversationMessages(conversation, source) {
   const messages = conversation.messages || conversation.chat_messages || [];
-  return messages.map((message) => ({
-    role: normalizeEventRole(message.role || message.sender || message.author?.role) || "unknown",
-    content: extractText(message.content || message.text || message.message),
-    timestamp: toIso(message.created_at || message.create_time || message.timestamp),
-    metadata: { source }
-  }));
+  return messages.map((message) => {
+    const role = normalizeEventRole(message.role || message.sender || message.author?.role) || "unknown";
+    const content = extractText(message.content || message.text || message.message);
+    return {
+      role,
+      content,
+      timestamp: toIso(message.created_at || message.create_time || message.timestamp),
+      metadata: webWithUsage({ source }, webMessageUsage(message, role, { inputText: content, outputText: content }))
+    };
+  });
 }
 
 function sortConversationMessages(messages) {
@@ -1805,7 +2209,8 @@ function webConversationSessionId(provider, accountId, conversationId) {
 
 function webConversationFingerprint(sourceType, accountId, conversation) {
   const body = conversation.messages.map((message) => `${message.role}:${message.timestamp}:${message.content}`).join("\n");
-  return `${fingerprintPrefix(sourceType)}:${accountId}:${conversation.projectPath || ""}:${conversation.updatedAt || conversation.endedAt || ""}:${conversation.messages.length}:${hashId(body)}`;
+  const summary = JSON.stringify(conversation.sessionSummary || {});
+  return `${fingerprintPrefix(sourceType)}:${accountId}:${conversation.projectPath || ""}:${conversation.updatedAt || conversation.endedAt || ""}:${conversation.messages.length}:${hashId(`${body}\n${summary}`)}`;
 }
 
 function webConversationScope(provider, accountId, projectPath = "") {
@@ -2005,8 +2410,8 @@ function discoverCliHistory(env = process.env, options = {}) {
     summarizeStructuredSessions(
       readAntigravitySessions({
         onProgress: (event) => reportDiscoveryProgress(options, { ...event, provider: "Antigravity" })
-      }),
-      "Antigravity task/plan/walkthrough artifacts; binary protobuf transcripts are counted separately"
+      }, env),
+      "Antigravity task/plan/walkthrough artifacts plus trajectory summaries; binary protobuf transcripts are counted separately"
     )
   );
 
@@ -2044,7 +2449,7 @@ function discoverCliHistory(env = process.env, options = {}) {
       readOpenCodeSessions(env, {
         onProgress: (event) => reportDiscoveryProgress(options, { ...event, provider: "OpenCode" })
       }),
-      "OpenCode JSON session/message/part storage"
+      "OpenCode SQLite database and JSON session/message/part storage"
     )
   );
 
@@ -2233,6 +2638,8 @@ function summarizeStructuredSessionDetails(sessions) {
     if (session.detailKey) acc[session.detailKey] = (acc[session.detailKey] || 0) + 1;
     if (session.artifactCount) acc.artifacts = (acc.artifacts || 0) + session.artifactCount;
     if (session.binaryCount) acc.binaryOnly = (acc.binaryOnly || 0) + session.binaryCount;
+    if (session.partialSummary) acc.partialSummaries = (acc.partialSummaries || 0) + 1;
+    if (session.stateDbCount) acc.stateDbs = (acc.stateDbs || 0) + session.stateDbCount;
     return acc;
   }, {});
 }
@@ -2413,7 +2820,7 @@ function readCodexThreads(env = process.env) {
         "where rollout_path != ''",
         "order by updated_at desc"
       ].join(" ");
-  const result = spawnSync("sqlite3", [db, "-json", query], { encoding: "utf8", maxBuffer: 1024 * 1024 * 50 });
+  const result = spawnSync("sqlite3", [db, "-json", query], { argv0: "agentlog-sqlite", encoding: "utf8", maxBuffer: 1024 * 1024 * 50 });
   if (result.status !== 0 || !result.stdout.trim()) return [];
   try {
     return JSON.parse(result.stdout).map((row) => ({
@@ -2550,18 +2957,37 @@ function normalizeSourcePath(file) {
 }
 
 function sqliteTableExists(dbPath, tableName) {
-  const result = runSqliteJson(
-    dbPath,
-    `select name from sqlite_master where type = 'table' and name = ${sqlQuote(tableName)} limit 1`
-  );
-  if (!result.ok) return false;
   try {
-    return parseSqliteJson(result.stdout).length > 0;
+    return readSqliteJson(
+      dbPath,
+      `select name from sqlite_master where type = 'table' and name = ${sqlQuote(tableName)} limit 1`,
+      `${tableName} table check`
+    ).length > 0;
   } catch {
     return false;
   }
 }
 
+function sqliteTableColumns(dbPath, tableName) {
+  try {
+    return new Set(
+      readSqliteJson(dbPath, `select name from pragma_table_info(${sqlQuote(tableName)})`, `${tableName} column check`)
+        .map((row) => String(row.name || ""))
+        .filter(Boolean)
+    );
+  } catch {
+    return new Set();
+  }
+}
+
+function sqliteSelectMaybe(columns, tableAlias, columnName, outputName = columnName) {
+  if (columns.has(columnName)) {
+    const value = `${tableAlias}.${columnName}`;
+    return outputName === columnName ? value : `${value} as ${outputName}`;
+  }
+  return `null as ${outputName}`;
+}
+
 function codexStateDb(env = process.env) {
   return env.CODEX_STATE_DB || path.join(codexHome(env), "state_5.sqlite");
 }
@@ -2848,11 +3274,13 @@ function readCursorProjectTranscriptSessions(options = {}) {
       return stat && stat.mtime >= options.modifiedSince;
     }));
   }
+  const composerInfoLookup = options.composerInfoLookup
+    || (options.composerTitleLookup ? (id) => ({ title: options.composerTitleLookup(id), model: "" }) : cursorBuildComposerInfoLookup(env));
   const sessions = [];
   reportDiscoveryProgress(options, { current: 0, total: groups.length, message: "reading Cursor agent transcripts" });
   for (let index = 0; index < groups.length; index++) {
     const group = groups[index];
-    const session = parseCursorTranscriptGroup(group);
+    const session = parseCursorTranscriptGroup({ ...group, composerInfoLookup });
     if (session) sessions.push(session);
     reportDiscoveryProgress(options, {
       current: index + 1,
@@ -2864,6 +3292,87 @@ function readCursorProjectTranscriptSessions(options = {}) {
   return sessions;
 }
 
+function cursorBuildComposerTitleLookup(env = process.env) {
+  const lookup = cursorBuildComposerInfoLookup(env);
+  return (composerId) => lookup(composerId).title;
+}
+
+function cursorBuildComposerInfoLookup(env = process.env) {
+  const info = new Map();
+  for (const db of cursorGlobalStorageDbs(env)) {
+    try {
+      const composerRows = readSqliteJson(
+        db,
+        [
+          "select",
+          "key,",
+          "json_extract(value, '$.name') as name,",
+          "json_extract(value, '$.title') as title,",
+          "json_extract(value, '$.chatTitle') as chatTitle,",
+          "json_extract(value, '$.modelConfig.modelName') as modelConfigModelName",
+          "from cursorDiskKV where",
+          "json_valid(value) and (",
+          cursorDiskKvPrefixRangeCondition("composerData:"),
+          "or",
+          cursorDiskKvPrefixRangeCondition("_composerData:"),
+          ")"
+        ].join(" "),
+        "Cursor global SQLite store"
+      );
+      for (const row of composerRows) {
+        const match = String(row.key || "").match(/^_?composerData:(.+)$/);
+        if (!match) continue;
+        const composerId = match[1].toLowerCase();
+        const title = firstString(row.name, row.title, row.chatTitle);
+        const entry = info.get(composerId) || { title: "", modelHist: new Map() };
+        if (title && !entry.title) entry.title = title;
+        const configModel = firstString(row.modelConfigModelName);
+        if (configModel) entry.configModel = (entry.configModel || configModel);
+        info.set(composerId, entry);
+      }
+      const bubbleRows = readSqliteJson(
+        db,
+        [
+          "select",
+          "key,",
+          "json_extract(value, '$.modelId') as modelId,",
+          "json_extract(value, '$.modelName') as modelName,",
+          "json_extract(value, '$.model') as model",
+          "from cursorDiskKV where",
+          "json_valid(value) and",
+          cursorDiskKvPrefixRangeCondition("bubbleId:")
+        ].join(" "),
+        "Cursor global SQLite store"
+      );
+      for (const row of bubbleRows) {
+        const keyMatch = String(row.key || "").match(/^bubbleId:([^:]+):/);
+        if (!keyMatch) continue;
+        const composerId = keyMatch[1].toLowerCase();
+        const model = firstString(row.modelId, row.modelName, row.model);
+        if (!model) continue;
+        const entry = info.get(composerId) || { title: "", modelHist: new Map() };
+        entry.modelHist.set(model, (entry.modelHist.get(model) || 0) + 1);
+        info.set(composerId, entry);
+      }
+    } catch {
+      // global store may be locked or absent; degrade silently.
+    }
+  }
+  const result = new Map();
+  for (const [id, entry] of info) {
+    let dominantModel = "";
+    let bestCount = 0;
+    for (const [model, count] of entry.modelHist || []) {
+      if (count > bestCount) { bestCount = count; dominantModel = model; }
+    }
+    result.set(id, {
+      title: entry.title || "",
+      model: dominantModel || entry.configModel || ""
+    });
+  }
+  return (composerId) => result.get(String(composerId || "").toLowerCase()) || { title: "", model: "" };
+}
+
 function cursorProjectTranscriptFiles(env = process.env) {
   const root = cursorProjectsRoot(env);
   const files = [];
@@ -2884,13 +3393,28 @@ function groupCursorTranscriptFiles(files, env = process.env) {
     if (agentIndex < 1) continue;
     const projectSlug = parts[0];
     const rest = parts.slice(agentIndex + 1);
-    const sessionPart = rest.length > 1 ? rest[0] : path.basename(file, path.extname(file));
-    const root = path.join(projectsRoot, projectSlug, "agent-transcripts", sessionPart);
-    const key = `${projectSlug}:${sessionPart}`;
+    const subagentIndex = rest.indexOf("subagents");
+    let id;
+    let parentId = "";
+    let root;
+    let key;
+    if (subagentIndex >= 0 && rest.length > subagentIndex + 1) {
+      // <projectSlug>/agent-transcripts/<parent>/subagents/<subagent>/...
+      parentId = rest.slice(0, subagentIndex).filter(Boolean)[0] || "";
+      const subagentRest = rest.slice(subagentIndex + 1);
+      id = subagentRest.length > 1 ? subagentRest[0] : path.basename(file, path.extname(file));
+      root = path.join(projectsRoot, projectSlug, "agent-transcripts", parentId, "subagents", id);
+      key = `${projectSlug}:${parentId}/subagents/${id}`;
+    } else {
+      id = rest.length > 1 ? rest[0] : path.basename(file, path.extname(file));
+      root = path.join(projectsRoot, projectSlug, "agent-transcripts", id);
+      key = `${projectSlug}:${id}`;
+    }
     if (!groups.has(key)) {
       groups.set(key, {
         key,
-        id: sessionPart,
+        id,
+        parentId: parentId || undefined,
         projectSlug,
         projectDir: path.join(projectsRoot, projectSlug),
         root,
@@ -2905,16 +3429,28 @@ function groupCursorTranscriptFiles(files, env = process.env) {
 
 function parseCursorTranscriptGroup(group) {
   const parsedFiles = group.files.map(parseCursorTranscriptFile).filter(Boolean);
-  const messages = stampMessages(dedupeAdjacentMessages(
-    parsedFiles.flatMap((parsed) => parsed.messages || []).sort((a, b) => String(a.timestamp).localeCompare(String(b.timestamp)))
-  ), "cursor-agent-transcripts");
-  if (!messages.length) return null;
+  const rawMessages = parsedFiles
+    .flatMap((parsed) => parsed.messages || [])
+    .sort((a, b) => String(a.timestamp).localeCompare(String(b.timestamp)));
+  if (!rawMessages.length) return null;
+  const composerInfoLookup = group.composerInfoLookup
+    || (group.composerLookup ? (id) => ({ title: group.composerLookup(id), model: "" }) : () => ({ title: "", model: "" }));
+  const info = composerInfoLookup(group.id);
+  const fallbackModel = info.model || "";
+  const enrichedRaw = fallbackModel
+    ? rawMessages.map((message) => cursorMessageWithFallbackModel(message, fallbackModel))
+    : rawMessages;
+  const messages = stampMessages(dedupeAdjacentMessages(enrichedRaw), "cursor-agent-transcripts");
   const cwd = firstString(...parsedFiles.map((parsed) => parsed.cwd), cursorSlugToPath(group.projectSlug, group.env));
+  const fileTitle = firstString(...parsedFiles.map((parsed) => parsed.title));
+  const userTitle = cursorTranscriptTitleFromMessages(messages);
+  const title = firstString(fileTitle, info.title, userTitle, group.id.replace(/[-_]+/g, " "));
   return {
     sessionId: `cursor-${hashId(group.key)}`,
     id: group.id,
+    parentComposerId: group.parentId || undefined,
     sourceKey: "cursor-agent-transcripts",
-    title: firstString(...parsedFiles.map((parsed) => parsed.title), group.id.replace(/[-_]+/g, " ")),
+    title,
     cwd,
     startedAt: messages[0]?.timestamp || new Date().toISOString(),
     endedAt: messages[messages.length - 1]?.timestamp || messages[0]?.timestamp || new Date().toISOString(),
@@ -2928,6 +3464,19 @@ function parseCursorTranscriptGroup(group) {
   };
 }
 
+function cursorTranscriptTitleFromMessages(messages) {
+  for (const message of messages || []) {
+    if (message.role !== "user") continue;
+    const text = String(message.content || "").trim();
+    if (!text) continue;
+    const firstLineText = text.split(/\r?\n/, 1)[0].trim();
+    if (!firstLineText) continue;
+    const truncated = firstLineText.length > 80 ? firstLineText.slice(0, 77).trimEnd() + "…" : firstLineText;
+    return truncated;
+  }
+  return "";
+}
+
 function parseCursorTranscriptFile(file) {
   const stat = safeStat(file);
   const fallbackTime = new Date(stat?.mtimeMs || Date.now()).toISOString();
@@ -3231,6 +3780,7 @@ function readCursorGlobalDiskKvSessionsFromDb(dbPath, options = {}) {
       "json_extract(value, '$.workspaceIdentifier') as workspaceIdentifier",
       "json_extract(value, '$.workspace') as workspace",
       "json_extract(value, '$.context') as context",
+      "json_extract(value, '$.modelConfig') as modelConfig",
       "json_extract(value, '$.fullConversationHeadersOnly') as fullConversationHeadersOnly",
       "length(json_extract(value, '$.conversation')) as conversationBytes"
     ].join(", "),
@@ -3289,6 +3839,7 @@ function cursorGlobalComposerDataFromRow(row) {
     workspaceIdentifier: cursorParseSqliteJsonColumn(row.workspaceIdentifier),
     workspace: cursorParseSqliteJsonColumn(row.workspace),
     context: cursorParseSqliteJsonColumn(row.context),
+    modelConfig: cursorParseSqliteJsonColumn(row.modelConfig),
     fullConversationHeadersOnly: cursorParseSqliteJsonColumn(row.fullConversationHeadersOnly),
     _hasConversation: Number(row.conversationBytes || 0) > 2
   };
@@ -3408,6 +3959,8 @@ function cursorGlobalBubbleSelectColumns(valueExpression = "value", keyExpressio
     `json_extract(${valueExpression}, '$.modelID') as modelID`,
     `json_extract(${valueExpression}, '$.modelName') as modelName`,
     `json_extract(${valueExpression}, '$.modelSlug') as modelSlug`,
+    `json_extract(${valueExpression}, '$.modelConfig') as modelConfig`,
+    `json_extract(${valueExpression}, '$.providerOptions') as providerOptions`,
     `json_extract(${valueExpression}, '$.status') as status`,
     `json_extract(${valueExpression}, '$.state') as state`,
     `json_extract(${valueExpression}, '$.phase') as phase`,
@@ -3422,6 +3975,8 @@ function cursorGlobalBubbleSelectColumns(valueExpression = "value", keyExpressio
     `json_extract(${valueExpression}, '$.usage') as usage`,
     `json_extract(${valueExpression}, '$.tokenUsage') as tokenUsage`,
     `json_extract(${valueExpression}, '$.token_usage') as token_usage`,
+    `json_extract(${valueExpression}, '$.tokenCount') as tokenCount`,
+    `json_extract(${valueExpression}, '$.token_count') as token_count`,
     `json_extract(${valueExpression}, '$.tokens') as tokens`,
     `json_extract(${valueExpression}, '$.terminalSelections') as terminalSelections`,
     `json_extract(${valueExpression}, '$.fileSelections') as fileSelections`,
@@ -3458,6 +4013,8 @@ function cursorGlobalBubbleDataFromRow(row) {
     modelID: row.modelID,
     modelName: row.modelName,
     modelSlug: row.modelSlug,
+    modelConfig: cursorParseSqliteJsonColumn(row.modelConfig),
+    providerOptions: cursorParseSqliteJsonColumn(row.providerOptions),
     status: row.status,
     state: cursorParseSqliteJsonColumn(row.state) || row.state,
     phase: row.phase,
@@ -3472,6 +4029,8 @@ function cursorGlobalBubbleDataFromRow(row) {
     usage: cursorParseSqliteJsonColumn(row.usage),
     tokenUsage: cursorParseSqliteJsonColumn(row.tokenUsage),
     token_usage: cursorParseSqliteJsonColumn(row.token_usage),
+    tokenCount: cursorParseSqliteJsonColumn(row.tokenCount),
+    token_count: cursorParseSqliteJsonColumn(row.token_count),
     tokens: cursorParseSqliteJsonColumn(row.tokens),
     terminalSelections: cursorParseSqliteJsonColumn(row.terminalSelections) || [],
     fileSelections: cursorParseSqliteJsonColumn(row.fileSelections) || [],
@@ -3500,6 +4059,7 @@ function cursorGlobalComposerSession(dbPath, composerId, composer, bubbleMap, op
   const headers = cursorGlobalComposerHeaders(composer);
   const startedAt = cursorIso(composer.createdAt || composer.created_at) || eventTimestamp(composer) || new Date().toISOString();
   const endedAt = cursorIso(composer.lastUpdatedAt || composer.updatedAt || composer.updated_at) || startedAt;
+  const composerModel = cursorModel(composer);
   const messages = [];
   for (let index = 0; index < headers.length; index++) {
     const header = headers[index] || {};
@@ -3507,14 +4067,14 @@ function cursorGlobalComposerSession(dbPath, composerId, composer, bubbleMap, op
     const record = bubbleMap.get(bubbleId) || header;
     const timestamp = offsetTimestamp(startedAt, index);
     for (const message of cursorMessagesFromRecord(record, "cursor-global-sqlite", timestamp)) {
-      messages.push({ ...message, timestamp });
+      messages.push(cursorMessageWithFallbackModel({ ...message, timestamp }, composerModel));
     }
   }
   if (!messages.length) {
     for (const [index, record] of [...bubbleMap.values()].sort(cursorGlobalBubbleRecordCompare).entries()) {
       const timestamp = offsetTimestamp(startedAt, index);
       for (const message of cursorMessagesFromRecord(record, "cursor-global-sqlite", timestamp)) {
-        messages.push({ ...message, timestamp });
+        messages.push(cursorMessageWithFallbackModel({ ...message, timestamp }, composerModel));
       }
     }
   }
@@ -3540,6 +4100,17 @@ function cursorGlobalComposerSession(dbPath, composerId, composer, bubbleMap, op
   };
 }
 
+function cursorMessageWithFallbackModel(message, model) {
+  if (!model || message?.role !== "assistant" || message?.metadata?.model) return message;
+  return {
+    ...message,
+    metadata: {
+      ...(message.metadata || {}),
+      model
+    }
+  };
+}
+
 function cursorGlobalComposerHeaders(composer) {
   if (Array.isArray(composer.fullConversationHeadersOnly) && composer.fullConversationHeadersOnly.length) {
     return composer.fullConversationHeadersOnly;
@@ -3894,24 +4465,46 @@ function cursorCwdFromObject(data) {
   );
   const workspaceCwd = cursorExistingCwdFromPath(workspacePath, true);
   if (workspaceCwd) return workspaceCwd;
+  const candidates = cursorPathCandidatesFromValue(data);
+  const mostFrequent = cursorMostFrequentExistingCwd(candidates);
+  if (mostFrequent) return mostFrequent;
   const filePath = cursorFirstPathInObject(data);
   return cursorExistingCwdFromPath(filePath, false);
 }
 
 function cursorCwdFromMessages(messages) {
+  const allCandidates = [];
   for (const message of messages || []) {
-    const metadataPaths = cursorPathCandidatesFromValue(message?.metadata);
-    for (const candidate of metadataPaths) {
-      const cwd = cursorExistingCwdFromPath(candidate, false);
-      if (cwd) return cwd;
-    }
+    allCandidates.push(...cursorPathCandidatesFromValue(message?.metadata));
   }
   const text = (messages || []).map((message) => message?.content || "").join("\n");
-  for (const candidate of cursorPathCandidatesFromValue(text)) {
+  allCandidates.push(...cursorPathCandidatesFromValue(text));
+  const mostFrequent = cursorMostFrequentExistingCwd(allCandidates);
+  if (mostFrequent) return mostFrequent;
+  return cursorCwdFromTerminalPromptText(text);
+}
+
+function cursorMostFrequentExistingCwd(candidates) {
+  if (!candidates || !candidates.length) return "";
+  const counts = new Map();
+  const order = [];
+  for (const candidate of candidates) {
     const cwd = cursorExistingCwdFromPath(candidate, false);
-    if (cwd) return cwd;
+    if (!cwd) continue;
+    if (!counts.has(cwd)) order.push(cwd);
+    counts.set(cwd, (counts.get(cwd) || 0) + 1);
   }
-  return cursorCwdFromTerminalPromptText(text);
+  if (!counts.size) return "";
+  let bestCwd = "";
+  let bestCount = -1;
+  for (const cwd of order) {
+    const count = counts.get(cwd) || 0;
+    if (count > bestCount) {
+      bestCount = count;
+      bestCwd = cwd;
+    }
+  }
+  return bestCwd;
 }
 
 function cursorPathCandidatesFromValue(value, depth = 0, candidates = []) {
@@ -4020,15 +4613,29 @@ function cursorNormalizePathCandidate(value) {
 function cursorAttributionCwd(value) {
   const candidate = cursorNormalizePathCandidate(value);
   if (!candidate || !path.isAbsolute(candidate)) return "";
-  const existing = cursorExistingCwdFromPath(candidate, true);
+  if (cursorIsSystemRootPath(candidate)) return "";
+  const climbed = cursorClimbOutOfDependencyDirs(candidate);
+  const existing = cursorExistingCwdFromPath(climbed, true);
   if (existing) return existing;
   const appSupportCursorWorkspace = `${path.sep}Application Support${path.sep}Cursor${path.sep}Workspaces${path.sep}`;
-  if (candidate.includes(appSupportCursorWorkspace)) return "";
+  if (climbed.includes(appSupportCursorWorkspace)) return "";
+  return climbed;
+}
+
+function cursorClimbOutOfDependencyDirs(candidate) {
+  const segments = candidate.split(path.sep);
+  // Strip trailing path beyond the first node_modules / .pnpm / vendor segment
+  // so workspace folders that point inside a dependency resolve to the project root.
+  for (const marker of ["node_modules", ".pnpm", "bower_components", "vendor"]) {
+    const index = segments.indexOf(marker);
+    if (index > 0) return segments.slice(0, index).join(path.sep) || candidate;
+  }
   return candidate;
 }
 
 function cursorExistingCwdFromPath(candidate, assumeDirectory = false) {
   if (!candidate || !path.isAbsolute(candidate)) return "";
+  if (cursorIsSystemRootPath(candidate)) return "";
   const stat = safeStat(candidate);
   let start = "";
   if (stat?.isDirectory()) start = candidate;
@@ -4042,13 +4649,34 @@ function cursorExistingCwdFromPath(candidate, assumeDirectory = false) {
 function cursorNearestProjectDir(start) {
   let current = path.resolve(start);
   for (;;) {
-    if (fs.existsSync(path.join(current, ".git")) || fs.existsSync(path.join(current, "package.json"))) return current;
+    if (cursorIsSystemRootPath(current)) return "";
+    const insideDependency = cursorPathInsideDependencyDir(current);
+    const hasMarker = fs.existsSync(path.join(current, ".git")) || fs.existsSync(path.join(current, "package.json"));
+    if (hasMarker && !insideDependency) return current;
     const parent = path.dirname(current);
-    if (parent === current) return fs.existsSync(start) ? start : "";
+    if (parent === current) return cursorIsSystemRootPath(start) ? "" : (fs.existsSync(start) ? start : "");
     current = parent;
   }
 }
 
+function cursorPathInsideDependencyDir(candidate) {
+  const segments = String(candidate || "").split(path.sep);
+  return ["node_modules", ".pnpm", "bower_components", "vendor"].some((marker) => segments.includes(marker));
+}
+
+function cursorIsSystemRootPath(candidate) {
+  const normalized = String(candidate || "").replace(/\/+$/, "") || "/";
+  if (normalized === "/" || normalized === path.parse(normalized).root) return true;
+  const home = os.homedir();
+  if (normalized === home) return true;
+  // Top-level system directories that are never project roots on their own.
+  const blocked = new Set([
+    "/Users", "/home", "/Volumes", "/private", "/tmp", "/var",
+    "/Applications", "/Library", "/System", "/opt", "/etc", "/usr"
+  ]);
+  return blocked.has(normalized);
+}
+
 function readSqliteJson(dbPath, query, label = "SQLite store") {
   const result = runSqliteJson(dbPath, query);
   if (result.ok) return parseSqliteJson(result.stdout);
@@ -4058,6 +4686,7 @@ function readSqliteJson(dbPath, query, label = "SQLite store") {
 
 function runSqliteJson(dbPath, query) {
   const result = spawnSync("sqlite3", [dbPath, "-json", query], {
+    argv0: "agentlog-sqlite",
     encoding: "utf8",
     maxBuffer: 1024 * 1024 * 200,
     timeout: SQLITE_QUERY_TIMEOUT_MS
@@ -4131,9 +4760,13 @@ function extractCursorConversations(data, sourceKey, fallbackTime) {
   const visit = (node) => {
     if (!node || typeof node !== "object") return;
     if (Array.isArray(node.bubbles)) {
-      const messages = node.bubbles
+      const containerModel = cursorModel(node);
+      const rawMessages = node.bubbles
         .flatMap((bubble, index) => cursorMessagesFromRecord(bubble, sourceKey, offsetTimestamp(fallbackTime, index)))
         .filter(Boolean);
+      const messages = containerModel
+        ? rawMessages.map((message) => cursorMessageWithFallbackModel(message, containerModel))
+        : rawMessages;
       if (messages.length) {
         conversations.push({
           id: node.tabId || node.composerId || node.id || hashId(JSON.stringify(messages.slice(0, 2))),
@@ -4297,6 +4930,7 @@ function cursorAiServiceGenerationMessage(entry, fallbackTime, index) {
   const timestamp = cursorIso(entry.unixMs) || offsetTimestamp(fallbackTime, index);
   const role = type === "composer" ? "user" : "assistant";
   const content = type === "apply" ? `Applied changes: ${text}` : text;
+  const commandType = cursorNormalizeCommandType(entry.commandType ?? entry.command_type);
   return {
     role,
     content,
@@ -4305,7 +4939,9 @@ function cursorAiServiceGenerationMessage(entry, fallbackTime, index) {
       provider: "cursor",
       source: "cursor-ai-service-history",
       eventType: firstString(type, "aiService.generation"),
-      requestId: firstString(entry.generationUUID, entry.generationId, entry.id) || undefined
+      requestId: firstString(entry.generationUUID, entry.generationId, entry.id) || undefined,
+      commandType: commandType || undefined,
+      model: cursorModel(entry) || undefined
     }
   };
 }
@@ -4313,6 +4949,7 @@ function cursorAiServiceGenerationMessage(entry, fallbackTime, index) {
 function cursorAiServicePromptMessage(prompt, fallbackTime, index) {
   const text = firstString(prompt?.text, prompt?.prompt, prompt?.value);
   if (!text) return null;
+  const commandType = cursorNormalizeCommandType(prompt?.commandType ?? prompt?.command_type);
   return {
     role: "user",
     content: text,
@@ -4320,11 +4957,31 @@ function cursorAiServicePromptMessage(prompt, fallbackTime, index) {
     metadata: {
       provider: "cursor",
       source: "cursor-ai-service-history",
-      eventType: "aiService.prompt"
+      eventType: "aiService.prompt",
+      commandType: commandType || undefined
     }
   };
 }
 
+function cursorNormalizeCommandType(value) {
+  if (value == null || value === "") return "";
+  const text = String(value).trim();
+  if (!text) return "";
+  // Cursor stores commandType as either an integer enum or a string. Normalize the
+  // common integer mapping so downstream consumers see human-readable labels.
+  const numeric = Number(text);
+  if (Number.isInteger(numeric)) {
+    switch (numeric) {
+      case 1: return "chat";
+      case 2: return "edit";
+      case 3: return "agent";
+      case 4: return "ask";
+      default: return `command-${numeric}`;
+    }
+  }
+  return text.toLowerCase();
+}
+
 function cursorMs(...values) {
   for (const value of values) {
     if (value == null || value === "") continue;
@@ -4476,43 +5133,184 @@ function cursorStructuredText(value) {
 
 function cursorMessageMetadata(record, source) {
   const usage = cursorUsage(record);
+  const commandType = cursorNormalizeCommandType(record?.commandType ?? record?.command_type ?? record?.message?.commandType);
   return {
     provider: "cursor",
     source,
     bubbleType: String(record?.type || "").trim() || undefined,
     eventType: firstString(record?.eventType, record?.event_type, record?.kind, record?.type) || undefined,
-    model: firstString(record?.model, record?.modelId, record?.modelID, record?.modelName, record?.modelSlug, record?.message?.model) || undefined,
+    model: cursorModel(record) || undefined,
     status: firstString(record?.status, record?.state, record?.phase) || undefined,
     requestId: firstString(record?.requestId, record?.request_id, record?.messageId, record?.messageID) || undefined,
     composerId: firstString(record?.composerId, record?.composerID, record?.conversationId, record?.conversation_id) || undefined,
+    commandType: commandType || undefined,
     usage: usage || undefined
   };
 }
 
+function cursorModel(record) {
+  return firstCursorModel(
+    record?.model,
+    record?.modelId,
+    record?.modelID,
+    record?.modelName,
+    record?.modelSlug,
+    record?.message?.model,
+    record?.message?.modelId,
+    record?.message?.modelName,
+    record?.providerOptions?.cursor?.modelName,
+    record?.providerOptions?.cursor?.modelId,
+    record?.provider_options?.cursor?.modelName,
+    record?.provider_options?.cursor?.modelId,
+    record?.message?.providerOptions?.cursor?.modelName,
+    record?.message?.providerOptions?.cursor?.modelId,
+    cursorModelFromModelConfig(record?.modelConfig),
+    cursorModelFromModelConfig(record?.message?.modelConfig),
+    cursorModelFromParts(record?.content),
+    cursorModelFromParts(record?.message?.content),
+    cursorModelFromParts(record?.parts)
+  );
+}
+
+function cursorModelFromModelConfig(config) {
+  if (!config || typeof config !== "object") return "";
+  const direct = firstCursorModel(config.modelName, config.model, config.modelId, config.model_slug, config.modelSlug);
+  if (direct) return direct;
+  const selected = Array.isArray(config.selectedModels) ? config.selectedModels : [];
+  for (const item of selected) {
+    const model = firstCursorModel(item?.modelName, item?.modelId, item?.id, item?.model);
+    if (model) return model;
+  }
+  return "";
+}
+
+function cursorModelFromParts(value, depth = 0) {
+  if (!value || depth > 5) return "";
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const model = cursorModelFromParts(item, depth + 1);
+      if (model) return model;
+    }
+    return "";
+  }
+  if (typeof value !== "object") return "";
+  const direct = firstCursorModel(
+    value.providerOptions?.cursor?.modelName,
+    value.providerOptions?.cursor?.modelId,
+    value.provider_options?.cursor?.modelName,
+    value.provider_options?.cursor?.modelId
+  );
+  if (direct) return direct;
+  const configured = cursorModelFromModelConfig(value.modelConfig);
+  if (configured) return configured;
+  for (const child of Object.values(value)) {
+    if (child && typeof child === "object") {
+      const model = cursorModelFromParts(child, depth + 1);
+      if (model) return model;
+    }
+  }
+  return "";
+}
+
+function firstCursorModel(...values) {
+  for (const value of values) {
+    if (typeof value !== "string") continue;
+    const trimmed = value.trim();
+    if (!trimmed || /^default$/i.test(trimmed)) continue;
+    return trimmed;
+  }
+  return "";
+}
+
 function cursorUsage(record) {
   const candidates = [
+    record?.tokenCount,
+    record?.token_count,
     record?.usage,
     record?.tokenUsage,
     record?.token_usage,
     record?.tokens,
     record?.metrics?.usage,
+    record?.message?.tokenCount,
+    record?.message?.token_count,
     record?.message?.usage,
     record?.message?.tokenUsage
   ];
+  let input = null;
+  let output = null;
+  let cacheInput = null;
+  let total = null;
   for (const item of candidates) {
     if (!item || typeof item !== "object") continue;
-    const input = numericValue(item.inputTokens, item.input_tokens, item.promptTokens, item.prompt_tokens, item.prompt);
-    const output = numericValue(item.outputTokens, item.output_tokens, item.completionTokens, item.completion_tokens, item.completion);
-    const total = numericValue(item.totalTokens, item.total_tokens, item.total);
-    if (input != null || output != null || total != null) {
-      return {
-        inputTokens: input ?? undefined,
-        outputTokens: output ?? undefined,
-        totalTokens: total ?? (input != null || output != null ? (input || 0) + (output || 0) : undefined)
-      };
-    }
-  }
-  return null;
+    input = preferredCursorTokenValue(input, numericValue(
+      item.inputTokens,
+      item.input_tokens,
+      item.inputTokenCount,
+      item.input_token_count,
+      item.promptTokens,
+      item.prompt_tokens,
+      item.promptTokenCount,
+      item.prompt_token_count,
+      item.prompt
+    ));
+    output = preferredCursorTokenValue(output, numericValue(
+      item.outputTokens,
+      item.output_tokens,
+      item.outputTokenCount,
+      item.output_token_count,
+      item.completionTokens,
+      item.completion_tokens,
+      item.completionTokenCount,
+      item.completion_token_count,
+      item.completion
+    ));
+    cacheInput = preferredCursorTokenValue(cacheInput, cursorCacheInputTokens(item));
+    total = preferredCursorTokenValue(total, numericValue(item.totalTokens, item.total_tokens, item.totalTokenCount, item.total_token_count, item.total));
+  }
+  if (![input, output, cacheInput, total].some((value) => value != null && value > 0)) return null;
+  const usage = {};
+  if (input != null) usage.inputTokens = input;
+  if (output != null) usage.outputTokens = output;
+  if (cacheInput != null) usage.cacheInputTokens = cacheInput;
+  if (total != null) usage.totalTokens = total;
+  else if (input != null || output != null) usage.totalTokens = (input || 0) + (output || 0);
+  return usage;
+}
+
+function preferredCursorTokenValue(current, next) {
+  if (next == null) return current;
+  if (current == null) return next;
+  if (current <= 0 && next > 0) return next;
+  return current;
+}
+
+function cursorCacheInputTokens(item) {
+  const cacheInput = numericValue(item.cacheInputTokens, item.cache_input_tokens);
+  const cacheCreation = numericValue(
+    item.cacheCreationInputTokens,
+    item.cache_creation_input_tokens,
+    item.cacheCreationTokens,
+    item.cache_creation_tokens
+  );
+  const cacheRead = numericValue(
+    item.cacheReadInputTokens,
+    item.cache_read_input_tokens,
+    item.cacheReadTokens,
+    item.cache_read_tokens
+  );
+  const cached = numericValue(
+    item.cachedContentTokenCount,
+    item.cached_content_token_count,
+    item.cachedTokens,
+    item.cached_tokens,
+    item.cacheTokens,
+    item.cache_tokens,
+    item.cached
+  );
+  const total = [cacheInput, cacheCreation, cacheRead, cached]
+    .filter((value) => value != null && value > 0)
+    .reduce((sum, value) => sum + value, 0);
+  return total > 0 ? total : null;
 }
 
 function cursorToolCallsFromRecord(record) {
@@ -4622,7 +5420,7 @@ function cursorToolName(node, keyToken, type) {
   if (node.command || node.cmd || node.terminalCommand) return "run_terminal_cmd";
   if (node.diff || node.patch || node.old_string || node.new_string || node.oldText || node.newText) return "edit";
   if (node.query || /search|grep/.test(type || keyToken)) return "search";
-  if (node.path || node.file || node.uri) {
+  if (node.path || node.file || node.filename || node.filePath || node.fsPath || node.uri) {
     if (/read|open|view/.test(type || keyToken)) return "read_file";
     if (/write|edit|diff|patch/.test(type || keyToken)) return "edit_file";
   }
@@ -4634,16 +5432,22 @@ function cursorToolArguments(node, name, keyToken, type) {
   const value = node.input ?? node.args ?? node.arguments ?? node.params ?? node.parameters ?? node.function?.arguments ?? action.input;
   if (value != null) return value;
   if (node.command || node.cmd || node.terminalCommand) return { command: node.command || node.cmd || node.terminalCommand };
-  if (node.diff || node.patch) return { diff: node.diff || node.patch, path: firstString(node.path, node.file, node.filename) || undefined };
+  if (node.diff || node.patch) return { diff: node.diff || node.patch, path: firstString(node.path, node.file, node.filename, node.filePath, node.fsPath) || undefined };
   if (node.old_string || node.new_string || node.oldText || node.newText) {
     return {
-      path: firstString(node.path, node.file, node.filename) || undefined,
+      path: firstString(node.path, node.file, node.filename, node.filePath, node.fsPath) || undefined,
       old_string: firstString(node.old_string, node.oldText),
       new_string: firstString(node.new_string, node.newText)
     };
   }
   if (node.query) return { query: node.query };
-  if (node.path || node.file || node.uri) return { path: firstString(node.path, node.file, node.uri), name: name || type || keyToken };
+  if (node.path || node.file || node.filename || node.filePath || node.fsPath || node.uri) {
+    return {
+      path: firstString(node.path, node.file, node.filename, node.filePath, node.fsPath, cursorUriPath(node.uri)),
+      instruction: firstString(node.instruction, node.text, node.content) || undefined,
+      name: name || type || keyToken
+    };
+  }
   return null;
 }
 
@@ -4653,7 +5457,11 @@ function cursorDiffToolCalls(node) {
     .concat(Array.isArray(node.diffs) ? node.diffs : [])
     .concat(Array.isArray(node.fileDiffs) ? node.fileDiffs : [])
     .concat(Array.isArray(node.file_diffs) ? node.file_diffs : [])
-    .concat(Array.isArray(node.edits) ? node.edits : []);
+    .concat(Array.isArray(node.edits) ? node.edits : [])
+    .concat(Array.isArray(node.suggestedCodeBlocks) ? node.suggestedCodeBlocks : [])
+    .concat(Array.isArray(node.suggested_code_blocks) ? node.suggested_code_blocks : [])
+    .concat(Array.isArray(node.diffHistories) ? node.diffHistories : [])
+    .concat(Array.isArray(node.diff_histories) ? node.diff_histories : []);
   return diffs.map((diff) => cursorNormalizeToolCall(diff, "fileDiffs")).filter(Boolean);
 }
 
@@ -4703,9 +5511,9 @@ function cursorLooksLikeToolResult(node, keyToken, type) {
 
 function cursorToolTarget(args, node) {
   if (args && typeof args === "object" && !Array.isArray(args)) {
-    return firstString(args.path, args.file, args.filename, args.target_file, args.targetFile, args.uri);
+    return firstString(args.path, args.file, args.filename, args.filePath, args.fsPath, args.target_file, args.targetFile, args.uri);
   }
-  return firstString(node?.path, node?.file, node?.filename, node?.target_file, node?.targetFile, node?.uri);
+  return firstString(node?.path, node?.file, node?.filename, node?.filePath, node?.fsPath, node?.target_file, node?.targetFile, node?.uri);
 }
 
 function dedupeCursorToolCalls(calls) {
@@ -4761,8 +5569,12 @@ function cursorBubbleContext(bubble) {
       if (value) parts.push(`Terminal selection:\n${value}`);
     }
   }
-  if (Array.isArray(bubble.fileSelections)) {
-    const files = bubble.fileSelections.map((selection) => selection.uri?.fsPath || selection.uri?.path).filter(Boolean);
+  if (Array.isArray(bubble.fileSelections) || Array.isArray(bubble.selections)) {
+    const files = []
+      .concat(Array.isArray(bubble.fileSelections) ? bubble.fileSelections : [])
+      .concat(Array.isArray(bubble.selections) ? bubble.selections : [])
+      .map((selection) => cursorUriPath(selection?.uri) || cursorNormalizePathCandidate(firstString(selection?.fsPath, selection?.path, selection?.filePath)))
+      .filter(Boolean);
     if (files.length) parts.push(`Files:\n${files.join("\n")}`);
   }
   const nestedPaths = [
@@ -5045,17 +5857,106 @@ function dedupeCursorSessions(sessions) {
     seen.add(key);
     exact.push(session);
   }
-  const contentDeduped = cursorDedupeSessionsByContent(exact);
+  cursorPropagateCwdFromComposerSiblings(exact);
+  const composerDeduped = cursorDedupeByComposerId(exact);
+  const contentDeduped = cursorDedupeSessionsByContent(composerDeduped);
   cursorPropagateCwdFromFallbackSessions(contentDeduped);
   return contentDeduped.filter(
     (session) =>
       !cursorSessionExactDuplicateInBetterSession(session, contentDeduped) &&
       !cursorSessionNearDuplicateInBetterSession(session, contentDeduped) &&
       !cursorSessionCoveredByBetterSessions(session, contentDeduped) &&
-      !cursorSessionContainedInBetterSession(session, contentDeduped)
+      !cursorSessionContainedInBetterSession(session, contentDeduped) &&
+      !cursorSessionIsEmptyApplyStub(session, contentDeduped)
   );
 }
 
+function cursorPropagateCwdFromComposerSiblings(sessions) {
+  const cwdByComposerId = new Map();
+  for (const session of sessions) {
+    const composerId = cursorSessionComposerId(session);
+    if (!composerId || !session.cwd) continue;
+    const existing = cwdByComposerId.get(composerId);
+    if (!existing || cursorSourceRank(session) > existing.rank) {
+      cwdByComposerId.set(composerId, { cwd: session.cwd, rank: cursorSourceRank(session) });
+    }
+  }
+  for (const target of sessions) {
+    if (!target || target.cwd) continue;
+    const composerId = cursorSessionComposerId(target);
+    if (!composerId) continue;
+    const sibling = cwdByComposerId.get(composerId);
+    if (!sibling?.cwd) continue;
+    target.cwd = sibling.cwd;
+    if (target.scopeCanonical === "cursor/uncategorized") target.scopeCanonical = "";
+  }
+}
+
+function cursorDedupeByComposerId(sessions) {
+  const byComposerId = new Map();
+  const result = [];
+  for (const session of sessions) {
+    const composerId = cursorSessionComposerId(session);
+    if (!composerId) {
+      result.push(session);
+      continue;
+    }
+    const existing = byComposerId.get(composerId);
+    if (!existing) {
+      byComposerId.set(composerId, session);
+      result.push(session);
+      continue;
+    }
+    if (cursorPreferSession(session, existing) === session) {
+      const index = result.indexOf(existing);
+      if (index >= 0) result[index] = session;
+      byComposerId.set(composerId, session);
+    }
+  }
+  return result;
+}
+
+function cursorSessionComposerId(session) {
+  if (!session) return "";
+  const direct = firstString(session.composerId, session.id);
+  if (cursorLooksLikeComposerId(direct)) return String(direct).trim();
+  const fromPath = cursorComposerIdFromSourcePath(session.sourcePath || "");
+  if (fromPath) return fromPath;
+  return "";
+}
+
+function cursorComposerIdFromSourcePath(sourcePath) {
+  const text = String(sourcePath || "");
+  if (!text) return "";
+  const matches = text.match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi);
+  if (!matches) return "";
+  // Prefer the last UUID in the path — that's the composer/transcript id, not the workspace hash.
+  return matches[matches.length - 1].toLowerCase();
+}
+
+function cursorSessionIsEmptyApplyStub(session, sessions) {
+  if (!session || !cursorLikelyCursorPromptHistoryFallback(session)) return false;
+  if (!cursorSessionAssistantMessagesAreOnlyApplyStubs(session)) return false;
+  const userProbes = cursorDedupeUserProbes(session);
+  const rank = cursorSourceRank(session);
+  for (const other of sessions) {
+    if (other === session) continue;
+    if (cursorSourceRank(other) <= rank) continue;
+    if (!cursorSessionsComparable(session, other)) continue;
+    if (!userProbes.length) return true;
+    const text = cursorSessionSearchText(other);
+    if (userProbes.some((probe) => text.includes(probe))) return true;
+  }
+  return false;
+}
+
+function cursorSessionAssistantMessagesAreOnlyApplyStubs(session) {
+  const messages = session?.messages || [];
+  const assistantMessages = messages.filter((message) => message.role === "assistant");
+  if (!assistantMessages.length) return true;
+  return assistantMessages.every((message) => /^applied changes:/i.test(String(message.content || "").trim()));
+}
+
 function cursorPropagateCwdFromFallbackSessions(sessions) {
   for (const target of sessions) {
     if (!target || target.cwd) continue;
@@ -5261,6 +6162,9 @@ function cursorSessionSearchText(session) {
 }
 
 function cursorSessionsComparable(left, right) {
+  const leftId = cursorSessionComposerId(left);
+  const rightId = cursorSessionComposerId(right);
+  if (leftId && rightId && leftId === rightId) return true;
   if (left.cwd && right.cwd && left.cwd !== right.cwd) return false;
   return true;
 }
@@ -5286,7 +6190,11 @@ function pruneCursorArchivedDuplicates(env = process.env, state = null, options
   const archived = listSessions(env)
     .filter((session) => session.provider === "cursor")
     .filter((session) => !sourcePaths || sourcePaths.has(cursorSessionSourcePath(session)))
-    .map((session) => cursorSessionWithInferredCwd({ ...session, messages: readTranscript(session.transcriptPath) }));
+    .map((session) => cursorSessionWithInferredCwd({
+      ...session,
+      id: session.composerId || cursorComposerIdFromSourcePath(session.sourcePath || ""),
+      messages: readTranscript(session.transcriptPath)
+    }));
   const kept = new Set(dedupeCursorSessions(archived).map((session) => session.sessionId));
   let pruned = 0;
   for (const session of archived) {
@@ -5630,14 +6538,30 @@ function clineTitle(messages) {
 }
 
 function readOpenCodeSessions(env = process.env, options = {}) {
+  const dbs = openCodeDatabaseFiles(env);
   const roots = openCodeStorageRoots(env);
   const files = roots.flatMap((root) => openCodeSessionFiles(root).map((file) => ({ root, file })));
   const sessions = [];
+  reportDiscoveryProgress(options, { current: 0, total: dbs.length, message: "reading OpenCode SQLite stores" });
+  for (let index = 0; index < dbs.length; index++) {
+    const dbSessions = readOpenCodeSqliteSessionsFromDb(dbs[index]);
+    sessions.push(...dbSessions);
+    reportDiscoveryProgress(options, {
+      current: index + 1,
+      total: dbs.length,
+      message: `${dbSessions.length} SQLite sessions`,
+      path: dbs[index]
+    });
+  }
+  const seenSessionIds = new Set();
   reportDiscoveryProgress(options, { current: 0, total: files.length, message: "reading OpenCode storage" });
   for (let index = 0; index < files.length; index++) {
     const item = files[index];
     const session = parseOpenCodeSessionFile(item.file, item.root);
-    if (session) sessions.push(session);
+    if (session) {
+      sessions.push(session);
+      seenSessionIds.add(session.sessionId.replace(/^opencode-/, ""));
+    }
     reportDiscoveryProgress(options, {
       current: index + 1,
       total: files.length,
@@ -5645,28 +6569,69 @@ function readOpenCodeSessions(env = process.env, options = {}) {
       path: item.file
     });
   }
+  for (const root of roots) {
+    for (const sessionId of openCodeMessageSessionIds(root)) {
+      if (seenSessionIds.has(sessionId)) continue;
+      const session = parseOpenCodeMessageOnlySession(root, sessionId);
+      if (session) {
+        sessions.push(session);
+        seenSessionIds.add(sessionId);
+      }
+    }
+  }
   return dedupeStructuredSessions(sessions, "opencode");
 }
 
+function openCodeDataRoots(env = process.env) {
+  const configured = env.AGENTLOG_OPENCODE_DATA_DIR || env.OPENCODE_DATA_DIR;
+  if (configured) return existingUniquePaths([configured]);
+  const home = env.HOME || os.homedir();
+  const roots = [
+    path.join(home, ".local", "share", "opencode"),
+    path.join(home, "Library", "Application Support", "opencode"),
+    path.join(home, ".local", "share", "ai.opencode.app"),
+    path.join(home, "Library", "Application Support", "ai.opencode.app")
+  ];
+  const appData = env.APPDATA || env.LOCALAPPDATA || env.LocalAppData;
+  if (appData) {
+    roots.push(path.join(appData, "opencode"));
+    roots.push(path.join(appData, "ai.opencode.app"));
+  }
+  return existingUniquePaths(roots);
+}
+
 function openCodeStorageRoots(env = process.env) {
   const explicit = envPathList(env.AGENTLOG_OPENCODE_STORAGE_ROOTS || env.AGENTLOG_OPENCODE_STORAGE_DIR);
   if (explicit.length) return existingUniquePaths(explicit);
-  const dataRoot = env.AGENTLOG_OPENCODE_DATA_DIR || env.OPENCODE_DATA_DIR || path.join(os.homedir(), ".local", "share", "opencode");
-  const roots = [path.join(dataRoot, "storage")];
-  const projectRoot = path.join(dataRoot, "project");
-  let entries = [];
-  try {
-    entries = fs.readdirSync(projectRoot, { withFileTypes: true });
-  } catch {
-    entries = [];
-  }
-  for (const entry of entries) {
-    if (entry.isDirectory()) roots.push(path.join(projectRoot, entry.name, "storage"));
+  const dataRoots = openCodeDataRoots(env);
+  const roots = [];
+  for (const dataRoot of dataRoots) {
+    roots.push(path.join(dataRoot, "storage"));
+    const projectRoot = path.join(dataRoot, "project");
+    let entries = [];
+    try {
+      entries = fs.readdirSync(projectRoot, { withFileTypes: true });
+    } catch {
+      entries = [];
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) roots.push(path.join(projectRoot, entry.name, "storage"));
+    }
+    if (path.basename(dataRoot) === "storage") roots.push(dataRoot);
   }
-  if (path.basename(dataRoot) === "storage") roots.push(dataRoot);
   return existingUniquePaths(roots);
 }
 
+function openCodeDatabaseFiles(env = process.env) {
+  const explicit = envPathList(env.AGENTLOG_OPENCODE_DB || env.AGENTLOG_OPENCODE_DATABASE || env.OPENCODE_DB);
+  if (explicit.length) return existingUniquePaths(explicit);
+  if ((env.AGENTLOG_OPENCODE_STORAGE_ROOTS || env.AGENTLOG_OPENCODE_STORAGE_DIR) && !(env.AGENTLOG_OPENCODE_DATA_DIR || env.OPENCODE_DATA_DIR)) return [];
+  return existingUniquePaths(openCodeDataRoots(env).flatMap((root) => [
+    path.join(root, "opencode.db"),
+    path.join(root, "storage", "opencode.db")
+  ]));
+}
+
 function openCodeSessionFiles(root) {
   const sessionRoot = path.join(root, "session");
   const files = [];
@@ -5676,6 +6641,216 @@ function openCodeSessionFiles(root) {
   return files.sort((a, b) => a.localeCompare(b));
 }
 
+function openCodeMessageSessionIds(root) {
+  const messageRoot = path.join(root, "message");
+  let entries = [];
+  try {
+    entries = fs.readdirSync(messageRoot, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name)
+    .filter(Boolean)
+    .sort((a, b) => a.localeCompare(b));
+}
+
+function readOpenCodeSqliteSessionsFromDb(dbPath) {
+  if (!safeStat(dbPath)) return [];
+  if (!sqliteTableExists(dbPath, "session") || !sqliteTableExists(dbPath, "message") || !sqliteTableExists(dbPath, "part")) return [];
+  const sessionRows = readOpenCodeSqliteSessionRows(dbPath);
+  const messageRows = readOpenCodeSqliteMessageRows(dbPath);
+  const partRows = readOpenCodeSqlitePartRows(dbPath);
+  const messagesBySession = groupRowsBy(messageRows, "session_id");
+  const partsByMessage = groupRowsBy(partRows, "message_id");
+  const storageRoot = path.join(path.dirname(dbPath), "storage");
+  const sessions = [];
+  for (const row of sessionRows) {
+    const rows = messagesBySession.get(row.id) || [];
+    const messages = stampMessages(
+      dedupeAdjacentMessages(rows.flatMap((messageRow, index) => openCodeSqliteMessagesFromRow(messageRow, partsByMessage.get(messageRow.id) || [], index)))
+        .sort((a, b) => String(a.timestamp).localeCompare(String(b.timestamp))),
+      "opencode-sqlite-history"
+    );
+    const diffFile = path.join(storageRoot, "session_diff", `${row.id}.json`);
+    const diffMessage = openCodeDiffMessage(diffFile, messages[messages.length - 1]?.timestamp || toIso(row.time_updated || row.time_created));
+    const finalMessages = diffMessage ? messages.concat(stampMessages([diffMessage], "opencode-sqlite-history")) : messages;
+    if (!finalMessages.length) continue;
+    const sourceFiles = [dbPath, safeStat(diffFile) ? diffFile : ""].filter(Boolean);
+    const startedAt = toIso(row.time_created) || finalMessages[0]?.timestamp || new Date(safeStat(dbPath)?.mtimeMs || Date.now()).toISOString();
+    const endedAt = toIso(row.time_updated) || finalMessages[finalMessages.length - 1]?.timestamp || startedAt;
+    const cwd = firstString(row.directory, row.path, row.project_worktree, openCodeCwdFromMessages(finalMessages));
+    sessions.push({
+      sessionId: `opencode-${row.id}`,
+      title: firstString(row.title, row.slug, clineTitle(finalMessages), row.id),
+      cwd,
+      startedAt,
+      endedAt,
+      messages: finalMessages,
+      sourcePath: `${dbPath}#${row.id}`,
+      sourceFiles,
+      sourceType: "opencode-sqlite-history",
+      fingerprint: openCodeSqliteSessionFingerprint(dbPath, row, rows, sourceFiles),
+      detailKey: "sqliteSessions",
+      sessionSummary: {
+        projectId: row.project_id || undefined,
+        parentId: row.parent_id || undefined,
+        workspaceId: row.workspace_id || undefined,
+        slug: row.slug || undefined,
+        version: row.version || undefined,
+        agent: row.agent || undefined,
+        model: row.model || undefined,
+        projectName: row.project_name || undefined,
+        projectWorktree: row.project_worktree || undefined
+      }
+    });
+  }
+  return sessions;
+}
+
+function readOpenCodeSqliteSessionRows(dbPath) {
+  const sessionColumns = sqliteTableColumns(dbPath, "session");
+  if (!sessionColumns.has("id")) return [];
+  const projectColumns = sqliteTableExists(dbPath, "project") ? sqliteTableColumns(dbPath, "project") : new Set();
+  const canJoinProject = sessionColumns.has("project_id") && projectColumns.has("id");
+  const selects = [
+    "s.id",
+    sqliteSelectMaybe(sessionColumns, "s", "project_id"),
+    sqliteSelectMaybe(sessionColumns, "s", "parent_id"),
+    sqliteSelectMaybe(sessionColumns, "s", "slug"),
+    sqliteSelectMaybe(sessionColumns, "s", "directory"),
+    sqliteSelectMaybe(sessionColumns, "s", "title"),
+    sqliteSelectMaybe(sessionColumns, "s", "version"),
+    sqliteSelectMaybe(sessionColumns, "s", "share_url"),
+    sqliteSelectMaybe(sessionColumns, "s", "time_created"),
+    sqliteSelectMaybe(sessionColumns, "s", "time_updated"),
+    sqliteSelectMaybe(sessionColumns, "s", "time_archived"),
+    sqliteSelectMaybe(sessionColumns, "s", "workspace_id"),
+    sqliteSelectMaybe(sessionColumns, "s", "path"),
+    sqliteSelectMaybe(sessionColumns, "s", "agent"),
+    sqliteSelectMaybe(sessionColumns, "s", "model"),
+    canJoinProject && projectColumns.has("worktree") ? "p.worktree as project_worktree" : "null as project_worktree",
+    canJoinProject && projectColumns.has("name") ? "p.name as project_name" : "null as project_name"
+  ];
+  const queryParts = [`select ${selects.join(", ")}`, "from session s"];
+  if (canJoinProject) queryParts.push("left join project p on p.id = s.project_id");
+  if (sessionColumns.has("time_archived")) queryParts.push("where coalesce(s.time_archived, 0) = 0");
+  const orderColumns = [];
+  if (sessionColumns.has("time_updated")) orderColumns.push("s.time_updated desc");
+  if (sessionColumns.has("time_created")) orderColumns.push("s.time_created desc");
+  orderColumns.push("s.id");
+  queryParts.push(`order by ${orderColumns.join(", ")}`);
+  return readSqliteJson(dbPath, queryParts.join(" "), "OpenCode SQLite sessions");
+}
+
+function readOpenCodeSqliteMessageRows(dbPath) {
+  const columns = sqliteTableColumns(dbPath, "message");
+  if (!columns.has("id") || !columns.has("session_id")) return [];
+  const selects = [
+    "id",
+    "session_id",
+    sqliteSelectMaybe(columns, "message", "time_created"),
+    sqliteSelectMaybe(columns, "message", "time_updated"),
+    sqliteSelectMaybe(columns, "message", "data")
+  ];
+  const orderColumns = ["session_id"];
+  if (columns.has("time_created")) orderColumns.push("time_created");
+  orderColumns.push("id");
+  return readSqliteJson(dbPath, `select ${selects.join(", ")} from message order by ${orderColumns.join(", ")}`, "OpenCode SQLite messages");
+}
+
+function readOpenCodeSqlitePartRows(dbPath) {
+  const columns = sqliteTableColumns(dbPath, "part");
+  if (!columns.has("id") || !columns.has("message_id") || !columns.has("session_id")) return [];
+  const selects = [
+    "id",
+    "message_id",
+    "session_id",
+    sqliteSelectMaybe(columns, "part", "time_created"),
+    sqliteSelectMaybe(columns, "part", "time_updated"),
+    sqliteSelectMaybe(columns, "part", "data")
+  ];
+  const orderColumns = ["session_id", "message_id"];
+  if (columns.has("time_created")) orderColumns.push("time_created");
+  orderColumns.push("id");
+  return readSqliteJson(dbPath, `select ${selects.join(", ")} from part order by ${orderColumns.join(", ")}`, "OpenCode SQLite parts");
+}
+
+function openCodeSqliteMessagesFromRow(row, partRows, index) {
+  const data = parseJsonObject(row.data);
+  const parts = (partRows || []).map((partRow) => ({
+    id: partRow.id,
+    messageID: partRow.message_id,
+    messageId: partRow.message_id,
+    sessionID: partRow.session_id,
+    sessionId: partRow.session_id,
+    timeCreated: partRow.time_created,
+    timeUpdated: partRow.time_updated,
+    ...parseJsonObject(partRow.data)
+  }));
+  const role = normalizeEventRole(data.role || data.type || data.actor) || openCodeRoleFromParts(parts);
+  const timestamp = toIso(data.time?.created || data.createdAt || data.created_at || row.time_created) || offsetTimestamp(new Date(Number(row.time_created) || Date.now()).toISOString(), index);
+  const text = firstString(data.content, data.text, data.message, openCodePartText(parts));
+  const toolCalls = parts.map(openCodeToolCall).filter(Boolean);
+  const toolResults = parts.map(openCodeToolResult).filter(Boolean);
+  const messageId = firstString(row.id, data.id, data.messageID, data.messageId);
+  const usage = openCodeUsageFromMessageData(data, parts);
+  const result = [];
+  if (role && (text || toolCalls.length)) {
+    result.push({
+      role,
+      content: text,
+      timestamp,
+      metadata: {
+        provider: "opencode",
+        messageId,
+        parentMessageId: firstString(data.parentID, data.parentId) || undefined,
+        requestId: usage ? messageId : undefined,
+        model: firstString(data.modelID, data.modelId, data.model?.modelID, data.model?.modelId, data.model) || undefined,
+        providerId: firstString(data.providerID, data.providerId, data.model?.providerID, data.model?.providerId) || undefined,
+        mode: firstString(data.mode) || undefined,
+        agent: firstString(data.agent) || undefined,
+        finish: firstString(data.finish) || undefined,
+        cwd: firstString(data.path?.cwd) || undefined,
+        root: firstString(data.path?.root) || undefined,
+        usage: usage || undefined,
+        cost: Number.isFinite(Number(data.cost)) ? Number(data.cost) : undefined,
+        toolCalls: toolCalls.length ? toolCalls : undefined
+      }
+    });
+  }
+  for (const toolResult of toolResults) {
+    result.push({ role: "tool", content: toolResult.output, timestamp, metadata: { provider: "opencode", messageId, toolResult } });
+  }
+  return result;
+}
+
+function openCodeUsageFromMessageData(data, parts = []) {
+  const finishPart = (parts || []).find((part) => String(part?.type || "").toLowerCase() === "step-finish" && part.tokens && typeof part.tokens === "object");
+  const tokens = data?.tokens && typeof data.tokens === "object" ? data.tokens : finishPart?.tokens;
+  if (!tokens || typeof tokens !== "object") return null;
+  const usage = {
+    input_tokens: Number.isFinite(Number(tokens.input)) ? Number(tokens.input) : undefined,
+    output_tokens: Number.isFinite(Number(tokens.output)) ? Number(tokens.output) : undefined,
+    total_tokens: Number.isFinite(Number(tokens.total)) ? Number(tokens.total) : undefined,
+    reasoning_tokens: Number.isFinite(Number(tokens.reasoning)) ? Number(tokens.reasoning) : undefined,
+    cache_creation_input_tokens: Number.isFinite(Number(tokens.cache?.write)) ? Number(tokens.cache.write) : undefined,
+    cache_read_input_tokens: Number.isFinite(Number(tokens.cache?.read)) ? Number(tokens.cache.read) : undefined
+  };
+  return Object.values(usage).some((value) => value !== undefined) ? usage : null;
+}
+
+function openCodeSqliteSessionFingerprint(dbPath, row, messageRows, sourceFiles) {
+  const sessionRevision = [
+    row.id,
+    row.time_updated || row.time_created || "",
+    messageRows.length,
+    messageRows.map((message) => `${message.id}:${message.time_updated || message.time_created || ""}`).join("|")
+  ].join(":");
+  return `${fingerprintPrefix("opencode-sqlite-history")}:${structuredSessionFingerprint({ sourcePath: dbPath, sourceFiles })}:${hashId(sessionRevision)}`;
+}
+
 function parseOpenCodeSessionFile(file, storageRoot) {
   const info = readJsonMaybe(file, null);
   if (!info || typeof info !== "object") return null;
@@ -5717,6 +6892,63 @@ function parseOpenCodeSessionFile(file, storageRoot) {
   };
 }
 
+function parseOpenCodeMessageOnlySession(storageRoot, sessionId) {
+  if (!sessionId) return null;
+  const messageFiles = openCodeMessageFiles(storageRoot, sessionId);
+  const parsedMessages = messageFiles.flatMap((messageFile, index) => openCodeMessagesFromFile(messageFile, storageRoot, index));
+  const diffFile = path.join(storageRoot, "session_diff", `${sessionId}.json`);
+  const diffMessage = openCodeDiffMessage(diffFile, parsedMessages[parsedMessages.length - 1]?.timestamp);
+  const messages = stampMessages(
+    dedupeAdjacentMessages(parsedMessages.concat(diffMessage ? [diffMessage] : [])).sort((a, b) => String(a.timestamp).localeCompare(String(b.timestamp))),
+    "opencode-history"
+  );
+  if (!messages.length) return null;
+  const sourceFiles = [
+    ...messageFiles,
+    ...messageFiles.flatMap((messageFile) => openCodePartFiles(storageRoot, firstString(readJsonMaybe(messageFile, {})?.id, path.basename(messageFile, ".json")))),
+    safeStat(diffFile) ? diffFile : ""
+  ].filter(Boolean);
+  const startedAt = messages[0]?.timestamp || "";
+  const endedAt = messages[messages.length - 1]?.timestamp || startedAt;
+  const cwd = openCodeCwdFromMessages(messages) || openCodeProjectPathFromStorage(storageRoot);
+  return {
+    sessionId: `opencode-${sessionId}`,
+    title: clineTitle(messages) || sessionId,
+    cwd,
+    startedAt,
+    endedAt,
+    messages,
+    sourcePath: path.join(storageRoot, "message", sessionId),
+    sourceFiles,
+    sourceType: "opencode-history",
+    fingerprint: `${fingerprintPrefix("opencode-history")}:${structuredSessionFingerprint({ sourcePath: path.join(storageRoot, "message", sessionId), sourceFiles })}`,
+    detailKey: "sessions"
+  };
+}
+
+function openCodeCwdFromMessages(messages) {
+  for (const message of messages || []) {
+    const cwd = firstString(message?.metadata?.cwd, message?.metadata?.directory, message?.metadata?.projectPath);
+    if (cwd) return cwd;
+    const fromContent = openCodePathFromText(message?.content);
+    if (fromContent) return fromContent;
+    for (const toolCall of message?.metadata?.toolCalls || []) {
+      const fromTool = openCodePathFromText(JSON.stringify(toolCall.arguments || toolCall.argument || ""));
+      if (fromTool) return fromTool;
+    }
+  }
+  return "";
+}
+
+function openCodePathFromText(text) {
+  const value = String(text || "");
+  const cdMatch = value.match(/\bcd\s+["']?([^"'\s]+)["']?/);
+  const candidate = cdMatch ? cdMatch[1] : value.match(/(?:working\s+)?directory[:=\s]+["']?([^"'\s]+)["']?/i)?.[1];
+  if (!candidate) return "";
+  const expanded = candidate.startsWith("~/") ? path.join(os.homedir(), candidate.slice(2)) : candidate;
+  return path.isAbsolute(expanded) && fs.existsSync(expanded) ? expanded : "";
+}
+
 function openCodeProjectInfo(storageRoot, projectId) {
   const file = projectId ? path.join(storageRoot, "project", `${projectId}.json`) : "";
   const data = file ? readJsonMaybe(file, {}) : {};
@@ -5887,10 +7119,14 @@ function openCodeDiffText(value) {
   if (typeof value === "string") return value.trim();
   if (Array.isArray(value)) return value.map(openCodeDiffText).filter(Boolean).join("\n");
   if (typeof value !== "object") return String(value);
+  const file = firstString(value.path, value.file, value.filename);
   for (const key of ["diff", "patch", "text", "content"]) {
-    if (typeof value[key] === "string" && value[key].trim()) return value[key].trim();
+    if (typeof value[key] === "string" && value[key].trim()) {
+      const body = value[key].trim();
+      if (file && !/^diff --git\s/m.test(body)) return `diff --git a/${file} b/${file}\n${body}`;
+      return body;
+    }
   }
-  const file = firstString(value.path, value.file, value.filename);
   const body = openCodeDiffText(value.hunks || value.changes || value.edits);
   if (file && body) return `diff --git a/${file} b/${file}\n${body}`;
   return "";
@@ -6024,6 +7260,7 @@ function aiderMarkdownMessages(text, fallbackTime) {
 }
 
 function dedupeStructuredSessions(sessions, provider) {
+  if (provider === "opencode") return dedupeOpenCodeSessions(sessions);
   const seen = new Set();
   const result = [];
   for (const session of sessions) {
@@ -6035,6 +7272,30 @@ function dedupeStructuredSessions(sessions, provider) {
   return result;
 }
 
+function dedupeOpenCodeSessions(sessions) {
+  const bySessionId = new Map();
+  const order = [];
+  for (const session of sessions || []) {
+    const key = `opencode:${session.sessionId}`;
+    const existing = bySessionId.get(key);
+    if (!existing) {
+      bySessionId.set(key, session);
+      order.push(key);
+      continue;
+    }
+    const preferred = openCodeSourceRank(session.sourceType) > openCodeSourceRank(existing.sourceType) ? session : existing;
+    preferred.sourceFiles = existingUniquePaths([...(existing.sourceFiles || []), ...(session.sourceFiles || [])]);
+    bySessionId.set(key, preferred);
+  }
+  return order.map((key) => bySessionId.get(key)).filter(Boolean);
+}
+
+function openCodeSourceRank(sourceType) {
+  if (sourceType === "opencode-sqlite-history") return 3;
+  if (sourceType === "opencode-history") return 2;
+  return 1;
+}
+
 function readDevinSessions(env = process.env, options = {}) {
   const db = devinSessionsDb(env);
   reportDiscoveryProgress(options, { current: 0, total: fs.existsSync(db) ? 1 : 0, message: "opening Devin sessions database", path: db });
@@ -6150,6 +7411,9 @@ function devinMessagesFromNode(row) {
   if (role === "system" || devinIsContextUserMessage(role, content)) return [];
   const toolResult = role === "tool" ? devinNormalizeToolResult(content, data) : null;
   const body = role === "tool" ? content : devinVisibleContent(content, toolCalls);
+  const usage = role === "assistant" ? devinUsage(data) : null;
+  const model = role === "assistant" ? firstString(data.metadata?.generation_model, data.model, data.model_id, data.modelId) : "";
+  const requestId = role === "assistant" ? firstString(data.metadata?.request_id, data.request_id, data.message_id) : "";
   if (!body && !toolCalls.length && !toolResult) return [];
   return [
     {
@@ -6162,6 +7426,9 @@ function devinMessagesFromNode(row) {
         parentNodeId: row.parent_node_id ?? undefined,
         toolCalls: toolCalls.length ? toolCalls.map(devinPublicToolCall) : undefined,
         toolResult: toolResult || undefined,
+        usage: usage || undefined,
+        model: model || undefined,
+        requestId: requestId || undefined,
         sourceType: "devin-cli-history",
         parserVersion: parserVersionForSource("devin-cli-history")
       }
@@ -6169,6 +7436,25 @@ function devinMessagesFromNode(row) {
   ];
 }
 
+function devinUsage(message = {}) {
+  const metrics = message?.metadata?.metrics;
+  if (!metrics || typeof metrics !== "object") return null;
+  const inputTokens = numericValue(metrics.input_tokens, metrics.inputTokens, metrics.prompt_tokens, metrics.promptTokens);
+  const outputTokens = numericValue(metrics.output_tokens, metrics.outputTokens, metrics.completion_tokens, metrics.completionTokens, message?.metadata?.num_tokens);
+  const cacheCreationInputTokens = numericValue(metrics.cache_creation_tokens, metrics.cache_creation_input_tokens, metrics.cacheCreationInputTokens);
+  const cacheReadInputTokens = numericValue(metrics.cache_read_tokens, metrics.cache_read_input_tokens, metrics.cacheReadInputTokens);
+  if ([inputTokens, outputTokens, cacheCreationInputTokens, cacheReadInputTokens].every((value) => value == null)) return null;
+  const usage = {
+    inputTokens: inputTokens ?? undefined,
+    outputTokens: outputTokens ?? undefined,
+    cacheCreationInputTokens: cacheCreationInputTokens ?? undefined,
+    cacheReadInputTokens: cacheReadInputTokens ?? undefined
+  };
+  const totalTokens = [inputTokens, outputTokens].reduce((sum, value) => sum + (value || 0), 0);
+  if (totalTokens) usage.totalTokens = totalTokens;
+  return usage;
+}
+
 function devinVisibleContent(content, toolCalls) {
   const value = String(content || "").trim();
   if (toolCalls.length && /^none$/i.test(value)) return "";
@@ -6292,8 +7578,9 @@ function readGeminiCliSessions(options = {}, env = process.env) {
   reportDiscoveryProgress(options, { current: 0, total: files.length, message: "reading saved chats and checkpoints" });
   for (let index = 0; index < files.length; index++) {
     const file = files[index];
-    const parsed = parseGeminiCliHistoryFile(file);
-    if (parsed) sessions.push(parsed);
+    for (const parsed of asArray(parseGeminiCliHistoryFile(file))) {
+      if (parsed) sessions.push(parsed);
+    }
     reportDiscoveryProgress(options, { current: index + 1, total: files.length, message: `${sessions.length} importable`, path: file });
   }
   return coalesceGeminiCliSessions(sessions);
@@ -6476,17 +7763,26 @@ function parseGeminiCliHistoryFile(file) {
   const stat = safeStat(file);
   const fallbackTime = new Date(stat?.mtimeMs || Date.now()).toISOString();
   const ext = path.extname(file).toLowerCase();
-  let parsed = null;
+  let parsedItems = [];
   try {
-    if (ext === ".jsonl") parsed = parseGeminiCliJsonl(fs.readFileSync(file, "utf8"), { fallbackTime });
-    else if (ext === ".md" || ext === ".markdown") parsed = parseMarkdownChatFile(file, "gemini-cli", fallbackTime);
-    else parsed = parseGeminiCliJson(JSON.parse(fs.readFileSync(file, "utf8")), { fallbackTime });
+    if (ext === ".jsonl") parsedItems = parseGeminiCliJsonlSessions(fs.readFileSync(file, "utf8"), { fallbackTime });
+    else if (ext === ".md" || ext === ".markdown") parsedItems = [parseMarkdownChatFile(file, "gemini-cli", fallbackTime)].filter(Boolean);
+    else parsedItems = parseGeminiCliJsonSessions(JSON.parse(fs.readFileSync(file, "utf8")), { fallbackTime });
   } catch {
     return null;
   }
+  const multiSessionSource = parsedItems.length > 1;
+  return parsedItems
+    .map((parsed, index) => geminiCliParsedSession(file, stat, fallbackTime, ext, parsed, { multiSessionSource, index }))
+    .filter(Boolean);
+}
+
+function geminiCliParsedSession(file, stat, fallbackTime, ext, parsed, options = {}) {
   if (!parsed || !parsed.messages.length) return null;
   const cwd = parsed.cwd || geminiProjectCwd(file);
   const sessionId = parsed.sessionId || stableSessionId("gemini_cli", file, parsed.startedAt || fallbackTime, parsed.messages);
+  const sourceFingerprint = fileFingerprint(file, stat);
+  const fingerprint = options.multiSessionSource ? `${sourceFingerprint}:session:${hashId(sessionId || options.index)}` : sourceFingerprint;
   return {
     sessionId,
     title: parsed.title || path.basename(file, ext),
@@ -6497,8 +7793,9 @@ function parseGeminiCliHistoryFile(file) {
     sourcePath: file,
     sourceFiles: [file],
     sourceType: "gemini-cli-history",
-    fingerprint: `${fingerprintPrefix("gemini-cli-history")}:${fileFingerprint(file, stat)}`,
-    detailKey: "files"
+    fingerprint: `${fingerprintPrefix("gemini-cli-history")}:${fingerprint}`,
+    detailKey: "files",
+    sessionSummary: parsed.sessionSummary || undefined
   };
 }
 
@@ -6526,6 +7823,121 @@ function parseMarkdownChatFile(file, source, fallbackTime) {
   };
 }
 
+function readWindsurfTrajectoryExport(target, options = {}) {
+  const files = windsurfTrajectoryFiles(target);
+  const sessions = [];
+  reportDiscoveryProgress(options, { current: 0, total: files.length, message: "reading Windsurf trajectory exports" });
+  for (let index = 0; index < files.length; index++) {
+    const file = files[index];
+    const session = parseWindsurfTrajectoryFile(file);
+    if (session) sessions.push(session);
+    reportDiscoveryProgress(options, { current: index + 1, total: files.length, message: `${sessions.length} importable`, path: file });
+  }
+  return sessions;
+}
+
+function windsurfTrajectoryFiles(target) {
+  const resolved = path.resolve(target);
+  const stat = safeStat(resolved);
+  if (!stat) throw new Error(`Cannot read Windsurf trajectory export path ${target}`);
+  if (stat.isFile()) return isMarkdownFile(resolved) ? [resolved] : [];
+  if (!stat.isDirectory()) return [];
+  const files = [];
+  collectFiles(resolved, (file) => {
+    if (isMarkdownFile(file)) files.push(file);
+  });
+  return files.sort((a, b) => a.localeCompare(b));
+}
+
+function isMarkdownFile(file) {
+  return [".md", ".markdown"].includes(path.extname(file).toLowerCase());
+}
+
+function parseWindsurfTrajectoryFile(file) {
+  const stat = safeStat(file);
+  const fallbackTime = new Date(stat?.mtimeMs || Date.now()).toISOString();
+  let text = "";
+  try {
+    text = fs.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+  if (!looksLikeWindsurfTrajectory(text)) return null;
+  const messages = windsurfTrajectoryMessages(text, fallbackTime);
+  if (!messages.length) return null;
+  const stampedMessages = stampMessages(messages, "windsurf-trajectory-export");
+  const startedAt = stampedMessages[0]?.timestamp || fallbackTime;
+  const endedAt = stampedMessages[stampedMessages.length - 1]?.timestamp || fallbackTime;
+  const cwd = inferCwdFromMarkdownText(text);
+  return {
+    sessionId: stableSessionId("windsurf", file, startedAt, stampedMessages),
+    title: windsurfTrajectoryTitle(text, stampedMessages, file),
+    cwd,
+    scopeCanonical: cwd ? "" : uncategorizedScope("windsurf"),
+    startedAt,
+    endedAt,
+    messages: stampedMessages,
+    sourcePath: file,
+    sourceFiles: [file],
+    sourceType: "windsurf-trajectory-export",
+    fingerprint: `${fingerprintPrefix("windsurf-trajectory-export")}:${fileFingerprint(file, stat)}:${hashId(stampedMessages.map((message) => `${message.role}:${message.content}`).join("\n"))}`,
+    detailKey: "exports"
+  };
+}
+
+function looksLikeWindsurfTrajectory(text) {
+  return /^#\s+Cascade Chat Conversation\s*$/im.test(String(text || "")) && /^###\s+(User Input|Planner Response|Assistant Response|Cascade Response)\s*$/im.test(String(text || ""));
+}
+
+function windsurfTrajectoryMessages(text, fallbackTime) {
+  const messages = [];
+  let role = "";
+  let heading = "";
+  let current = [];
+  const flush = () => {
+    const content = current.join("\n").trim();
+    if (role && content) {
+      messages.push({
+        role,
+        content,
+        timestamp: new Date(new Date(fallbackTime).getTime() + messages.length).toISOString(),
+        metadata: { source: "windsurf-trajectory-export", heading }
+      });
+    }
+    current = [];
+  };
+  for (const line of String(text || "").split(/\r?\n/)) {
+    const match = line.match(/^###\s+(.+?)\s*$/);
+    const nextRole = match ? windsurfTrajectoryRole(match[1]) : "";
+    if (match && nextRole) {
+      flush();
+      role = nextRole;
+      heading = match[1].trim();
+    } else if (role) {
+      current.push(line);
+    }
+  }
+  flush();
+  return messages;
+}
+
+function windsurfTrajectoryRole(label) {
+  const value = String(label || "").trim().toLowerCase();
+  if (/(user|human).*(input|prompt|message)?/.test(value)) return "user";
+  if (/(planner|assistant|cascade|agent|model).*(response|output|message)?/.test(value)) return "assistant";
+  if (/system/.test(value)) return "system";
+  if (/tool/.test(value)) return "tool";
+  return "";
+}
+
+function windsurfTrajectoryTitle(text, messages, file) {
+  const title = markdownTitle(text);
+  if (title && !/^Cascade Chat Conversation$/i.test(title)) return title;
+  const firstUser = messages.find((message) => message.role === "user");
+  const line = firstLine(firstUser?.content);
+  return line ? line.slice(0, 120) : path.basename(file, path.extname(file));
+}
+
 function readWindsurfSessions(options = {}) {
   // Kept for future decoder work only. Windsurf's current Cascade transcript
   // stores are encrypted binary files, so this source is disabled from public
@@ -6560,8 +7972,9 @@ function readWindsurfSessions(options = {}) {
 }
 
 function readAntigravitySessions(options = {}, env = process.env) {
-  const roots = [path.join(os.homedir(), ".gemini", "antigravity", "brain")];
-  const sessions = readMarkdownArtifactSessions({
+  const home = antigravityHome(env);
+  const roots = [path.join(home, "brain")];
+  const artifactSessions = readMarkdownArtifactSessions({
     provider: "antigravity",
     roots,
     sourceType: "antigravity-brain",
@@ -6569,7 +7982,11 @@ function readAntigravitySessions(options = {}, env = process.env) {
     artifactNames: ["task.md", "implementation_plan.md", "walkthrough.md", "plan.md"],
     options
   });
-  const binaryCount = countFiles(path.join(os.homedir(), ".gemini", "antigravity", "conversations"), (file) => file.endsWith(".pb"));
+  const artifactSessionIds = new Set(artifactSessions.map((session) => session.sessionId));
+  const trajectorySessions = readAntigravityTrajectorySummarySessions(options, env)
+    .filter((session) => !artifactSessionIds.has(session.sessionId));
+  const sessions = [...artifactSessions, ...trajectorySessions];
+  const binaryCount = countFiles(path.join(home, "conversations"), (file) => file.endsWith(".pb"));
   if (binaryCount && sessions.length) sessions[0].binaryCount = binaryCount;
   else if (binaryCount) {
     sessions.push({
@@ -6580,7 +7997,7 @@ function readAntigravitySessions(options = {}, env = process.env) {
       startedAt: new Date().toISOString(),
       endedAt: new Date().toISOString(),
       messages: [],
-      sourcePath: path.join(os.homedir(), ".gemini", "antigravity", "conversations"),
+      sourcePath: path.join(home, "conversations"),
       sourceType: "antigravity-protobuf",
       binaryCount,
       detailKey: "tasks"
@@ -6589,6 +8006,205 @@ function readAntigravitySessions(options = {}, env = process.env) {
   return sessions;
 }
 
+function antigravityHome(env = process.env) {
+  return env.AGENTLOG_ANTIGRAVITY_HOME_DIR || path.join(geminiHome(env), "antigravity");
+}
+
+function antigravityGlobalStateDbs(env = process.env) {
+  const explicit = envPathList(env.AGENTLOG_ANTIGRAVITY_GLOBAL_STORAGE_DB || env.AGENTLOG_ANTIGRAVITY_GLOBAL_STATE_DB);
+  if (explicit.length) return existingUniquePaths(explicit);
+  const appRoots = envPathList(env.AGENTLOG_ANTIGRAVITY_APP_SUPPORT_DIR);
+  if (!appRoots.length) {
+    appRoots.push(
+      path.join(os.homedir(), "Library", "Application Support", "Antigravity"),
+      path.join(os.homedir(), ".config", "Antigravity"),
+      path.join(os.homedir(), "AppData", "Roaming", "Antigravity")
+    );
+  }
+  return existingUniquePaths([
+    ...explicit,
+    ...appRoots.flatMap((root) => [
+      path.join(root, "User", "globalStorage", "state.vscdb"),
+      path.join(root, "User", "globalStorage", "state.vscdb.backup")
+    ])
+  ]);
+}
+
+function readAntigravityTrajectorySummarySessions(options = {}, env = process.env) {
+  const dbs = antigravityGlobalStateDbs(env);
+  if (!dbs.length) return [];
+  const sessions = [];
+  const seen = new Set();
+  reportDiscoveryProgress(options, { current: 0, total: dbs.length, message: "reading trajectory summaries" });
+  for (let index = 0; index < dbs.length; index++) {
+    const db = dbs[index];
+    try {
+      for (const session of antigravityTrajectorySummarySessionsFromDb(db, env)) {
+        if (seen.has(session.sessionId)) continue;
+        seen.add(session.sessionId);
+        sessions.push(session);
+      }
+    } catch (error) {
+      reportDiscoveryProgress(options, { current: index + 1, total: dbs.length, message: error.message, path: db });
+      continue;
+    }
+    reportDiscoveryProgress(options, { current: index + 1, total: dbs.length, message: `${sessions.length} summaries`, path: db });
+  }
+  if (sessions.length) sessions[0].stateDbCount = dbs.length;
+  return sessions.sort((a, b) => String(a.startedAt).localeCompare(String(b.startedAt)) || a.sessionId.localeCompare(b.sessionId));
+}
+
+function antigravityTrajectorySummarySessionsFromDb(db, env = process.env) {
+  if (!fs.existsSync(db)) return [];
+  const rows = readSqliteJson(
+    db,
+    "SELECT value FROM ItemTable WHERE key='antigravityUnifiedStateSync.trajectorySummaries'",
+    "Antigravity global state"
+  );
+  const encoded = firstString(...rows.map((row) => row.value));
+  if (!encoded) return [];
+  return parseAntigravityTrajectorySummaries(encoded, { db, env });
+}
+
+function parseAntigravityTrajectorySummaries(encoded, context = {}) {
+  const outer = decodeProtoMessage(bufferFromBase64(encoded));
+  const sessions = [];
+  for (const entry of outer.filter((field) => field.number === 1 && field.wireType === 2)) {
+    const session = antigravityTrajectorySummarySession(entry.bytes, context);
+    if (session) sessions.push(session);
+  }
+  return sessions;
+}
+
+function antigravityTrajectorySummarySession(entryBytes, context = {}) {
+  const entry = decodeProtoMessage(entryBytes);
+  const id = protoString(firstProtoField(entry, 1));
+  const wrapper = firstProtoField(entry, 2);
+  const summaryEnvelope = wrapper?.bytes ? decodeProtoMessage(wrapper.bytes) : [];
+  const summaryEncoded = protoString(firstProtoField(summaryEnvelope, 1));
+  if (!id || !summaryEncoded) return null;
+
+  const sourceType = "antigravity-trajectory-summary";
+  const summaryBytes = bufferFromBase64(summaryEncoded);
+  const fields = decodeProtoMessage(summaryBytes);
+  const prompt = cleanAntigravityText(protoString(firstProtoField(fields, 1)));
+  if (!prompt) return null;
+  const startedAt = antigravitySummaryTimestamp(fields, 7) || antigravitySummaryTimestamp(fields, 3) || antigravitySummaryTimestamp(fields, 10) || new Date().toISOString();
+  const endedAt = antigravitySummaryTimestamp(fields, 10) || antigravitySummaryTimestamp(fields, 3) || startedAt;
+  const cwd = antigravitySummaryCwd(fields);
+  const assistantSummary = antigravityAssistantSummary(fields, prompt);
+  const messages = [
+    {
+      role: "user",
+      content: prompt,
+      timestamp: startedAt,
+      metadata: {
+        provider: "antigravity",
+        source: sourceType,
+        providerConversationId: id,
+        partialSummary: true
+      }
+    }
+  ];
+  if (assistantSummary) {
+    messages.push({
+      role: "assistant",
+      content: `# Antigravity Trajectory Summary\n\n${assistantSummary}`,
+      timestamp: endedAt,
+      metadata: {
+        provider: "antigravity",
+        source: sourceType,
+        providerConversationId: id,
+        partialSummary: true
+      }
+    });
+  }
+  const db = context.db || "";
+  return {
+    sessionId: `antigravity-${id}`,
+    providerConversationId: id,
+    title: antigravitySummaryTitle(prompt),
+    cwd,
+    scopeCanonical: cwd ? "" : "antigravity/uncategorized",
+    startedAt,
+    endedAt,
+    messages: stampMessages(messages, sourceType),
+    sourcePath: `antigravity-state:${db || "globalStorage/state.vscdb"}#trajectorySummaries/${id}`,
+    sourceFiles: [],
+    sourceType,
+    fingerprint: `${fingerprintPrefix(sourceType)}:${db}:${id}:${hashId(summaryEncoded)}`,
+    detailKey: "trajectorySummaries",
+    partialSummary: true,
+    rawReferences: db
+      ? [
+          {
+            originalPath: db,
+            entryPath: `ItemTable/antigravityUnifiedStateSync.trajectorySummaries/${id}`,
+            conversationId: id,
+            note: "Antigravity trajectory summary state row. The global state DB is referenced but not copied because it can contain auth tokens."
+          }
+        ]
+      : undefined,
+    sessionSummary: {
+      source: sourceType,
+      partial: true,
+      note: "Imported from Antigravity trajectory summary metadata. Full binary conversation bodies are not decoded."
+    }
+  };
+}
+
+function antigravitySummaryTimestamp(fields, number) {
+  const field = firstProtoField(fields, number);
+  if (!field?.bytes) return "";
+  const timestamp = decodeProtoMessage(field.bytes);
+  const seconds = protoVarintValue(firstProtoField(timestamp, 1));
+  const nanos = protoVarintValue(firstProtoField(timestamp, 2)) || 0;
+  if (!Number.isFinite(seconds) || seconds < 946684800 || seconds > 4102444800) return "";
+  return new Date((seconds * 1000) + Math.floor(nanos / 1e6)).toISOString();
+}
+
+function antigravitySummaryCwd(fields) {
+  const candidates = collectProtoStrings(fields)
+    .filter((value) => value.startsWith("file://"))
+    .map((value) => {
+      try {
+        return fileURLToPath(value);
+      } catch {
+        return "";
+      }
+    })
+    .filter(Boolean)
+    .map((candidate) => {
+      const stat = safeStat(candidate);
+      return stat?.isFile() ? path.dirname(candidate) : candidate;
+    })
+    .filter((candidate) => candidate && !candidate.includes(`${path.sep}.gemini${path.sep}antigravity${path.sep}`))
+    .filter((candidate) => !cursorIsSystemRootPath(candidate));
+  return candidates[0] || "";
+}
+
+function antigravityAssistantSummary(fields, prompt) {
+  const promptValue = cleanAntigravityText(prompt);
+  return collectProtoStrings(fields)
+    .map(cleanAntigravityText)
+    .filter((value) => value && value !== promptValue)
+    .filter((value) => value.length >= 80)
+    .filter((value) => !value.startsWith("file://"))
+    .filter((value) => !isLikelyBase64(value))
+    .filter((value) => !/^[0-9a-f-]{32,}$/i.test(value))
+    .sort((a, b) => b.length - a.length)[0] || "";
+}
+
+function antigravitySummaryTitle(prompt) {
+  const value = cleanAntigravityText(prompt);
+  if (!value) return "Antigravity trajectory summary";
+  return value.length > 80 ? `${value.slice(0, 77).trimEnd()}...` : value;
+}
+
+function cleanAntigravityText(value) {
+  return String(value || "").replace(/\s+/g, " ").trim();
+}
+
 function readMarkdownArtifactSessions({ provider, roots, sourceType, detailKey, artifactNames, options = {} }) {
   const dirs = [];
   for (const root of roots) {
@@ -6738,16 +8354,22 @@ function inferCwdFromMarkdownFiles(files) {
     } catch {
       continue;
     }
-    const match = text.match(/file:\/\/([^)\]\s]+)/);
-    if (!match) continue;
-    try {
-      const pathname = fileURLToPath(match[0]);
-      if (fs.existsSync(pathname)) return fs.statSync(pathname).isDirectory() ? pathname : path.dirname(pathname);
-      const existing = nearestExistingParent(pathname);
-      if (existing) return existing;
-    } catch {
-      // Try the next candidate.
-    }
+    const cwd = inferCwdFromMarkdownText(text);
+    if (cwd) return cwd;
+  }
+  return "";
+}
+
+function inferCwdFromMarkdownText(text) {
+  const match = String(text || "").match(/file:\/\/([^)\]\s]+)/);
+  if (!match) return "";
+  try {
+    const pathname = fileURLToPath(match[0]);
+    if (fs.existsSync(pathname)) return fs.statSync(pathname).isDirectory() ? pathname : path.dirname(pathname);
+    const existing = nearestExistingParent(pathname);
+    if (existing) return existing;
+  } catch {
+    return "";
   }
   return "";
 }
@@ -6813,6 +8435,111 @@ function countFiles(root, predicate) {
   return count;
 }
 
+function bufferFromBase64(value) {
+  try {
+    return Buffer.from(String(value || ""), "base64");
+  } catch {
+    return Buffer.alloc(0);
+  }
+}
+
+function decodeProtoMessage(buffer) {
+  const fields = [];
+  const bytes = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer || []);
+  let offset = 0;
+  while (offset < bytes.length) {
+    const key = readProtoVarint(bytes, offset);
+    if (!key) break;
+    offset = key.offset;
+    const fieldNumber = Math.floor(key.value / 8);
+    const wireType = key.value % 8;
+    if (!fieldNumber) break;
+    if (wireType === 0) {
+      const value = readProtoVarint(bytes, offset);
+      if (!value) break;
+      offset = value.offset;
+      fields.push({ number: fieldNumber, wireType, value: value.value });
+      continue;
+    }
+    if (wireType === 1) {
+      if (offset + 8 > bytes.length) break;
+      fields.push({ number: fieldNumber, wireType, bytes: bytes.subarray(offset, offset + 8) });
+      offset += 8;
+      continue;
+    }
+    if (wireType === 2) {
+      const length = readProtoVarint(bytes, offset);
+      if (!length) break;
+      offset = length.offset;
+      if (length.value < 0 || offset + length.value > bytes.length) break;
+      const value = bytes.subarray(offset, offset + length.value);
+      offset += length.value;
+      fields.push({ number: fieldNumber, wireType, bytes: value, text: printableUtf8(value) });
+      continue;
+    }
+    if (wireType === 5) {
+      if (offset + 4 > bytes.length) break;
+      fields.push({ number: fieldNumber, wireType, bytes: bytes.subarray(offset, offset + 4) });
+      offset += 4;
+      continue;
+    }
+    break;
+  }
+  return fields;
+}
+
+function readProtoVarint(buffer, offset) {
+  let value = 0n;
+  let shift = 0n;
+  for (let index = offset; index < buffer.length; index++) {
+    const byte = buffer[index];
+    value |= BigInt(byte & 0x7f) << shift;
+    if ((byte & 0x80) === 0) {
+      if (value > BigInt(Number.MAX_SAFE_INTEGER)) return null;
+      return { value: Number(value), offset: index + 1 };
+    }
+    shift += 7n;
+    if (shift > 63n) return null;
+  }
+  return null;
+}
+
+function printableUtf8(buffer) {
+  if (!buffer?.length) return "";
+  const text = buffer.toString("utf8");
+  if (text.includes("\uFFFD")) return "";
+  if (/[\x00-\x08\x0b\x0c\x0e-\x1f]/.test(text)) return "";
+  return text;
+}
+
+function firstProtoField(fields, number) {
+  return (fields || []).find((field) => field.number === number) || null;
+}
+
+function protoString(field) {
+  return field?.wireType === 2 ? field.text || "" : "";
+}
+
+function protoVarintValue(field) {
+  return field?.wireType === 0 ? field.value : null;
+}
+
+function collectProtoStrings(fields, depth = 0) {
+  const strings = [];
+  if (depth > 8) return strings;
+  for (const field of fields || []) {
+    if (field.wireType !== 2 || !field.bytes) continue;
+    if (field.text) strings.push(field.text);
+    strings.push(...collectProtoStrings(decodeProtoMessage(field.bytes), depth + 1));
+  }
+  return strings;
+}
+
+function isLikelyBase64(value) {
+  const text = String(value || "").trim();
+  return text.length >= 80 && text.length % 4 === 0 && /^[A-Za-z0-9+/]+={0,2}$/.test(text);
+}
+
 function envPathList(value) {
   return String(value || "")
     .split(new RegExp(`[${escapeRegExp(path.delimiter)},]`))
@@ -6843,6 +8570,30 @@ function readJsonMaybe(file, fallback = null) {
   }
 }
 
+function parseJsonObject(value, fallback = {}) {
+  if (value && typeof value === "object" && !Array.isArray(value)) return value;
+  if (typeof value !== "string" || !value.trim()) return fallback;
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+function groupRowsBy(rows, key) {
+  const grouped = new Map();
+  for (const row of rows || []) {
+    const value = row?.[key];
+    if (value === undefined || value === null || value === "") continue;
+    const groupKey = String(value);
+    const group = grouped.get(groupKey) || [];
+    group.push(row);
+    grouped.set(groupKey, group);
+  }
+  return grouped;
+}
+
 function defaultSkipDirs() {
   return new Set([".git", "node_modules", "vendor", "dist", "build", ".next", ".cache", ".venv", "venv", "__pycache__"]);
 }
@@ -7037,6 +8788,7 @@ module.exports = {
   mergeCursorRawAssistantOnlySessions,
   mergeCursorRawCompanionSessions,
   importCliHistory,
+  importWindsurfTrajectoryExport,
   importWebChat,
   normalizeEventRole,
   parseClaudeDesktopSessionFile,
@@ -7046,18 +8798,26 @@ module.exports = {
   providerAdapterForSource,
   providerAdapterSources,
   geminiCliHistoryFiles,
+  openCodeDatabaseFiles,
   openCodeStorageRoots,
   readCursorProjectTranscriptSessions,
   readCursorGlobalDiskKvSessionsFromDb,
   readCursorRawSqliteSalvageSessionsFromDb,
   readAiderSessions,
+  readAntigravitySessions,
   readClineSessions,
   readDevinSessionsFromDb,
   readGeminiCliSessions,
   readOpenCodeSessions,
+  readWindsurfTrajectoryExport,
   readExportBundle,
   readExportJson,
   normalizeWebConversations,
   claudeFileHistoryFiles,
-  claudeFileHistoryRoot
+  claudeFileHistoryRoot,
+  __cursorTestables: {
+    cursorAttributionCwd,
+    cursorIsSystemRootPath,
+    cursorMostFrequentExistingCwd
+  }
 };