agentel 0.2.5 → 0.2.6

package/src/importers.js

@@ -19,6 +19,7 @@ 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";
@@ -46,6 +47,7 @@ function importProviderHelpers() {
     importCursorProvider,
     importJsonlProvider,
     importStructuredProvider,
+    manualImportInstructionResult,
     readAntigravitySessions,
     readAiderSessions,
     readClineSessions,
@@ -157,7 +159,7 @@ function importJsonlProvider(provider, roots, since, options = {}, env = process
           sourceFiles: [item.file, sessionMetadata?.sourcePath || "", ...auxiliaryFiles].filter(Boolean),
           sourceType,
           title: jsonlSessionTitleForImport(parsed, sessionMetadata),
-          sessionSummary: claudeCodeSidecarSessionSummary(sessionMetadata)
+          sessionSummary: mergeSessionSummaries(claudeCodeSidecarSessionSummary(sessionMetadata), parsed.sessionSummary)
         },
         env
       );
@@ -179,6 +181,12 @@ 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);
@@ -257,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);
@@ -288,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++;
@@ -579,10 +589,12 @@ function structuredSessionUsesSharedRawFiles(provider, 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;
@@ -592,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,
@@ -603,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;
@@ -617,13 +643,292 @@ function parseAgentJsonl(file, provider) {
     cwd,
     sessionId,
     title: title || inferredTitle,
-    titleSource: title ? "source" : inferredTitle ? "first-user-prompt" : "",
+    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;
@@ -665,7 +970,6 @@ function isClaudeJsonlProvider(provider) {
 }
 
 function jsonlSessionTitleForImport(parsed, metadata = null) {
-  if (parsed?.titleSource === "source") return parsed.title || "";
   return firstString(metadata?.title, parsed?.title);
 }
 
@@ -701,6 +1005,23 @@ function claudeCodeSidecarSessionSummary(metadata = null) {
   });
 }
 
+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;
@@ -757,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(
@@ -2487,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({
@@ -2613,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
@@ -2629,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() {
@@ -2888,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";
@@ -2900,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) {
@@ -3173,9 +3561,10 @@ 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 = {}, env = process.env) {

package/src/parser-versions.js

@@ -10,6 +10,7 @@ const SOURCE_TYPE_ALIASES = {
 const PARSER_VERSION_SUFFIXES = {
   "codex-cli-history": 0,
   "codex-desktop-history": 0,
+  "codex-sdk-history": 0,
   "cli-history": 0,
   "claude-sdk-history": 0,
   "claude-code-desktop-metadata": 0,

package/src/search.js

@@ -1103,6 +1103,7 @@ function normalizeProviderFilter(value) {
     codex: { provider: "codex" },
     codex_cli: { provider: "codex", sourceType: "codex-cli-history", sourceTypes: ["codex-cli-history", "cli-history"] },
     codex_desktop: { provider: "codex", sourceType: "codex-desktop-history", sourceTypes: ["codex-desktop-history"] },
+    codex_sdk: { provider: "codex", sourceType: "codex-sdk-history", sourceTypes: ["codex-sdk-history"] },
     cursor: { provider: "cursor" },
     cline: { provider: "cline", sourceType: "cline-task-history", sourceTypes: ["cline-task-history"] },
     opencode: { provider: "opencode", sourceTypes: ["opencode-cli-history", "opencode-cli-sqlite-history", "opencode-desktop-history", "opencode-desktop-sqlite-history", "opencode-web-sqlite-history", "opencode-history", "opencode-sqlite-history"] },

package/src/sources.js

@@ -6,6 +6,7 @@ const SOURCE_GROUPS = [
     sources: [
       { source: "codex-cli", provider: "codex", sourceType: "codex-cli-history", label: "Codex CLI" },
       { source: "codex-desktop", provider: "codex", sourceType: "codex-desktop-history", label: "Codex Desktop" },
+      { source: "codex-sdk", provider: "codex", sourceType: "codex-sdk-history", label: "Codex SDK jobs" },
       { source: "chatgpt", provider: "chatgpt", label: "ChatGPT" }
     ]
   },

package/src/web-export-instructions.js

@@ -0,0 +1,77 @@
+"use strict";
+
+const WEB_EXPORT_INSTRUCTIONS = {
+  chatgpt: {
+    source: "chatgpt",
+    provider: "chatgpt",
+    label: "ChatGPT",
+    requestUrl: "https://privacy.openai.com/policies/en/",
+    helpUrl: "https://help.openai.com/en/articles/7260999-how-do-i-export-my-chatgpt-history-and-data",
+    fileDescription: "official ChatGPT data export ZIP or extracted folder",
+    importCommand: "agentlog import chatgpt <path-to-export.zip> --username <email> --scope local",
+    steps: [
+      "Open the OpenAI Privacy Portal, choose Make a Privacy Request, select I have a consumer ChatGPT account, then select Download my data.",
+      "Or in ChatGPT, open your profile menu, choose Settings, open Data Controls, then use Export Data.",
+      "Complete account verification and wait for the export email.",
+      "Download the ZIP before the email link expires, then pass the ZIP or extracted folder to agentlog."
+    ],
+    notes: [
+      "OpenAI says ChatGPT Business and Enterprise chat exports are not available through the ChatGPT account export flow.",
+      "OpenAI export emails can take time to arrive, and the download link expires after 24 hours."
+    ]
+  },
+  "claude-web": {
+    source: "claude-web",
+    provider: "claude_web",
+    label: "Claude.ai",
+    requestUrl: "https://claude.ai/settings/privacy",
+    helpUrl: "https://support.claude.com/en/articles/9450526-how-can-i-export-my-claude-data",
+    fileDescription: "official Claude.ai data export ZIP or extracted folder",
+    importCommand: "agentlog import claude-web <path-to-export.zip> --username <email-or-name> --scope local",
+    steps: [
+      "Open Claude on the web or Claude Desktop and go to Settings > Privacy.",
+      "Click Export data.",
+      "Wait for Claude to email the download link to the address on the account.",
+      "Download the ZIP before the email link expires, then pass the ZIP or extracted folder to agentlog."
+    ],
+    notes: [
+      "Claude's mobile apps cannot start a data export.",
+      "Claude requires you to be signed in when using the emailed download link, and the link expires after 24 hours."
+    ]
+  }
+};
+
+function canonicalWebExportInstructionSource(source) {
+  const value = String(source || "").trim().toLowerCase().replace(/[_\s]+/g, "-");
+  if (value === "chatgpt" || value === "openai") return "chatgpt";
+  if (value === "claude-ai" || value === "claude-web") return "claude-web";
+  return "";
+}
+
+function webExportInstructions(source) {
+  const key = canonicalWebExportInstructionSource(source);
+  return key ? WEB_EXPORT_INSTRUCTIONS[key] : null;
+}
+
+function manualImportInstructionResult(source) {
+  const instructions = webExportInstructions(source);
+  if (!instructions) throw new Error(`unknown web export instruction source: ${source}`);
+  return {
+    provider: instructions.provider,
+    source: instructions.source,
+    manual: true,
+    instructions,
+    discovered: 0,
+    candidates: 0,
+    imported: 0,
+    skipped: 0,
+    errors: []
+  };
+}
+
+module.exports = {
+  WEB_EXPORT_INSTRUCTIONS,
+  canonicalWebExportInstructionSource,
+  manualImportInstructionResult,
+  webExportInstructions
+};