agentel 0.2.4 → 0.2.6

package/src/importers.js

@@ -19,9 +19,12 @@ const { parseGeminiCliJsonSessions, parseGeminiCliJsonlSessions } = require("./i
 const { importSourceWithAdapter, providerAdapterForSource, providerAdapterSources } = require("./importers/providers");
 const { parseSince } = require("./importers/shared");
 const { canonicalWebProvider, derivedAccountId, getWebAccount, upsertWebAccount } = require("./web-accounts");
+const { manualImportInstructionResult } = require("./web-export-instructions");
 
 const WEB_TOKEN_ESTIMATE_CHARS = 4;
 const WEB_CHAT_TOKEN_ESTIMATION_METHOD = "web-message-parts-chars-v1";
+const OPENCODE_SOURCE_KINDS = new Set(["cli", "desktop", "web"]);
+const OPENCODE_SESSION_ID_RE = /\bses_[A-Za-z0-9]+\b/g;
 
 function importCliHistory(options = {}, env = process.env) {
   const source = options.source || "all";
@@ -44,6 +47,7 @@ function importProviderHelpers() {
     importCursorProvider,
     importJsonlProvider,
     importStructuredProvider,
+    manualImportInstructionResult,
     readAntigravitySessions,
     readAiderSessions,
     readClineSessions,
@@ -76,6 +80,7 @@ function importJsonlProvider(provider, roots, since, options = {}, env = process
   const archived = archivedSessionKeys(env);
   const files =
     provider === "claude_code" ? claudeFiles(env) : provider === "claude_sdk" ? claudeSdkFiles(env) : jsonlFiles(roots);
+  const claudeCodeMetadata = provider === "claude_code" ? claudeCodeSessionMetadataByCliSessionId(env) : new Map();
 
   const candidates = files
     .map((file) => ({ file, stat: safeStat(file) }))
@@ -95,7 +100,11 @@ function importJsonlProvider(provider, roots, since, options = {}, env = process
   for (let index = 0; index < candidates.length; index++) {
     const item = candidates[index];
     const sourceType = jsonlProviderSourceType(provider);
-    const fingerprint = `${fingerprintPrefix(sourceType)}:${fileFingerprint(item.file, item.stat)}`;
+    const baseFingerprint = `${fingerprintPrefix(sourceType)}:${fileFingerprint(item.file, item.stat)}`;
+    const preliminaryMetadata = provider === "claude_code"
+      ? claudeCodeMetadata.get(claudeSessionIdFromFilename(item.file)) || null
+      : null;
+    let fingerprint = claudeCodeImportFingerprint(baseFingerprint, preliminaryMetadata);
     if (alreadyImportedFile(state, fingerprint, archived, provider)) {
       summary.skipped++;
       reportProgress(options, summary, index + 1, item.file);
@@ -115,15 +124,17 @@ function importJsonlProvider(provider, roots, since, options = {}, env = process
       reportProgress(options, summary, index + 1, item.file);
       continue;
     }
-    const cwd = parsed.cwd || "";
+    const sessionId = parsed.sessionId || stableSessionId(provider, item.file, parsed.startedAt, parsed.messages);
+    const sessionMetadata = preliminaryMetadata || claudeCodeMetadata.get(sessionId) || null;
+    fingerprint = claudeCodeImportFingerprint(baseFingerprint, sessionMetadata);
+    const cwd = parsed.cwd || sessionMetadata?.cwd || "";
     const scopeCanonical = cwd ? "" : uncategorizedScope(provider);
-    const repo = cwd ? canonicalRepo(cwd) : null;
+    const repo = repoInfoForImport(provider, cwd, sessionMetadata);
     if (options.repos && options.repos.length && (!repo || !options.repos.includes(repo.key))) {
       summary.skipped++;
       reportProgress(options, summary, index + 1, item.file);
       continue;
     }
-    const sessionId = parsed.sessionId || stableSessionId(provider, item.file, parsed.startedAt, parsed.messages);
     if (alreadyImported(state, sessionId, fingerprint, archived, provider)) {
       state.files[fingerprint] = { sessionId, duplicate: true, at: new Date().toISOString() };
       summary.skipped++;
@@ -145,9 +156,10 @@ function importJsonlProvider(provider, roots, since, options = {}, env = process
           startedAt: parsed.startedAt,
           endedAt: parsed.endedAt,
           sourcePath: item.file,
-          sourceFiles: [item.file, ...auxiliaryFiles],
+          sourceFiles: [item.file, sessionMetadata?.sourcePath || "", ...auxiliaryFiles].filter(Boolean),
           sourceType,
-          title: parsed.title
+          title: jsonlSessionTitleForImport(parsed, sessionMetadata),
+          sessionSummary: mergeSessionSummaries(claudeCodeSidecarSessionSummary(sessionMetadata), parsed.sessionSummary)
         },
         env
       );
@@ -169,10 +181,16 @@ function jsonlProviderSourceType(provider) {
   return "cli-history";
 }
 
+function codexThreadSourceType(thread) {
+  if (thread.source === "vscode") return "codex-desktop-history";
+  if (thread.source === "exec") return "codex-sdk-history";
+  return "codex-cli-history";
+}
+
 function importClaudeDesktopProvider(provider, since, options = {}, env = process.env) {
   const state = loadImportState(env);
   const archived = archivedSessionKeys(env);
-  const sessions = readClaudeDesktopSessions().filter((session) => {
+  const sessions = readClaudeDesktopSessions({}, env).filter((session) => {
     return !options.claudeDesktopKind || session.kind === options.claudeDesktopKind;
   });
   const candidates = sessions
@@ -199,7 +217,7 @@ function importClaudeDesktopProvider(provider, since, options = {}, env = proces
       continue;
     }
     const cwd = session.cwd || "";
-    const repo = cwd ? canonicalRepo(cwd) : null;
+    const repo = repoInfoForImport(provider, cwd);
     if (options.repos && options.repos.length && !matchesImportedSessionRepo(session, repo, options.repos)) {
       summary.skipped++;
       reportProgress(options, summary, index + 1, session.sourcePath);
@@ -247,10 +265,12 @@ function matchesImportedSessionRepo(session, repo, wantedRepos) {
 
 function importCodexProvider(provider, since, options = {}, env = process.env) {
   const threads = readCodexSessionEntries(env).filter((thread) => {
-    if (options.codexSource && thread.source !== options.codexSource) return false;
-    if (!["cli", "vscode"].includes(thread.source)) return false;
-    return true;
+    if (options.codexSource) return thread.source === options.codexSource;
+    return ["cli", "vscode"].includes(thread.source);
   });
+  if (!threads.length && options.codexSource && options.codexSource !== "cli") {
+    return { provider, discovered: 0, candidates: 0, imported: 0, skipped: 0, errors: [], details: {} };
+  }
   if (!threads.length) return importJsonlProvider(provider, codexRoots(env), since, options, env);
 
   const state = loadImportState(env);
@@ -278,7 +298,7 @@ function importCodexProvider(provider, since, options = {}, env = process.env) {
       reportProgress(options, summary, index + 1, thread.rolloutPath);
       continue;
     }
-    const sourceType = thread.source === "vscode" ? "codex-desktop-history" : "codex-cli-history";
+    const sourceType = codexThreadSourceType(thread);
     const fingerprint = `${fingerprintPrefix(sourceType)}:${fileFingerprint(thread.rolloutPath, stat)}:${codexSupplementFingerprint(thread)}`;
     if (alreadyImported(state, thread.id, fingerprint, archived, provider)) {
       summary.skipped++;
@@ -564,15 +584,17 @@ function structuredSessionReplaceSourcePathCopies(provider, sourceType) {
 }
 
 function structuredSessionUsesSharedRawFiles(provider, sourceType) {
-  return provider === "opencode" && sourceType === "opencode-sqlite-history";
+  return provider === "opencode" && ["opencode-cli-sqlite-history", "opencode-web-sqlite-history", "opencode-sqlite-history", "opencode-desktop-sqlite-history"].includes(sourceType);
 }
 
 function parseAgentJsonl(file, provider) {
   const text = readTextMaybeZstd(file);
+  const events = [];
   const messages = [];
   let cwd = "";
   let sessionId = "";
   let title = "";
+  let titleSource = "";
   const context = { model: "", tokenUsage: { input: 0, output: 0 } };
   for (const line of text.split(/\r?\n/)) {
     if (!line.trim()) continue;
@@ -582,6 +604,7 @@ function parseAgentJsonl(file, provider) {
     } catch {
       continue;
     }
+    events.push(event);
     cwd ||= firstString(event.cwd, event.working_directory, event.workingDirectory, event.context?.cwd, event.payload?.cwd);
     sessionId ||= firstString(
       event.session_id,
@@ -593,7 +616,20 @@ function parseAgentJsonl(file, provider) {
       event.payload?.session_id,
       event.sessionId
     );
-    title ||= firstString(event.title, event.conversation_title, event.payload?.title);
+    if (!title) {
+      const sourceTitle = firstString(event.title, event.conversation_title, event.payload?.title);
+      const aiTitle = firstString(event.aiTitle, event.ai_title);
+      if (sourceTitle) {
+        title = sourceTitle;
+        titleSource = "source";
+      } else if (aiTitle) {
+        title = aiTitle;
+        titleSource = "ai-title";
+      }
+    }
+    collectClaudeJsonlSessionMetadata(event, provider, context);
+  }
+  for (const event of events) {
     updateCodexParseContext(event, provider, context);
     updateClaudeParseContext(event, provider, context);
     if (applyCodexTokenCount(event, provider, messages, context)) continue;
@@ -602,16 +638,409 @@ function parseAgentJsonl(file, provider) {
   }
   messages.sort((a, b) => String(a.timestamp || "").localeCompare(String(b.timestamp || "")));
   const deduped = dedupeAdjacentMessages(messages);
+  const inferredTitle = inferredJsonlSessionTitle(provider, deduped);
   return {
     cwd,
     sessionId,
-    title,
+    title: title || inferredTitle,
+    titleSource: titleSource || (inferredTitle ? "first-user-prompt" : ""),
+    sessionSummary: claudeJsonlSessionSummary(provider, context),
     messages: deduped,
     startedAt: deduped[0]?.timestamp || "",
     endedAt: deduped[deduped.length - 1]?.timestamp || ""
   };
 }
 
+function collectClaudeJsonlSessionMetadata(event, provider, context = {}) {
+  if (!isClaudeJsonlProvider(provider) || !event || typeof event !== "object") return;
+  const metadata = context.claudeJsonl || (context.claudeJsonl = {
+    eventTypeCounts: {},
+    entrypoints: new Set(),
+    userTypes: new Set(),
+    versions: new Set(),
+    gitBranches: new Set(),
+    permissionModes: new Set(),
+    promptIds: new Set(),
+    requestIds: new Set(),
+    sourceToolAssistantUUIDs: new Set(),
+    attachmentTypes: new Set(),
+    remoteToolNames: new Set(),
+    mcpServerNames: new Set(),
+    toolNames: new Set(),
+    agentIds: new Set(),
+    slugs: new Set(),
+    sourceToolUseIDs: new Set(),
+    parentToolUseIDs: new Set(),
+    toolUseIDs: new Set(),
+    attributionSkills: new Set(),
+    queue: {},
+    attachmentDetails: {},
+    apiErrors: {},
+    mcpStructuredContentCount: 0,
+    aiTitles: new Set(),
+    lastPrompt: "",
+    sidechainMessageCount: 0,
+    messageEventCount: 0,
+    remoteControl: false
+  });
+
+  const type = firstString(event.type, event.kind);
+  if (type) metadata.eventTypeCounts[type] = (metadata.eventTypeCounts[type] || 0) + 1;
+  addSetValue(metadata.entrypoints, event.entrypoint);
+  addSetValue(metadata.userTypes, event.userType, event.user_type);
+  addSetValue(metadata.versions, event.version);
+  addSetValue(metadata.gitBranches, event.gitBranch, event.git_branch);
+  addSetValue(metadata.permissionModes, event.permissionMode, event.permission_mode);
+  addSetValue(metadata.promptIds, event.promptId, event.prompt_id);
+  addSetValue(metadata.requestIds, event.requestId, event.request_id);
+  addSetValue(metadata.sourceToolAssistantUUIDs, event.sourceToolAssistantUUID, event.source_tool_assistant_uuid);
+  addSetValue(metadata.agentIds, event.agentId, event.agent_id);
+  addSetValue(metadata.slugs, event.slug);
+  addSetValue(metadata.sourceToolUseIDs, event.sourceToolUseID, event.source_tool_use_id);
+  addSetValue(metadata.parentToolUseIDs, event.parentToolUseID, event.parent_tool_use_id);
+  addSetValue(metadata.toolUseIDs, event.toolUseID, event.tool_use_id);
+  addSetValue(metadata.attributionSkills, event.attributionSkill, event.attribution_skill);
+  if (event.mcpMeta?.structuredContent && typeof event.mcpMeta.structuredContent === "object") metadata.mcpStructuredContentCount++;
+  collectClaudeApiError(event, metadata);
+  if (event.isSidechain === true) metadata.sidechainMessageCount++;
+  if ((event.type === "user" || event.type === "assistant") && event.message) metadata.messageEventCount++;
+
+  const aiTitle = firstString(event.aiTitle, event.ai_title);
+  if (aiTitle) metadata.aiTitles.add(aiTitle);
+  const lastPrompt = firstString(event.lastPrompt, event.last_prompt);
+  if (lastPrompt) metadata.lastPrompt = lastPrompt;
+
+  if (event.type === "queue-operation") collectClaudeQueueOperation(event, metadata);
+  if (event.type === "attachment") collectClaudeAttachmentMetadata(event, metadata);
+  collectClaudeToolNames(event, metadata);
+}
+
+function collectClaudeQueueOperation(event, metadata) {
+  const op = firstString(event.operation).toLowerCase();
+  if (!op) return;
+  const key = op.replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "unknown";
+  metadata.queue[key] = (metadata.queue[key] || 0) + 1;
+  const timestamp = toIso(event.timestamp || event.created_at || event.createdAt || event.time);
+  if (timestamp) {
+    if (!metadata.queue.firstAt || timestamp < metadata.queue.firstAt) metadata.queue.firstAt = timestamp;
+    if (!metadata.queue.lastAt || timestamp > metadata.queue.lastAt) metadata.queue.lastAt = timestamp;
+    const upper = key.charAt(0).toUpperCase() + key.slice(1);
+    if (!metadata.queue[`first${upper}At`] || timestamp < metadata.queue[`first${upper}At`]) metadata.queue[`first${upper}At`] = timestamp;
+    if (!metadata.queue[`last${upper}At`] || timestamp > metadata.queue[`last${upper}At`]) metadata.queue[`last${upper}At`] = timestamp;
+  }
+  if (typeof event.content === "string" && event.content.trim()) {
+    metadata.queue.lastContent = event.content.trim();
+  }
+}
+
+function collectClaudeApiError(event, metadata) {
+  if (!event || typeof event !== "object") return;
+  if (event.isApiErrorMessage !== true && !event.error && event.apiErrorStatus == null) return;
+  const status = Number(event.apiErrorStatus);
+  if (Number.isFinite(status)) {
+    const key = String(status);
+    metadata.apiErrors.statusCounts = metadata.apiErrors.statusCounts || {};
+    metadata.apiErrors.statusCounts[key] = (metadata.apiErrors.statusCounts[key] || 0) + 1;
+  }
+  const type = firstString(event.error);
+  if (type) {
+    metadata.apiErrors.typeCounts = metadata.apiErrors.typeCounts || {};
+    metadata.apiErrors.typeCounts[type] = (metadata.apiErrors.typeCounts[type] || 0) + 1;
+  }
+  metadata.apiErrors.count = (metadata.apiErrors.count || 0) + 1;
+}
+
+function collectClaudeAttachmentMetadata(event, metadata) {
+  const attachment = event.attachment && typeof event.attachment === "object" ? event.attachment : {};
+  addSetValue(metadata.attachmentTypes, attachment.type);
+  collectClaudeAttachmentDetails(attachment, metadata);
+  for (const name of [...asStringArray(attachment.addedNames), ...asStringArray(attachment.removedNames)]) {
+    if (typeof name !== "string" || !name.trim()) continue;
+    const value = name.trim();
+    metadata.remoteToolNames.add(value);
+    if (isClaudeRemoteControlToolName(value)) metadata.remoteControl = true;
+    const server = claudeMcpServerNameFromTool(value);
+    if (server) metadata.mcpServerNames.add(server);
+  }
+}
+
+function collectClaudeAttachmentDetails(attachment, metadata) {
+  const type = firstString(attachment.type);
+  if (!type) return;
+  const details = metadata.attachmentDetails;
+  details.countByType = details.countByType || {};
+  details.countByType[type] = (details.countByType[type] || 0) + 1;
+  if (type === "nested_memory") {
+    details.nestedMemoryPaths = details.nestedMemoryPaths || new Set();
+    addSetValue(details.nestedMemoryPaths, firstString(attachment.path, attachment.content?.path, attachment.displayPath));
+  } else if (type === "edited_text_file") {
+    details.editedTextFiles = details.editedTextFiles || new Set();
+    addSetValue(details.editedTextFiles, firstString(attachment.path, attachment.content?.path, attachment.displayPath));
+  } else if (type === "queued_command") {
+    details.queuedCommandCount = (details.queuedCommandCount || 0) + 1;
+    details.lastQueuedCommand = compactMetadata({
+      prompt: firstString(attachment.prompt),
+      commandMode: firstString(attachment.commandMode, attachment.command_mode)
+    });
+  } else if (type === "command_permissions") {
+    details.commandPermissionCount = (details.commandPermissionCount || 0) + 1;
+    details.lastAllowedTools = asStringArray(attachment.allowedTools);
+  } else if (type === "date_change") {
+    details.dateChanges = details.dateChanges || new Set();
+    addSetValue(details.dateChanges, attachment.newDate, attachment.new_date);
+  } else if (type === "max_turns_reached") {
+    details.maxTurnsReachedCount = (details.maxTurnsReachedCount || 0) + 1;
+    details.lastMaxTurnsReached = compactMetadata({
+      maxTurns: numericValue(attachment.maxTurns, attachment.max_turns),
+      turnCount: numericValue(attachment.turnCount, attachment.turn_count)
+    });
+  } else if (type === "compact_file_reference") {
+    details.compactFileReferences = details.compactFileReferences || new Set();
+    addSetValue(details.compactFileReferences, attachment.path, attachment.displayPath);
+  }
+}
+
+function collectClaudeToolNames(event, metadata) {
+  const parts = Array.isArray(event.message?.content) ? event.message.content : [];
+  for (const part of parts) {
+    if (!part || typeof part !== "object") continue;
+    const type = String(part.type || part.kind || "").toLowerCase();
+    if (type !== "tool_use" && type !== "server_tool_use" && type !== "mcp_tool_use" && type !== "function_call") continue;
+    addSetValue(metadata.toolNames, part.name, part.tool_name, part.toolName, part.function?.name);
+  }
+}
+
+function claudeMcpServerNameFromTool(name) {
+  const match = String(name || "").match(/^mcp__(.+?)__/);
+  if (!match) return "";
+  return match[1];
+}
+
+const CLAUDE_REMOTE_CONTROL_TOOL_NAMES = new Set([
+  "RemoteTrigger",
+  "TaskOutput",
+  "TaskStop",
+  "PushNotification",
+  "AskUserQuestion",
+  "Monitor",
+  "TaskCreate",
+  "TaskUpdate",
+  "TaskList",
+  "TaskGet",
+  "CronCreate",
+  "CronDelete",
+  "CronList"
+]);
+
+function isClaudeRemoteControlToolName(name) {
+  const value = String(name || "").trim();
+  return CLAUDE_REMOTE_CONTROL_TOOL_NAMES.has(value);
+}
+
+function claudeJsonlSessionSummary(provider, context = {}) {
+  if (!isClaudeJsonlProvider(provider)) return null;
+  const metadata = context.claudeJsonl;
+  if (!metadata) return null;
+  const remoteToolNames = sortedSet(metadata.remoteToolNames);
+  const mcpServerNames = sortedSet(metadata.mcpServerNames);
+  const attachmentDetails = claudeAttachmentDetailsSummary(metadata.attachmentDetails);
+  const result = compactMetadata({
+    claudeJsonl: compactMetadata({
+      entrypoint: singleOrArray(metadata.entrypoints),
+      userType: singleOrArray(metadata.userTypes),
+      version: singleOrArray(metadata.versions),
+      gitBranch: singleOrArray(metadata.gitBranches),
+      permissionModes: sortedSet(metadata.permissionModes),
+      eventTypeCounts: compactMetadata(metadata.eventTypeCounts),
+      messageEventCount: metadata.messageEventCount || undefined,
+      sidechainMessageCount: metadata.sidechainMessageCount || undefined,
+      promptIdCount: metadata.promptIds.size || undefined,
+      requestIdCount: metadata.requestIds.size || undefined,
+      sourceToolAssistantUUIDCount: metadata.sourceToolAssistantUUIDs.size || undefined,
+      agentIds: sortedSet(metadata.agentIds),
+      slugs: sortedSet(metadata.slugs),
+      sourceToolUseIDCount: metadata.sourceToolUseIDs.size || undefined,
+      parentToolUseIDCount: metadata.parentToolUseIDs.size || undefined,
+      toolUseIDCount: metadata.toolUseIDs.size || undefined,
+      attributionSkills: sortedSet(metadata.attributionSkills),
+      mcpStructuredContentCount: metadata.mcpStructuredContentCount || undefined,
+      apiErrors: compactMetadata(metadata.apiErrors),
+      attachmentTypes: sortedSet(metadata.attachmentTypes),
+      attachmentDetails,
+      toolNames: sortedSet(metadata.toolNames),
+      aiTitle: sortedSet(metadata.aiTitles)[0] || undefined,
+      lastPrompt: metadata.lastPrompt || undefined,
+      queue: compactMetadata(metadata.queue),
+      remoteControl: metadata.remoteControl ? compactMetadata({
+        detected: true,
+        toolCount: remoteToolNames.length || undefined,
+        toolNames: remoteToolNames,
+        mcpToolCount: remoteToolNames.filter((name) => name.startsWith("mcp__")).length || undefined,
+        mcpServerNames
+      }) : undefined
+    })
+  });
+  return result || null;
+}
+
+function claudeAttachmentDetailsSummary(details = {}) {
+  return compactMetadata({
+    countByType: compactMetadata(details.countByType),
+    nestedMemoryPaths: details.nestedMemoryPaths ? sortedSet(details.nestedMemoryPaths) : undefined,
+    editedTextFiles: details.editedTextFiles ? sortedSet(details.editedTextFiles) : undefined,
+    queuedCommandCount: details.queuedCommandCount || undefined,
+    lastQueuedCommand: details.lastQueuedCommand || undefined,
+    commandPermissionCount: details.commandPermissionCount || undefined,
+    lastAllowedTools: details.lastAllowedTools?.length ? details.lastAllowedTools : undefined,
+    dateChanges: details.dateChanges ? sortedSet(details.dateChanges) : undefined,
+    maxTurnsReachedCount: details.maxTurnsReachedCount || undefined,
+    lastMaxTurnsReached: details.lastMaxTurnsReached || undefined,
+    compactFileReferences: details.compactFileReferences ? sortedSet(details.compactFileReferences) : undefined
+  });
+}
+
+function addSetValue(set, ...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) set.add(value.trim());
+  }
+}
+
+function asStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => typeof item === "string" && item.trim()).map((item) => item.trim());
+}
+
+function numericValue(...values) {
+  for (const value of values) {
+    if (value == null || value === "") continue;
+    const number = Number(value);
+    if (Number.isFinite(number)) return number;
+  }
+  return undefined;
+}
+
+function sortedSet(set) {
+  return [...set].sort((a, b) => a.localeCompare(b));
+}
+
+function singleOrArray(set) {
+  const values = sortedSet(set);
+  if (!values.length) return undefined;
+  return values.length === 1 ? values[0] : values;
+}
+
+function repoInfoForImport(provider, cwd, metadata = null) {
+  const repoCwd = repoCwdForImport(provider, cwd, metadata);
+  if (!repoCwd) return null;
+  return canonicalRepo(repoCwd);
+}
+
+function repoCwdForImport(provider, cwd, metadata = null) {
+  const metadataCwd = firstExistingDirectory(metadata?.originCwd, metadata?.cwd);
+  if (metadataCwd) return metadataCwd;
+  return claudeWorktreeParentRepo(provider, cwd) || cwd;
+}
+
+function claudeWorktreeParentRepo(provider, cwd) {
+  if (!isClaudeJsonlProvider(provider)) return "";
+  const resolved = path.resolve(String(cwd || ""));
+  const marker = `${path.sep}.claude${path.sep}worktrees${path.sep}`;
+  const markerIndex = resolved.indexOf(marker);
+  if (markerIndex === -1) return "";
+  const parentRepo = resolved.slice(0, markerIndex);
+  const stat = safeStat(parentRepo);
+  return stat && stat.isDirectory() ? parentRepo : "";
+}
+
+function inferredJsonlSessionTitle(provider, messages) {
+  if (!isClaudeJsonlProvider(provider)) return "";
+  const firstUser = (messages || []).find((message) => message.role === "user" && !message.metadata?.providerGenerated);
+  return titleFromPrompt(firstUser?.content);
+}
+
+function titleFromPrompt(value) {
+  const cleaned = firstLine(value).replace(/\s+/g, " ").trim();
+  if (!cleaned) return "";
+  const max = 96;
+  return cleaned.length > max ? `${cleaned.slice(0, max - 1).trimEnd()}…` : cleaned;
+}
+
+function isClaudeJsonlProvider(provider) {
+  return provider === "claude_code" || provider === "claude_sdk";
+}
+
+function jsonlSessionTitleForImport(parsed, metadata = null) {
+  return firstString(metadata?.title, parsed?.title);
+}
+
+function claudeCodeSidecarSessionSummary(metadata = null) {
+  if (!metadata) return null;
+  const sidecar = compactMetadata({
+    appSessionId: metadata.sessionId || undefined,
+    cliSessionId: metadata.cliSessionId || undefined,
+    title: metadata.title || undefined,
+    titleSource: metadata.titleSource || undefined,
+    cwd: metadata.cwd || undefined,
+    originCwd: metadata.originCwd || undefined,
+    worktreePath: metadata.worktreePath || undefined,
+    worktreeName: metadata.worktreeName || undefined,
+    sourceBranch: metadata.sourceBranch || undefined,
+    branch: metadata.branch || undefined,
+    createdAt: metadata.createdAt || undefined,
+    lastActivityAt: metadata.lastActivityAt || undefined,
+    model: metadata.model || undefined,
+    effort: metadata.effort || undefined,
+    permissionMode: metadata.permissionMode || undefined,
+    chromePermissionMode: metadata.chromePermissionMode || undefined,
+    completedTurns: metadata.completedTurns,
+    isArchived: typeof metadata.isArchived === "boolean" ? metadata.isArchived : undefined,
+    enabledMcpToolCount: metadata.enabledMcpToolCount,
+    mcpServerNames: metadata.mcpServerNames?.length ? metadata.mcpServerNames : undefined,
+    sourcePath: metadata.sourcePath || undefined
+  });
+  if (!sidecar) return null;
+  return compactMetadata({
+    claudeCodeSidecar: sidecar,
+    modelUsage: metadata.model ? [{ model: metadata.model, source: "claude-code-sidecar" }] : undefined
+  });
+}
+
+function mergeSessionSummaries(...summaries) {
+  const result = {};
+  for (const summary of summaries) {
+    if (!summary || typeof summary !== "object" || Array.isArray(summary)) continue;
+    for (const [key, value] of Object.entries(summary)) {
+      if (key === "modelUsage" && Array.isArray(value)) {
+        result.modelUsage = [...(Array.isArray(result.modelUsage) ? result.modelUsage : []), ...value];
+      } else if (value && typeof value === "object" && !Array.isArray(value) && result[key] && typeof result[key] === "object" && !Array.isArray(result[key])) {
+        result[key] = compactMetadata({ ...result[key], ...value });
+      } else {
+        result[key] = value;
+      }
+    }
+  }
+  return compactMetadata(result);
+}
+
+function firstExistingDirectory(...values) {
+  for (const value of values) {
+    if (typeof value !== "string" || !value.trim()) continue;
+    const stat = safeStat(value.trim());
+    if (stat && stat.isDirectory()) return value.trim();
+  }
+  return "";
+}
+
+function claudeCodeImportFingerprint(baseFingerprint, metadata = null) {
+  if (!metadata?.sourcePath) return baseFingerprint;
+  return `${baseFingerprint}:claude-code-session:${fileFingerprint(metadata.sourcePath, safeStat(metadata.sourcePath))}`;
+}
+
+function claudeSessionIdFromFilename(file) {
+  const base = path.basename(String(file || "")).replace(/\.jsonl(?:\.zst)?$/i, "");
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(base) ? base : "";
+}
+
 function extractMessages(event, provider, context = {}) {
   const claudeMessages = extractClaudeMessagesFromEvent(event, provider, context);
   if (claudeMessages.length) {
@@ -649,9 +1078,54 @@ function dedupeAdjacentMessages(messages) {
     }
     result.push(message);
   }
+  return dedupeDuplicateToolResults(result);
+}
+
+function dedupeDuplicateToolResults(messages) {
+  const result = [];
+  const toolResultsByKey = new Map();
+  for (const message of messages) {
+    const key = duplicateToolResultKey(message);
+    if (key && toolResultsByKey.has(key)) {
+      const existingIndex = toolResultsByKey.get(key);
+      const existing = result[existingIndex];
+      if (timestampsNear(existing?.timestamp, message?.timestamp)) {
+        result[existingIndex] = preferredToolResultMessage(existing, message);
+        continue;
+      }
+    }
+    if (key) toolResultsByKey.set(key, result.length);
+    result.push(message);
+  }
   return result;
 }
 
+function duplicateToolResultKey(message) {
+  const result = message?.metadata?.toolResult;
+  const id = firstString(result?.id, result?.callId, result?.call_id, result?.toolCallId, result?.tool_call_id, result?.toolUseId, result?.tool_use_id);
+  if (!id || message?.role !== "tool") return "";
+  return `${message?.metadata?.provider || result?.provider || ""}:${id}`;
+}
+
+function preferredToolResultMessage(left, right) {
+  return toolResultMessageDisplayScore(right) > toolResultMessageDisplayScore(left) ? right : left;
+}
+
+function toolResultMessageDisplayScore(message) {
+  const result = message?.metadata?.toolResult || {};
+  const rawCategory = normalizeToolToken(result.rawCategory);
+  const kind = normalizeToolToken(result.kind);
+  const category = normalizeToolToken(result.category);
+  let score = 0;
+  if (["exec_command_end", "patch_apply_end", "mcp_tool_call_end", "web_search_end", "tool_result", "tool_output"].includes(rawCategory)) score += 2000;
+  if (rawCategory === "function_call_output" || rawCategory === "custom_tool_call_output") score -= 1000;
+  if (category && category !== "function") score += 250;
+  if (kind && !kind.startsWith("call_")) score += 150;
+  if (/^\$\s/.test(String(result.summary || result.output || message?.content || ""))) score += 250;
+  score += Math.min(200, String(result.output || message?.content || "").length / 200);
+  return score;
+}
+
 function hasStructuredTranscriptMetadata(message) {
   const metadata = message?.metadata || {};
   return Boolean(
@@ -2379,6 +2853,7 @@ function discoverCliHistory(env = process.env, options = {}) {
   const codexThreads = readCodexSessionEntries(env);
   publish("codexCli", "Codex CLI", summarizeCodexThreads(codexThreads, "cli"));
   publish("codexDesktop", "Codex Desktop", summarizeCodexThreads(codexThreads, "vscode"));
+  publish("codexSdk", "Codex SDK jobs", summarizeCodexThreads(codexThreads, "exec"));
   result.codex = summarizeCodexThreads(codexThreads);
 
   const claudeScan = scanClaudeProjectFiles({
@@ -2388,7 +2863,7 @@ function discoverCliHistory(env = process.env, options = {}) {
 
   const claudeDesktopSessions = readClaudeDesktopSessions({
     onProgress: (event) => reportDiscoveryProgress(options, { ...event, provider: "Claude App" })
-  });
+  }, env);
   publish("claudeCodeDesktop", "Claude Code Desktop", summarizeClaudeDesktopSessions(claudeDesktopSessions, "claude-code-desktop-metadata"));
   publish("claudeWorkspace", "Claude Workspace", summarizeClaudeDesktopSessions(claudeDesktopSessions, "claude-workspace-desktop"));
   publish("claudeSdk", "Claude SDK jobs", summarizeClaudeSdkScan(claudeScan));
@@ -2443,13 +2918,38 @@ function discoverCliHistory(env = process.env, options = {}) {
   );
 
   publish(
-    "opencode",
-    "OpenCode",
+    "opencodeCli",
+    "OpenCode CLI",
     summarizeStructuredSessions(
       readOpenCodeSessions(env, {
-        onProgress: (event) => reportDiscoveryProgress(options, { ...event, provider: "OpenCode" })
+        openCodeKind: "cli",
+        onProgress: (event) => reportDiscoveryProgress(options, { ...event, provider: "OpenCode CLI" })
       }),
-      "OpenCode SQLite database and JSON session/message/part storage"
+      "OpenCode CLI/core SQLite database plus project JSON session/message/part storage"
+    )
+  );
+
+  publish(
+    "opencodeDesktop",
+    "OpenCode Desktop",
+    summarizeStructuredSessions(
+      readOpenCodeSessions(env, {
+        openCodeKind: "desktop",
+        onProgress: (event) => reportDiscoveryProgress(options, { ...event, provider: "OpenCode Desktop" })
+      }),
+      "OpenCode Desktop app-specific SQLite database and JSON session/message/part storage"
+    )
+  );
+
+  publish(
+    "opencodeWeb",
+    "OpenCode Web",
+    summarizeStructuredSessions(
+      readOpenCodeSessions(env, {
+        openCodeKind: "web",
+        onProgress: (event) => reportDiscoveryProgress(options, { ...event, provider: "OpenCode Web" })
+      }),
+      "OpenCode web sessions from the shared OpenCode SQLite store"
     )
   );
 
@@ -2480,8 +2980,8 @@ function summarizeCodex(env = process.env, source) {
 
 function summarizeCodexThreads(allThreads, source) {
   const threads = allThreads.filter((thread) => {
-    if (!["cli", "vscode"].includes(thread.source)) return false;
-    return source ? thread.source === source : true;
+    if (source) return thread.source === source;
+    return ["cli", "vscode"].includes(thread.source);
   });
   if (threads.length) {
     const oldest = threads.length
@@ -2496,10 +2996,24 @@ function summarizeCodexThreads(allThreads, source) {
           ? "terminal `codex` sessions"
           : source === "vscode"
             ? "Codex desktop app sessions"
+            : source === "exec"
+              ? "Codex exec/SDK batch jobs; opt-in"
             : "includes Codex CLI and Codex Desktop top-level sessions"
     };
   }
-  return { sessions: 0, oldest: "", details: {}, note: source === "cli" ? "terminal `codex` sessions" : source === "vscode" ? "Codex desktop app sessions" : "" };
+  return {
+    sessions: 0,
+    oldest: "",
+    details: {},
+    note:
+      source === "cli"
+        ? "terminal `codex` sessions"
+        : source === "vscode"
+          ? "Codex desktop app sessions"
+          : source === "exec"
+            ? "Codex exec/SDK batch jobs; opt-in"
+            : ""
+  };
 }
 
 function summarizeClaude() {
@@ -2524,7 +3038,7 @@ function summarizeClaudeSdkScan(scan) {
 }
 
 function summarizeClaudeDesktop(env = process.env, options = {}) {
-  const sessions = readClaudeDesktopSessions(options);
+  const sessions = readClaudeDesktopSessions(options, env);
   return summarizeClaudeDesktopSessions(sessions);
 }
 
@@ -2755,11 +3269,13 @@ function classifyClaudeFile(file) {
   }
   let inspected = 0;
   let sawSdkMessage = false;
+  let sawRemoteControlTools = false;
   for (const line of lines) {
     if (!line.trim()) continue;
     inspected++;
     try {
       const event = JSON.parse(line);
+      if (isClaudeRemoteControlToolDelta(event)) sawRemoteControlTools = true;
       if ((event.type === "user" || event.type === "assistant") && event.message) {
         if (event.entrypoint === "sdk-cli") sawSdkMessage = true;
         else return "conversation";
@@ -2767,9 +3283,14 @@ function classifyClaudeFile(file) {
     } catch {
       return "other";
     }
-    if (inspected >= 80) return sawSdkMessage ? "sdk-job" : "other";
+    if (inspected >= 80) return sawSdkMessage ? (sawRemoteControlTools ? "conversation" : "sdk-job") : "other";
   }
-  return sawSdkMessage ? "sdk-job" : "other";
+  return sawSdkMessage ? (sawRemoteControlTools ? "conversation" : "sdk-job") : "other";
+}
+
+function isClaudeRemoteControlToolDelta(event) {
+  if (!event || event.type !== "attachment" || !Array.isArray(event.attachment?.addedNames)) return false;
+  return event.attachment.addedNames.some((name) => isClaudeRemoteControlToolName(name));
 }
 
 function readInitialLines(file, maxLines, maxBytes = 1024 * 1024) {
@@ -3040,15 +3561,16 @@ function codexSupplementFingerprint(thread) {
 function summarizeCodexSources(threads) {
   const cli = threads.filter((thread) => thread.source === "cli").length;
   const desktop = threads.filter((thread) => thread.source === "vscode").length;
+  const exec = threads.filter((thread) => thread.source === "exec").length;
   const summaries = threads.filter((thread) => thread.rawMemory || thread.rolloutSummary).length;
   const archived = threads.filter((thread) => thread.sourceDetail === "archived_sessions").length;
-  return { cli, desktop, ...(archived ? { archived } : {}), ...(summaries ? { summaries } : {}) };
+  return { cli, desktop, ...(exec ? { exec } : {}), ...(archived ? { archived } : {}), ...(summaries ? { summaries } : {}) };
 }
 
-function readClaudeDesktopSessions(options = {}) {
+function readClaudeDesktopSessions(options = {}, env = process.env) {
   const roots = [
-    { root: path.join(os.homedir(), "Library", "Application Support", "Claude", "claude-code-sessions"), kind: "claude-code-desktop-metadata" },
-    { root: path.join(os.homedir(), "Library", "Application Support", "Claude", "local-agent-mode-sessions"), kind: "claude-workspace-desktop" }
+    { root: claudeCodeSessionsRoot(env), kind: "claude-code-desktop-metadata" },
+    { root: claudeWorkspaceSessionsRoot(env), kind: "claude-workspace-desktop" }
   ];
   const candidates = [];
   for (const { root, kind } of roots) {
@@ -3071,6 +3593,90 @@ function readClaudeDesktopSessions(options = {}) {
   return sessions;
 }
 
+function claudeCodeSessionMetadataByCliSessionId(env = process.env) {
+  const byCliSessionId = new Map();
+  collectFiles(claudeCodeSessionsRoot(env), (file) => {
+    if (!path.basename(file).startsWith("local_") || !file.endsWith(".json")) return;
+    const metadata = parseClaudeCodeSessionMetadataFile(file);
+    if (metadata?.cliSessionId) byCliSessionId.set(metadata.cliSessionId, metadata);
+  });
+  return byCliSessionId;
+}
+
+function parseClaudeCodeSessionMetadataFile(file) {
+  let data;
+  try {
+    data = JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+  const cliSessionId = firstString(data.cliSessionId);
+  if (!cliSessionId) return null;
+  return {
+    cliSessionId,
+    sessionId: firstString(data.sessionId),
+    title: firstString(data.title),
+    titleSource: firstString(data.titleSource),
+    cwd: firstString(data.cwd),
+    originCwd: firstString(data.originCwd),
+    worktreePath: firstString(data.worktreePath),
+    worktreeName: firstString(data.worktreeName),
+    sourceBranch: firstString(data.sourceBranch),
+    branch: firstString(data.branch),
+    createdAt: toIso(data.createdAt),
+    lastActivityAt: toIso(data.lastActivityAt),
+    model: firstString(data.model),
+    effort: firstString(data.effort),
+    permissionMode: firstString(data.permissionMode),
+    chromePermissionMode: firstString(data.chromePermissionMode),
+    completedTurns: numberValue(data.completedTurns),
+    isArchived: typeof data.isArchived === "boolean" ? data.isArchived : undefined,
+    enabledMcpToolCount: enabledMcpToolCount(data.enabledMcpTools),
+    mcpServerNames: claudeMcpServerNames(data.remoteMcpServersConfig),
+    sourcePath: file
+  };
+}
+
+function enabledMcpToolCount(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  return Object.values(value).filter(Boolean).length;
+}
+
+function claudeMcpServerNames(value) {
+  if (!Array.isArray(value)) return [];
+  return [...new Set(value.map((server) => firstString(server?.name)).filter(Boolean))].sort((a, b) => a.localeCompare(b));
+}
+
+function compactMetadata(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value || null;
+  const result = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (item === undefined || item === null || item === "") continue;
+    if (Array.isArray(item) && !item.length) continue;
+    if (item && typeof item === "object" && !Array.isArray(item) && !Object.keys(item).length) continue;
+    result[key] = item;
+  }
+  return Object.keys(result).length ? result : null;
+}
+
+function numberValue(value) {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : undefined;
+}
+
+function claudeAppSupportRoot(env = process.env) {
+  const home = env && env.HOME ? env.HOME : os.homedir();
+  return env.CLAUDE_APP_SUPPORT || path.join(home, "Library", "Application Support", "Claude");
+}
+
+function claudeCodeSessionsRoot(env = process.env) {
+  return path.join(claudeAppSupportRoot(env), "claude-code-sessions");
+}
+
+function claudeWorkspaceSessionsRoot(env = process.env) {
+  return path.join(claudeAppSupportRoot(env), "local-agent-mode-sessions");
+}
+
 function parseClaudeDesktopSessionFile(file, kind = "claude-workspace-desktop") {
   let data;
   try {
@@ -3337,7 +3943,10 @@ function cursorBuildComposerInfoLookup(env = process.env) {
           "key,",
           "json_extract(value, '$.modelId') as modelId,",
           "json_extract(value, '$.modelName') as modelName,",
-          "json_extract(value, '$.model') as model",
+          "json_extract(value, '$.model') as model,",
+          "json_extract(value, '$.modelInfo.modelName') as modelInfoModelName,",
+          "json_extract(value, '$.modelInfo.modelId') as modelInfoModelId,",
+          "json_extract(value, '$.modelInfo.model') as modelInfoModel",
           "from cursorDiskKV where",
           "json_valid(value) and",
           cursorDiskKvPrefixRangeCondition("bubbleId:")
@@ -3348,7 +3957,14 @@ function cursorBuildComposerInfoLookup(env = process.env) {
         const keyMatch = String(row.key || "").match(/^bubbleId:([^:]+):/);
         if (!keyMatch) continue;
         const composerId = keyMatch[1].toLowerCase();
-        const model = firstString(row.modelId, row.modelName, row.model);
+        const model = firstString(
+          row.modelInfoModelName,
+          row.modelInfoModelId,
+          row.modelInfoModel,
+          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);
@@ -3960,6 +4576,7 @@ function cursorGlobalBubbleSelectColumns(valueExpression = "value", keyExpressio
     `json_extract(${valueExpression}, '$.modelName') as modelName`,
     `json_extract(${valueExpression}, '$.modelSlug') as modelSlug`,
     `json_extract(${valueExpression}, '$.modelConfig') as modelConfig`,
+    `json_extract(${valueExpression}, '$.modelInfo') as modelInfo`,
     `json_extract(${valueExpression}, '$.providerOptions') as providerOptions`,
     `json_extract(${valueExpression}, '$.status') as status`,
     `json_extract(${valueExpression}, '$.state') as state`,
@@ -4014,6 +4631,7 @@ function cursorGlobalBubbleDataFromRow(row) {
     modelName: row.modelName,
     modelSlug: row.modelSlug,
     modelConfig: cursorParseSqliteJsonColumn(row.modelConfig),
+    modelInfo: cursorParseSqliteJsonColumn(row.modelInfo),
     providerOptions: cursorParseSqliteJsonColumn(row.providerOptions),
     status: row.status,
     state: cursorParseSqliteJsonColumn(row.state) || row.state,
@@ -5151,6 +5769,11 @@ function cursorMessageMetadata(record, source) {
 
 function cursorModel(record) {
   return firstCursorModel(
+    record?.modelInfo?.modelName,
+    record?.modelInfo?.modelId,
+    record?.modelInfo?.model,
+    record?.message?.modelInfo?.modelName,
+    record?.message?.modelInfo?.modelId,
     record?.model,
     record?.modelId,
     record?.modelID,
@@ -6539,15 +7162,15 @@ function clineTitle(messages) {
 }
 
 function readOpenCodeSessions(env = process.env, options = {}) {
-  const dbs = openCodeDatabaseFiles(env);
-  const roots = openCodeStorageRoots(env);
+  const dbs = openCodeDatabaseFiles(env, options);
+  const roots = openCodeStorageRoots(env, options);
   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++) {
     let dbSessions = [];
     try {
-      dbSessions = readOpenCodeSqliteSessionsFromDb(dbs[index], options);
+      dbSessions = readOpenCodeSqliteSessionsFromDb(dbs[index], options, env);
     } catch (error) {
       reportDiscoveryProgress(options, {
         current: index + 1,
@@ -6569,7 +7192,7 @@ function readOpenCodeSessions(env = process.env, options = {}) {
   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);
+    const session = parseOpenCodeSessionFile(item.file, item.root, env, options);
     if (session) {
       sessions.push(session);
       seenSessionIds.add(session.sessionId.replace(/^opencode-/, ""));
@@ -6584,38 +7207,70 @@ function readOpenCodeSessions(env = process.env, options = {}) {
   for (const root of roots) {
     for (const sessionId of openCodeMessageSessionIds(root)) {
       if (seenSessionIds.has(sessionId)) continue;
-      const session = parseOpenCodeMessageOnlySession(root, sessionId);
+      const session = parseOpenCodeMessageOnlySession(root, sessionId, env, options);
       if (session) {
         sessions.push(session);
         seenSessionIds.add(sessionId);
       }
     }
   }
-  return dedupeStructuredSessions(sessions, "opencode");
+  return filterOpenCodeSessionsForKind(dedupeStructuredSessions(sessions, "opencode"), options.openCodeKind);
+}
+
+function filterOpenCodeSessionsForKind(sessions, kind) {
+  if (!OPENCODE_SOURCE_KINDS.has(kind)) return sessions;
+  return (sessions || []).filter((session) => openCodeSourceKindForType(session.sourceType) === kind);
 }
 
-function openCodeDataRoots(env = process.env) {
+function openCodeDataRoots(env = process.env, options = {}) {
   const configured = env.AGENTLOG_OPENCODE_DATA_DIR || env.OPENCODE_DATA_DIR;
   if (configured) return existingUniquePaths([configured]);
-  const home = env.HOME || os.homedir();
+  if (options.openCodeKind === "cli") return existingUniquePaths(openCodeCliDataRoots(env));
+  if (options.openCodeKind === "desktop") return existingUniquePaths(openCodeDesktopDataRoots(env));
+  if (options.openCodeKind === "web") return [];
+  return existingUniquePaths([...openCodeCliDataRoots(env), ...openCodeDesktopDataRoots(env)]);
+}
+
+function openCodeCliDataRoots(env = process.env) {
+  const home = env.HOME || env.USERPROFILE || os.homedir();
   const roots = [
-    path.join(home, ".local", "share", "opencode"),
+    path.join(home, ".local", "share", "opencode")
+  ];
+  return roots;
+}
+
+function openCodeDesktopDataRoots(env = process.env) {
+  const home = env.HOME || env.USERPROFILE || os.homedir();
+  const roots = [
+    path.join(home, "Library", "Application Support", "ai.opencode.desktop"),
     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, "ai.opencode.desktop"));
     roots.push(path.join(appData, "opencode"));
     roots.push(path.join(appData, "ai.opencode.app"));
   }
   return existingUniquePaths(roots);
 }
 
-function openCodeStorageRoots(env = process.env) {
+function openCodeSqliteDataRoots(env = process.env) {
+  return existingUniquePaths([...openCodeCliDataRoots(env), ...openCodeDesktopDataRoots(env)]);
+}
+
+function openCodeDatabaseRoots(env = process.env, options = {}) {
+  const configured = env.AGENTLOG_OPENCODE_DATA_DIR || env.OPENCODE_DATA_DIR;
+  if (configured) return existingUniquePaths([configured]);
+  if (OPENCODE_SOURCE_KINDS.has(options.openCodeKind)) return openCodeSqliteDataRoots(env);
+  return openCodeSqliteDataRoots(env);
+}
+
+function openCodeStorageRoots(env = process.env, options = {}) {
   const explicit = envPathList(env.AGENTLOG_OPENCODE_STORAGE_ROOTS || env.AGENTLOG_OPENCODE_STORAGE_DIR);
   if (explicit.length) return existingUniquePaths(explicit);
-  const dataRoots = openCodeDataRoots(env);
+  const dataRoots = openCodeDataRoots(env, options);
   const roots = [];
   for (const dataRoot of dataRoots) {
     roots.push(path.join(dataRoot, "storage"));
@@ -6634,11 +7289,11 @@ function openCodeStorageRoots(env = process.env) {
   return existingUniquePaths(roots);
 }
 
-function openCodeDatabaseFiles(env = process.env) {
+function openCodeDatabaseFiles(env = process.env, options = {}) {
   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) => [
+  return existingUniquePaths(openCodeDatabaseRoots(env, options).flatMap((root) => [
     path.join(root, "opencode.db"),
     path.join(root, "storage", "opencode.db")
   ]));
@@ -6668,11 +7323,40 @@ function openCodeMessageSessionIds(root) {
     .sort((a, b) => a.localeCompare(b));
 }
 
-function readOpenCodeSqliteSessionsFromDb(dbPath, options = {}) {
+function openCodeDesktopSessionHints(env = process.env) {
+  const hints = new Map();
+  for (const root of openCodeDesktopDataRoots(env)) {
+    collectFilesLimited(root, (file) => {
+      if (!openCodeDesktopHintFile(file)) return;
+      const stat = safeStat(file);
+      if (!stat || stat.size > 2 * 1024 * 1024) return;
+      let text = "";
+      try {
+        text = fs.readFileSync(file, "utf8");
+      } catch {
+        return;
+      }
+      for (const id of text.match(OPENCODE_SESSION_ID_RE) || []) {
+        const files = hints.get(id) || new Set();
+        files.add(file);
+        hints.set(id, files);
+      }
+    }, 2, { skipDirs: new Set(["Cache", "Cache_Data", "Code Cache", "GPUCache", "blob_storage", "logs"]) });
+  }
+  return hints;
+}
+
+function openCodeDesktopHintFile(file) {
+  const base = path.basename(String(file || ""));
+  return base.endsWith(".dat") || base === "opencode.settings" || base === "settings.json";
+}
+
+function readOpenCodeSqliteSessionsFromDb(dbPath, options = {}, env = process.env) {
   if (!safeStat(dbPath)) return [];
   if (!sqliteTableExists(dbPath, "session") || !sqliteTableExists(dbPath, "message") || !sqliteTableExists(dbPath, "part")) return [];
   const sessionRows = readOpenCodeSqliteSessionRows(dbPath, options);
   if (!sessionRows.length) return [];
+  const classifications = openCodeSqliteSessionClassifications(sessionRows, dbPath, env, options);
   const sessionIds = sessionRows.map((row) => row.id).filter(Boolean);
   const messageRows = sortOpenCodeSqliteRows(readOpenCodeSqliteMessageRows(dbPath, sessionIds), ["session_id", "time_created", "id"]);
   const partRows = sortOpenCodeSqliteRows(readOpenCodeSqlitePartRows(dbPath, sessionIds), ["session_id", "message_id", "time_created", "id"]);
@@ -6681,20 +7365,22 @@ function readOpenCodeSqliteSessionsFromDb(dbPath, options = {}) {
   const storageRoot = path.join(path.dirname(dbPath), "storage");
   const sessions = [];
   for (const row of sessionRows) {
+    const sourceType = classifications.sourceTypes.get(String(row.id || "")) || openCodeSqliteSourceType(dbPath, env, options);
     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"
+      sourceType
     );
     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;
+    const finalMessages = diffMessage ? messages.concat(stampMessages([diffMessage], sourceType)) : 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));
+    const hintFiles = classifications.hintFiles.get(String(row.id || "")) || [];
     sessions.push({
       sessionId: `opencode-${row.id}`,
       title: firstString(row.title, row.slug, clineTitle(finalMessages), row.id),
@@ -6703,11 +7389,12 @@ function readOpenCodeSqliteSessionsFromDb(dbPath, options = {}) {
       endedAt,
       messages: finalMessages,
       sourcePath: `${dbPath}#${row.id}`,
-      sourceFiles,
-      sourceType: "opencode-sqlite-history",
-      fingerprint: openCodeSqliteSessionFingerprint(dbPath, row, rows, sourceFiles),
+      sourceFiles: existingUniquePaths([...sourceFiles, ...hintFiles]),
+      sourceType,
+      fingerprint: openCodeSqliteSessionFingerprint(dbPath, row, rows, existingUniquePaths([...sourceFiles, ...hintFiles]), sourceType),
       detailKey: "sqliteSessions",
       sessionSummary: {
+        source: openCodeSourceKindForType(sourceType),
         projectId: row.project_id || undefined,
         parentId: row.parent_id || undefined,
         workspaceId: row.workspace_id || undefined,
@@ -6763,6 +7450,92 @@ function readOpenCodeSqliteSessionRows(dbPath, options = {}) {
   return readSqliteJson(dbPath, queryParts.join(" "), "OpenCode SQLite sessions");
 }
 
+function openCodeSqliteSessionClassifications(sessionRows, dbPath, env = process.env, options = {}) {
+  const baseSourceType = openCodeSqliteSourceType(dbPath, env, options);
+  const rowsById = new Map((sessionRows || []).map((row) => [String(row.id || ""), row]).filter(([id]) => id));
+  const desktopHints = openCodeDesktopSessionHints(env);
+  const sourceTypes = new Map();
+  const hintFiles = new Map();
+  const classify = (row, visiting = new Set()) => {
+    const id = String(row?.id || "");
+    if (!id) return baseSourceType;
+    if (sourceTypes.has(id)) return sourceTypes.get(id);
+    if (desktopHints.has(id)) {
+      sourceTypes.set(id, "opencode-desktop-sqlite-history");
+      hintFiles.set(id, [...desktopHints.get(id)]);
+      return "opencode-desktop-sqlite-history";
+    }
+    if (row?.parent_id && !visiting.has(id)) {
+      visiting.add(id);
+      const parentId = String(row.parent_id);
+      const parent = rowsById.get(parentId);
+      const parentSourceType = parent ? classify(parent, visiting) : "";
+      if (parentSourceType === "opencode-desktop-sqlite-history") {
+        sourceTypes.set(id, parentSourceType);
+        const parentFiles = hintFiles.get(parentId);
+        if (parentFiles?.length) hintFiles.set(id, parentFiles);
+        return parentSourceType;
+      }
+    }
+    const sourceType = openCodeSqliteRowSourceType(row, dbPath, env, options, baseSourceType);
+    sourceTypes.set(id, sourceType);
+    return sourceType;
+  };
+  for (const row of sessionRows || []) classify(row);
+  return { sourceTypes, hintFiles };
+}
+
+function openCodeSqliteRowSourceType(row, dbPath, env = process.env, options = {}, baseSourceType = openCodeSqliteSourceType(dbPath, env, options)) {
+  if (baseSourceType === "opencode-desktop-sqlite-history") return baseSourceType;
+  if (!pathInsideAny(dbPath, openCodeCliDataRoots(env)) && !OPENCODE_SOURCE_KINDS.has(options.openCodeKind)) return baseSourceType;
+  if (openCodeSqliteRowHasCliMetadata(row)) return "opencode-cli-sqlite-history";
+  if (openCodeSqliteRowLooksWeb(row, dbPath, env)) return "opencode-web-sqlite-history";
+  return baseSourceType;
+}
+
+function openCodeSqliteRowHasCliMetadata(row) {
+  return Boolean(firstString(row?.agent, row?.model));
+}
+
+function openCodeSqliteRowLooksWeb(row, dbPath, env = process.env) {
+  const version = firstString(row?.version);
+  if (!version || version === "local") return false;
+  return pathInsideAny(dbPath, openCodeCliDataRoots(env));
+}
+
+function openCodeSqliteSourceType(dbPath, env = process.env, options = {}) {
+  if (pathInsideAny(dbPath, openCodeDesktopDataRoots(env))) return "opencode-desktop-sqlite-history";
+  if (pathInsideAny(dbPath, openCodeCliDataRoots(env))) return "opencode-sqlite-history";
+  if (options.openCodeKind === "cli") return "opencode-cli-sqlite-history";
+  if (options.openCodeKind === "desktop") return "opencode-desktop-sqlite-history";
+  if (options.openCodeKind === "web") return "opencode-web-sqlite-history";
+  return "opencode-sqlite-history";
+}
+
+function openCodeStorageSourceType(storageRoot, env = process.env, options = {}) {
+  if (options.openCodeKind === "cli") return "opencode-cli-history";
+  if (options.openCodeKind === "desktop") return "opencode-desktop-history";
+  if (pathInsideAny(storageRoot, openCodeCliDataRoots(env))) return "opencode-cli-history";
+  if (pathInsideAny(storageRoot, openCodeDesktopDataRoots(env))) return "opencode-desktop-history";
+  return "opencode-history";
+}
+
+function openCodeSourceKindForType(sourceType) {
+  if (String(sourceType || "").includes("cli")) return "cli";
+  if (String(sourceType || "").includes("desktop")) return "desktop";
+  if (String(sourceType || "").includes("web")) return "web";
+  return "unknown";
+}
+
+function pathInsideAny(candidate, roots) {
+  const resolved = path.resolve(String(candidate || ""));
+  return (roots || []).some((root) => {
+    if (!root) return false;
+    const resolvedRoot = path.resolve(String(root));
+    return resolved === resolvedRoot || resolved.startsWith(`${resolvedRoot}${path.sep}`);
+  });
+}
+
 function openCodeSqliteSessionTimestampExpr(sessionColumns) {
   const candidates = ["time_updated", "time_created"].filter((column) => sessionColumns.has(column)).map((column) => `s.${column}`);
   if (!candidates.length) return "";
@@ -6915,19 +7688,20 @@ function openCodeUsageFromMessageData(data, parts = []) {
   return Object.values(usage).some((value) => value !== undefined) ? usage : null;
 }
 
-function openCodeSqliteSessionFingerprint(dbPath, row, messageRows, sourceFiles) {
+function openCodeSqliteSessionFingerprint(dbPath, row, messageRows, sourceFiles, sourceType = "opencode-sqlite-history") {
   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)}`;
+  return `${fingerprintPrefix(sourceType)}:${structuredSessionFingerprint({ sourcePath: dbPath, sourceFiles })}:${hashId(sessionRevision)}`;
 }
 
-function parseOpenCodeSessionFile(file, storageRoot) {
+function parseOpenCodeSessionFile(file, storageRoot, env = process.env, options = {}) {
   const info = readJsonMaybe(file, null);
   if (!info || typeof info !== "object") return null;
+  const sourceType = openCodeStorageSourceType(storageRoot, env, options);
   const sessionId = firstString(info.id, info.sessionID, info.sessionId, path.basename(file, ".json"));
   if (!sessionId) return null;
   const projectId = firstString(info.projectID, info.projectId, path.basename(path.dirname(file)));
@@ -6938,7 +7712,7 @@ function parseOpenCodeSessionFile(file, storageRoot) {
   const diffMessage = openCodeDiffMessage(diffFile, parsedMessages[parsedMessages.length - 1]?.timestamp || toIso(info.time?.updated || info.updatedAt || info.createdAt));
   const messages = stampMessages(
     dedupeAdjacentMessages(parsedMessages.concat(diffMessage ? [diffMessage] : [])).sort((a, b) => String(a.timestamp).localeCompare(String(b.timestamp))),
-    "opencode-history"
+    sourceType
   );
   if (!messages.length) return null;
   const sourceFiles = [
@@ -6960,21 +7734,23 @@ function parseOpenCodeSessionFile(file, storageRoot) {
     messages,
     sourcePath: file,
     sourceFiles,
-    sourceType: "opencode-history",
-    fingerprint: `${fingerprintPrefix("opencode-history")}:${structuredSessionFingerprint({ sourcePath: file, sourceFiles })}`,
-    detailKey: "sessions"
+    sourceType,
+    fingerprint: `${fingerprintPrefix(sourceType)}:${structuredSessionFingerprint({ sourcePath: file, sourceFiles })}`,
+    detailKey: "sessions",
+    sessionSummary: { source: openCodeSourceKindForType(sourceType) }
   };
 }
 
-function parseOpenCodeMessageOnlySession(storageRoot, sessionId) {
+function parseOpenCodeMessageOnlySession(storageRoot, sessionId, env = process.env, options = {}) {
   if (!sessionId) return null;
+  const sourceType = openCodeStorageSourceType(storageRoot, env, options);
   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"
+    sourceType
   );
   if (!messages.length) return null;
   const sourceFiles = [
@@ -6994,9 +7770,10 @@ function parseOpenCodeMessageOnlySession(storageRoot, sessionId) {
     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"
+    sourceType,
+    fingerprint: `${fingerprintPrefix(sourceType)}:${structuredSessionFingerprint({ sourcePath: path.join(storageRoot, "message", sessionId), sourceFiles })}`,
+    detailKey: "sessions",
+    sessionSummary: { source: openCodeSourceKindForType(sourceType), recoveredFromMessages: true }
   };
 }
 
@@ -7365,7 +8142,12 @@ function dedupeOpenCodeSessions(sessions) {
 }
 
 function openCodeSourceRank(sourceType) {
+  if (sourceType === "opencode-cli-sqlite-history") return 3;
+  if (sourceType === "opencode-web-sqlite-history") return 3;
+  if (sourceType === "opencode-desktop-sqlite-history") return 3;
   if (sourceType === "opencode-sqlite-history") return 3;
+  if (sourceType === "opencode-cli-history") return 2;
+  if (sourceType === "opencode-desktop-history") return 2;
   if (sourceType === "opencode-history") return 2;
   return 1;
 }