agentel 0.2.3 → 0.2.5

package/src/importers.js

@@ -22,6 +22,8 @@ const { canonicalWebProvider, derivedAccountId, getWebAccount, upsertWebAccount
 
 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";
@@ -76,6 +78,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 +98,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 +122,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 +154,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: claudeCodeSidecarSessionSummary(sessionMetadata)
         },
         env
       );
@@ -172,7 +182,7 @@ function jsonlProviderSourceType(provider) {
 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 +209,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);
@@ -564,7 +574,7 @@ 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) {
@@ -602,16 +612,114 @@ 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: title ? "source" : inferredTitle ? "first-user-prompt" : "",
     messages: deduped,
     startedAt: deduped[0]?.timestamp || "",
     endedAt: deduped[deduped.length - 1]?.timestamp || ""
   };
 }
 
+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) {
+  if (parsed?.titleSource === "source") return parsed.title || "";
+  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 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) {
@@ -2388,7 +2496,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 +2551,38 @@ function discoverCliHistory(env = process.env, options = {}) {
   );
 
   publish(
-    "opencode",
-    "OpenCode",
+    "opencodeCli",
+    "OpenCode CLI",
+    summarizeStructuredSessions(
+      readOpenCodeSessions(env, {
+        openCodeKind: "cli",
+        onProgress: (event) => reportDiscoveryProgress(options, { ...event, provider: "OpenCode CLI" })
+      }),
+      "OpenCode CLI/core SQLite database plus project JSON session/message/part storage"
+    )
+  );
+
+  publish(
+    "opencodeDesktop",
+    "OpenCode Desktop",
     summarizeStructuredSessions(
       readOpenCodeSessions(env, {
-        onProgress: (event) => reportDiscoveryProgress(options, { ...event, provider: "OpenCode" })
+        openCodeKind: "desktop",
+        onProgress: (event) => reportDiscoveryProgress(options, { ...event, provider: "OpenCode Desktop" })
       }),
-      "OpenCode SQLite database and JSON session/message/part storage"
+      "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"
     )
   );
 
@@ -2524,7 +2657,7 @@ function summarizeClaudeSdkScan(scan) {
 }
 
 function summarizeClaudeDesktop(env = process.env, options = {}) {
-  const sessions = readClaudeDesktopSessions(options);
+  const sessions = readClaudeDesktopSessions(options, env);
   return summarizeClaudeDesktopSessions(sessions);
 }
 
@@ -3045,10 +3178,10 @@ function summarizeCodexSources(threads) {
   return { cli, desktop, ...(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 +3204,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 +3554,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 +3568,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 +4187,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 +4242,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,
@@ -4149,6 +4378,7 @@ const CURSOR_RAW_ASSISTANT_MERGE_MIN_SCORE = 32;
 const CURSOR_RAW_ASSISTANT_MERGE_MIN_OVERLAP = 2;
 const CURSOR_ABSOLUTE_PATH_RE = /(?:file:\/\/)?\/(?:Users|home|Volumes|private|tmp|var)\/[^\s"'`<>{}|]+/g;
 const SQLITE_QUERY_TIMEOUT_MS = 30 * 1000;
+const OPENCODE_SQLITE_BATCH_SIZE = 100;
 
 function readCursorRawSqliteSalvageSessionsFromDb(dbPath, options = {}) {
   const files = cursorRawSqliteFilesForDb(dbPath);
@@ -5150,6 +5380,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,
@@ -6538,13 +6773,24 @@ 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++) {
-    const dbSessions = readOpenCodeSqliteSessionsFromDb(dbs[index]);
+    let dbSessions = [];
+    try {
+      dbSessions = readOpenCodeSqliteSessionsFromDb(dbs[index], options, env);
+    } catch (error) {
+      reportDiscoveryProgress(options, {
+        current: index + 1,
+        total: dbs.length,
+        message: `SQLite skipped: ${error.message}`,
+        path: dbs[index]
+      });
+      continue;
+    }
     sessions.push(...dbSessions);
     reportDiscoveryProgress(options, {
       current: index + 1,
@@ -6557,7 +6803,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-/, ""));
@@ -6572,38 +6818,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 openCodeDataRoots(env = process.env) {
+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, 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")
+  ];
+  return roots;
+}
+
+function openCodeDesktopDataRoots(env = process.env) {
+  const home = env.HOME || env.USERPROFILE || os.homedir();
   const roots = [
-    path.join(home, ".local", "share", "opencode"),
+    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"));
@@ -6622,11 +6900,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")
   ]));
@@ -6656,31 +6934,64 @@ function openCodeMessageSessionIds(root) {
     .sort((a, b) => a.localeCompare(b));
 }
 
-function readOpenCodeSqliteSessionsFromDb(dbPath) {
+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);
-  const messageRows = readOpenCodeSqliteMessageRows(dbPath);
-  const partRows = readOpenCodeSqlitePartRows(dbPath);
+  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"]);
   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 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),
@@ -6689,11 +7000,12 @@ function readOpenCodeSqliteSessionsFromDb(dbPath) {
       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,
@@ -6709,11 +7021,12 @@ function readOpenCodeSqliteSessionsFromDb(dbPath) {
   return sessions;
 }
 
-function readOpenCodeSqliteSessionRows(dbPath) {
+function readOpenCodeSqliteSessionRows(dbPath, options = {}) {
   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 timestampExpr = openCodeSqliteSessionTimestampExpr(sessionColumns);
   const selects = [
     "s.id",
     sqliteSelectMaybe(sessionColumns, "s", "project_id"),
@@ -6735,7 +7048,11 @@ function readOpenCodeSqliteSessionRows(dbPath) {
   ];
   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 where = [];
+  if (sessionColumns.has("time_archived")) where.push("coalesce(s.time_archived, 0) = 0");
+  const sinceCondition = openCodeSqliteSinceCondition(timestampExpr, options.since);
+  if (sinceCondition) where.push(sinceCondition);
+  if (where.length) queryParts.push(`where ${where.join(" and ")}`);
   const orderColumns = [];
   if (sessionColumns.has("time_updated")) orderColumns.push("s.time_updated desc");
   if (sessionColumns.has("time_created")) orderColumns.push("s.time_created desc");
@@ -6744,7 +7061,109 @@ function readOpenCodeSqliteSessionRows(dbPath) {
   return readSqliteJson(dbPath, queryParts.join(" "), "OpenCode SQLite sessions");
 }
 
-function readOpenCodeSqliteMessageRows(dbPath) {
+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 "";
+  return candidates.length === 1 ? candidates[0] : `coalesce(${candidates.join(", ")})`;
+}
+
+function openCodeSqliteSinceCondition(timestampExpr, since) {
+  if (!timestampExpr || !since) return "";
+  const sinceTime = since instanceof Date ? since.getTime() : Date.parse(since);
+  if (!Number.isFinite(sinceTime)) return "";
+  const sinceMs = Math.floor(sinceTime);
+  const sinceSeconds = Math.floor(sinceTime / 1000);
+  const sinceIso = new Date(sinceTime).toISOString();
+  return `((${timestampExpr} is not null) and ((abs(${timestampExpr}) > 1000000000000 and ${timestampExpr} >= ${sinceMs}) or (abs(${timestampExpr}) <= 1000000000000 and ${timestampExpr} >= ${sinceSeconds}) or (typeof(${timestampExpr}) = 'text' and datetime(${timestampExpr}) >= datetime(${sqlQuote(sinceIso)}))))`;
+}
+
+function readOpenCodeSqliteMessageRows(dbPath, sessionIds = []) {
   const columns = sqliteTableColumns(dbPath, "message");
   if (!columns.has("id") || !columns.has("session_id")) return [];
   const selects = [
@@ -6754,13 +7173,16 @@ function readOpenCodeSqliteMessageRows(dbPath) {
     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");
+  return readOpenCodeSqliteRowsForSessionIds(
+    dbPath,
+    "message",
+    selects,
+    sessionIds,
+    "OpenCode SQLite messages"
+  );
 }
 
-function readOpenCodeSqlitePartRows(dbPath) {
+function readOpenCodeSqlitePartRows(dbPath, sessionIds = []) {
   const columns = sqliteTableColumns(dbPath, "part");
   if (!columns.has("id") || !columns.has("message_id") || !columns.has("session_id")) return [];
   const selects = [
@@ -6771,10 +7193,46 @@ function readOpenCodeSqlitePartRows(dbPath) {
     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");
+  return readOpenCodeSqliteRowsForSessionIds(
+    dbPath,
+    "part",
+    selects,
+    sessionIds,
+    "OpenCode SQLite parts"
+  );
+}
+
+function readOpenCodeSqliteRowsForSessionIds(dbPath, tableName, selects, sessionIds, label) {
+  const ids = [...new Set((sessionIds || []).map((id) => String(id || "")).filter(Boolean))];
+  if (!ids.length) return [];
+  const rows = [];
+  for (let index = 0; index < ids.length; index += OPENCODE_SQLITE_BATCH_SIZE) {
+    const batch = ids.slice(index, index + OPENCODE_SQLITE_BATCH_SIZE);
+    const query = [
+      `select ${selects.join(", ")}`,
+      `from ${tableName}`,
+      `where session_id in (${batch.map(sqlQuote).join(",")})`
+    ].join(" ");
+    rows.push(...readSqliteJson(dbPath, query, label));
+  }
+  return rows;
+}
+
+function sortOpenCodeSqliteRows(rows, keys) {
+  return rows.sort((left, right) => {
+    for (const key of keys) {
+      const result = compareOpenCodeSqliteValues(left?.[key], right?.[key]);
+      if (result) return result;
+    }
+    return 0;
+  });
+}
+
+function compareOpenCodeSqliteValues(left, right) {
+  const leftNumber = Number(left);
+  const rightNumber = Number(right);
+  if (Number.isFinite(leftNumber) && Number.isFinite(rightNumber) && leftNumber !== rightNumber) return leftNumber - rightNumber;
+  return String(left || "").localeCompare(String(right || ""));
 }
 
 function openCodeSqliteMessagesFromRow(row, partRows, index) {
@@ -6841,19 +7299,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)));
@@ -6864,7 +7323,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 = [
@@ -6886,21 +7345,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 = [
@@ -6920,9 +7381,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 }
   };
 }
 
@@ -7291,7 +7753,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;
 }