agentel 0.2.5 → 0.2.8

package/src/importers.js

@@ -7,7 +7,7 @@ const path = require("path");
 const zlib = require("zlib");
 const { execFileSync, spawnSync } = require("child_process");
 const { fileURLToPath } = require("url");
-const { archiveRoot, deleteSessionArchive, listSessions, readTranscript, writeSession, stableSessionId, toIso } = require("./archive");
+const { archiveRoot, computeSessionUsage, deleteSessionArchive, listSessions, readTranscript, writeSession, stableSessionId, toIso } = require("./archive");
 const { fingerprintPrefix, parserVersionForSource } = require("./parser-versions");
 const { canonicalRepo } = require("./repo");
 const { ensureDir, paths, readJson, writeJson } = require("./paths");
@@ -19,9 +19,11 @@ 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 EXPORT_ZIP_ENTRY_MAX_BUFFER = 1024 * 1024 * 512;
 const OPENCODE_SOURCE_KINDS = new Set(["cli", "desktop", "web"]);
 const OPENCODE_SESSION_ID_RE = /\bses_[A-Za-z0-9]+\b/g;
 
@@ -46,6 +48,7 @@ function importProviderHelpers() {
     importCursorProvider,
     importJsonlProvider,
     importStructuredProvider,
+    manualImportInstructionResult,
     readAntigravitySessions,
     readAiderSessions,
     readClineSessions,
@@ -79,10 +82,22 @@ function importJsonlProvider(provider, roots, since, options = {}, env = process
   const files =
     provider === "claude_code" ? claudeFiles(env) : provider === "claude_sdk" ? claudeSdkFiles(env) : jsonlFiles(roots);
   const claudeCodeMetadata = provider === "claude_code" ? claudeCodeSessionMetadataByCliSessionId(env) : new Map();
+  const claudeSubagentCache = provider === "claude_code" ? new Map() : null;
 
   const candidates = files
-    .map((file) => ({ file, stat: safeStat(file) }))
-    .filter((item) => item.stat && (!since || item.stat.mtime >= since))
+    .map((file) => {
+      const stat = safeStat(file);
+      const claudeSubagentRunSourceFiles = provider === "claude_code"
+        ? claudeSubagentRunSourceFilesForSession(claudeSessionIdFromFilename(file), file, env)
+        : [];
+      return {
+        file,
+        stat,
+        claudeSubagentRunSourceFiles,
+        importMtimeMs: latestFileMtimeMs([file, ...claudeSubagentRunSourceFiles], stat)
+      };
+    })
+    .filter((item) => item.stat && (!since || item.importMtimeMs >= since.getTime()))
     .sort((a, b) => a.file.localeCompare(b.file));
 
   const summary = {
@@ -98,7 +113,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 baseFingerprint = `${fingerprintPrefix(sourceType)}:${fileFingerprint(item.file, item.stat)}`;
+    const subagentRunFingerprint = provider === "claude_code" ? filesFingerprint(item.claudeSubagentRunSourceFiles) : "";
+    const baseFingerprint = [
+      `${fingerprintPrefix(sourceType)}:${fileFingerprint(item.file, item.stat)}`,
+      subagentRunFingerprint ? `claude-subagent-runs:${subagentRunFingerprint}` : ""
+    ].filter(Boolean).join(":");
     const preliminaryMetadata = provider === "claude_code"
       ? claudeCodeMetadata.get(claudeSessionIdFromFilename(item.file)) || null
       : null;
@@ -128,6 +147,12 @@ function importJsonlProvider(provider, roots, since, options = {}, env = process
     const cwd = parsed.cwd || sessionMetadata?.cwd || "";
     const scopeCanonical = cwd ? "" : uncategorizedScope(provider);
     const repo = repoInfoForImport(provider, cwd, sessionMetadata);
+    const claudeSubagents = provider === "claude_code"
+      ? claudeSubagentImportContext(repoCwdForImport(provider, cwd, sessionMetadata), env, claudeSubagentCache)
+      : null;
+    const claudeSubagentRuns = provider === "claude_code"
+      ? claudeSubagentRunImportContext(sessionId, item.file, env, item.claudeSubagentRunSourceFiles)
+      : null;
     if (options.repos && options.repos.length && (!repo || !options.repos.includes(repo.key))) {
       summary.skipped++;
       reportProgress(options, summary, index + 1, item.file);
@@ -154,18 +179,48 @@ function importJsonlProvider(provider, roots, since, options = {}, env = process
           startedAt: parsed.startedAt,
           endedAt: parsed.endedAt,
           sourcePath: item.file,
-          sourceFiles: [item.file, sessionMetadata?.sourcePath || "", ...auxiliaryFiles].filter(Boolean),
+          sourceFiles: [
+            item.file,
+            sessionMetadata?.sourcePath || "",
+            ...auxiliaryFiles,
+            ...(claudeSubagents?.sourceFiles || []),
+            ...(claudeSubagentRuns?.sourceFiles || [])
+          ].filter(Boolean),
           sourceType,
           title: jsonlSessionTitleForImport(parsed, sessionMetadata),
-          sessionSummary: claudeCodeSidecarSessionSummary(sessionMetadata)
+          sessionSummary: mergeSessionSummaries(
+            claudeCodeSidecarSessionSummary(sessionMetadata),
+            parsed.sessionSummary,
+            claudeSubagents?.sessionSummary,
+            claudeSubagentRuns?.sessionSummary
+          )
         },
         env
       );
       state.files[fingerprint] = { sessionId, at: new Date().toISOString() };
       state.sessions[sessionId] = { provider, sourcePath: item.file, fingerprint, auxiliary: auxiliaryFiles.length || undefined, at: new Date().toISOString() };
       archived.add(archiveSessionKey(provider, sessionId));
+      for (const subagentSession of claudeSubagentRuns?.sessions || []) {
+        writeSession(
+          {
+            ...subagentSession,
+            repoInfo: repo || undefined,
+            scopeCanonical,
+            sourceType
+          },
+          env
+        );
+        state.sessions[subagentSession.sessionId] = {
+          provider,
+          sourcePath: subagentSession.sourcePath,
+          fingerprint: `${fingerprintPrefix(sourceType)}:${filesFingerprint(subagentSession.sourceFiles || [subagentSession.sourcePath])}`,
+          parentSessionId: sessionId,
+          at: new Date().toISOString()
+        };
+        archived.add(archiveSessionKey(provider, subagentSession.sessionId));
+      }
     }
-    summary.imported++;
+    summary.imported += 1 + (claudeSubagentRuns?.sessions?.length || 0);
     reportProgress(options, summary, index + 1, item.file);
   }
 
@@ -179,6 +234,52 @@ 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 finalizeCodexParsedThread(thread, parsed) {
+  const result = { ...(parsed || {}) };
+  result.messages = Array.isArray(parsed?.messages) ? [...parsed.messages] : [];
+  result.messages.push(...codexSupplementaryMessages(thread, result.endedAt || thread?.updatedAt));
+  result.messages = dedupeAdjacentMessages(result.messages)
+    .sort((a, b) => String(a.timestamp || "").localeCompare(String(b.timestamp || "")));
+  result.startedAt = result.messages[0]?.timestamp || result.startedAt;
+  result.endedAt = result.messages[result.messages.length - 1]?.timestamp || result.endedAt;
+  result.sessionSummary = mergeSessionSummaries(result.sessionSummary, codexThreadStateSessionSummary(thread));
+  return result;
+}
+
+function codexThreadStateSessionSummary(thread) {
+  const rawTotalTokens = Number(thread?.tokensUsed);
+  const totalTokens = Number.isFinite(rawTotalTokens) && rawTotalTokens > 0 ? rawTotalTokens : 0;
+  const model = firstString(thread?.model);
+  if (!totalTokens && !model) return null;
+  return {
+    usage: totalTokens ? { totalTokens, authoritativeTotalTokens: true, source: "codex-state-tokens-used" } : undefined,
+    modelUsage: model ? [{ model, source: "codex-state" }] : undefined
+  };
+}
+
+function codexSubagentChildrenByParent(threads) {
+  const byParent = new Map();
+  for (const thread of threads || []) {
+    if (!thread?.parentThreadId) continue;
+    const children = byParent.get(thread.parentThreadId) || [];
+    children.push(thread);
+    byParent.set(thread.parentThreadId, children);
+  }
+  for (const children of byParent.values()) {
+    children.sort((a, b) => {
+      const time = String(a.createdAt || a.updatedAt || "").localeCompare(String(b.createdAt || b.updatedAt || ""));
+      return time || String(a.id || "").localeCompare(String(b.id || ""));
+    });
+  }
+  return byParent;
+}
+
 function importClaudeDesktopProvider(provider, since, options = {}, env = process.env) {
   const state = loadImportState(env);
   const archived = archivedSessionKeys(env);
@@ -257,17 +358,20 @@ 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);
   });
+  const codexSubagentChildren = codexSubagentChildrenByParent(threads);
+  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);
   const archived = archivedSessionKeys(env);
   const candidates = threads
     .filter((thread) => thread.rolloutPath)
-    .filter((thread) => !since || new Date(thread.updatedAt || thread.createdAt) >= since)
+    .filter((thread) => !since || new Date(codexThreadImportUpdatedAt(thread, codexSubagentChildren.get(thread.id) || [])) >= since)
     .sort((a, b) => a.rolloutPath.localeCompare(b.rolloutPath));
   const summary = {
     provider,
@@ -288,8 +392,14 @@ 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 fingerprint = `${fingerprintPrefix(sourceType)}:${fileFingerprint(thread.rolloutPath, stat)}:${codexSupplementFingerprint(thread)}`;
+    const sourceType = codexThreadSourceType(thread);
+    const children = codexSubagentChildren.get(thread.id) || [];
+    const fingerprint = [
+      `${fingerprintPrefix(sourceType)}:${fileFingerprint(thread.rolloutPath, stat)}`,
+      codexSupplementFingerprint(thread),
+      codexThreadMetadataFingerprint(thread),
+      codexSubagentRunsFingerprint(children)
+    ].filter(Boolean).join(":");
     if (alreadyImported(state, thread.id, fingerprint, archived, provider)) {
       summary.skipped++;
       reportProgress(options, summary, index + 1, thread.rolloutPath);
@@ -303,10 +413,7 @@ function importCodexProvider(provider, since, options = {}, env = process.env) {
       reportProgress(options, summary, index + 1, thread.rolloutPath);
       continue;
     }
-    parsed.messages.push(...codexSupplementaryMessages(thread, parsed.endedAt || thread.updatedAt));
-    parsed.messages = dedupeAdjacentMessages(parsed.messages).sort((a, b) => String(a.timestamp || "").localeCompare(String(b.timestamp || "")));
-    parsed.startedAt = parsed.messages[0]?.timestamp || parsed.startedAt;
-    parsed.endedAt = parsed.messages[parsed.messages.length - 1]?.timestamp || parsed.endedAt;
+    parsed = finalizeCodexParsedThread(thread, parsed);
     if (!parsed.messages.length) {
       state.files[fingerprint] = { skipped: true, reason: "no messages", at: new Date().toISOString() };
       summary.skipped++;
@@ -328,6 +435,8 @@ function importCodexProvider(provider, since, options = {}, env = process.env) {
       reportProgress(options, summary, index + 1, thread.rolloutPath);
       continue;
     }
+    const codexSubagentRuns = codexSubagentRunImportContext(thread, children, env);
+    const codexSubagentRun = codexSubagentSessionSummary(thread, parsed, env);
     if (!options.dryRun) {
       writeSession(
         {
@@ -340,9 +449,12 @@ function importCodexProvider(provider, since, options = {}, env = process.env) {
           startedAt: parsed.startedAt || thread.createdAt,
           endedAt: parsed.endedAt || thread.updatedAt,
           sourcePath: thread.rolloutPath,
-          sourceFiles: codexSourceFiles(thread, env),
+          sourceFiles: codexSourceFiles(thread, env, children),
           sourceType,
-          title: thread.title || parsed.title
+          title: codexSessionTitleForImport(thread, parsed),
+          sessionSummary: mergeSessionSummaries(parsed.sessionSummary, codexSubagentRuns?.sessionSummary, codexSubagentRun?.sessionSummary),
+          conversationKind: thread.isCodexSubagent ? "codex_subagent" : undefined,
+          parentComposerId: thread.parentThreadId || undefined
         },
         env
       );
@@ -579,10 +691,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 +706,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 +718,24 @@ function parseAgentJsonl(file, provider) {
       event.payload?.session_id,
       event.sessionId
     );
-    title ||= firstString(event.title, event.conversation_title, event.payload?.title);
+    const codexThreadTitle = provider === "codex" ? codexThreadNameFromEvent(event) : "";
+    if (codexThreadTitle) {
+      title = codexThreadTitle;
+      titleSource = "thread-name";
+    } else 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 +749,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;
@@ -648,24 +1059,53 @@ function claudeWorktreeParentRepo(provider, cwd) {
 }
 
 function inferredJsonlSessionTitle(provider, messages) {
-  if (!isClaudeJsonlProvider(provider)) return "";
+  if (!isClaudeJsonlProvider(provider) && provider !== "codex") 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();
+  const cleaned = cleanPromptTitleLine(promptTitleLine(value));
   if (!cleaned) return "";
   const max = 96;
   return cleaned.length > max ? `${cleaned.slice(0, max - 1).trimEnd()}…` : cleaned;
 }
 
+function promptTitleLine(value) {
+  const lines = String(value || "")
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+  if (!lines.length) return "";
+  if (isAgentlogRecallSkillLine(lines[0]) && lines.length > 1) {
+    const candidate = lines.slice(1).find((line) => cleanPromptTitleLine(line) && !lowSignalPromptTitleLine(line));
+    if (candidate) return candidate;
+  }
+  return lines[0];
+}
+
+function cleanPromptTitleLine(value) {
+  return String(value || "")
+    .replace(/\[\$[^\]\n]+\]\([^)]+\)\s*/g, "")
+    .replace(/\[([^\]\n]+)\]\([^)]+\)/g, "$1")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function isAgentlogRecallSkillLine(value) {
+  return /^\[\$agentlog-recall\]\([^)]+\)/i.test(String(value || "").trim());
+}
+
+function lowSignalPromptTitleLine(value) {
+  const cleaned = cleanPromptTitleLine(value);
+  return /^#/.test(cleaned) || /^<[^>]+>/.test(cleaned) || /^['"]?\/[^'"]+['"]?$/.test(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);
 }
 
@@ -701,6 +1141,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 +1214,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(
@@ -864,21 +1366,37 @@ function applyCodexTokenCount(event, provider, messages, context) {
   if (String(payload.type || event.type || "").toLowerCase() !== "token_count") return false;
   const usage = codexTokenUsage(payload);
   if (!usage) return true;
-  const previous = context.tokenUsage || { input: 0, output: 0 };
-  const inputDelta = previous.input || previous.output ? Math.max(0, usage.input - previous.input) : usage.input;
-  const outputDelta = previous.input || previous.output ? Math.max(0, usage.output - previous.output) : usage.output;
+  const previous = context.tokenUsage || { input: 0, output: 0, cachedInput: 0, reasoningOutput: 0, total: 0 };
+  const hasPrevious = codexTokenUsageHasProgress(previous);
+  const inputDelta = hasPrevious ? Math.max(0, usage.input - previous.input) : usage.input;
+  const outputDelta = hasPrevious ? Math.max(0, usage.output - previous.output) : usage.output;
+  const cacheInputDelta = hasPrevious ? Math.max(0, usage.cachedInput - previous.cachedInput) : usage.cachedInput;
+  const reasoningOutputDelta = hasPrevious ? Math.max(0, usage.reasoningOutput - previous.reasoningOutput) : usage.reasoningOutput;
+  const totalDelta = usage.total
+    ? (hasPrevious ? Math.max(0, usage.total - previous.total) : usage.total)
+    : inputDelta + outputDelta;
   context.tokenUsage = usage;
   const target = [...messages].reverse().find((message) => message.role === "assistant");
   if (!target) return true;
+  const existingUsage = target.metadata?.usage && typeof target.metadata.usage === "object" ? target.metadata.usage : {};
+  const freshInputDelta = Math.max(0, inputDelta - cacheInputDelta);
+  const nextUsage = compactMetadata({
+    ...existingUsage,
+    inputTokens: addTokenNumbers(existingUsage.inputTokens, freshInputDelta),
+    outputTokens: addTokenNumbers(existingUsage.outputTokens, outputDelta),
+    cacheInputTokens: addTokenNumbers(existingUsage.cacheInputTokens, cacheInputDelta),
+    reasoningOutputTokens: addTokenNumbers(existingUsage.reasoningOutputTokens, reasoningOutputDelta),
+    reasoningOutputTokensIncludedInOutput: reasoningOutputDelta || existingUsage.reasoningOutputTokensIncludedInOutput ? true : undefined,
+    totalTokens: addTokenNumbers(existingUsage.totalTokens, totalDelta || freshInputDelta + cacheInputDelta + outputDelta),
+    totalInputTokens: usage.input,
+    totalOutputTokens: usage.output,
+    totalCacheInputTokens: usage.cachedInput || undefined,
+    totalReasoningOutputTokens: usage.reasoningOutput || undefined
+  });
   target.metadata = {
     ...(target.metadata || {}),
     provider,
-    usage: {
-      inputTokens: inputDelta,
-      outputTokens: outputDelta,
-      totalInputTokens: usage.input,
-      totalOutputTokens: usage.output
-    }
+    usage: nextUsage
   };
   return true;
 }
@@ -894,11 +1412,50 @@ function codexTokenUsage(payload) {
   for (const item of candidates) {
     const input = Number(item?.input_tokens ?? item?.inputTokens ?? item?.prompt_tokens ?? item?.promptTokens);
     const output = Number(item?.output_tokens ?? item?.outputTokens ?? item?.completion_tokens ?? item?.completionTokens);
-    if (Number.isFinite(input) && Number.isFinite(output)) return { input, output };
+    if (Number.isFinite(input) && Number.isFinite(output)) {
+      const cachedInput = Number(
+        item?.cached_input_tokens ??
+        item?.cachedInputTokens ??
+        item?.cache_read_input_tokens ??
+        item?.cacheReadInputTokens ??
+        item?.cacheInputTokens ??
+        item?.prompt_tokens_details?.cached_tokens ??
+        item?.promptTokensDetails?.cachedTokens
+      );
+      const reasoningOutput = Number(
+        item?.reasoning_output_tokens ??
+        item?.reasoningOutputTokens ??
+        item?.reasoning_tokens ??
+        item?.reasoningTokens ??
+        item?.completion_tokens_details?.reasoning_tokens ??
+        item?.completionTokensDetails?.reasoningTokens ??
+        item?.output_tokens_details?.reasoning_tokens ??
+        item?.outputTokensDetails?.reasoningTokens
+      );
+      const total = Number(item?.total_tokens ?? item?.totalTokens ?? item?.totalTokenCount ?? item?.total_token_count ?? item?.total);
+      return {
+        input,
+        output,
+        cachedInput: Number.isFinite(cachedInput) && cachedInput > 0 ? cachedInput : 0,
+        reasoningOutput: Number.isFinite(reasoningOutput) && reasoningOutput > 0 ? reasoningOutput : 0,
+        total: Number.isFinite(total) && total > 0 ? total : input + output
+      };
+    }
   }
   return null;
 }
 
+function codexTokenUsageHasProgress(usage) {
+  return Boolean((usage?.input || 0) || (usage?.output || 0) || (usage?.cachedInput || 0) || (usage?.reasoningOutput || 0) || (usage?.total || 0));
+}
+
+function addTokenNumbers(left, right) {
+  const a = Number(left || 0);
+  const b = Number(right || 0);
+  const sum = (Number.isFinite(a) && a > 0 ? a : 0) + (Number.isFinite(b) && b > 0 ? b : 0);
+  return sum || undefined;
+}
+
 function extractCodexSpecialMessage(event, provider, context = {}) {
   if (provider !== "codex") return null;
   const item = event?.payload || event?.item || event?.data || event;
@@ -1398,7 +1955,17 @@ function extractText(value, depth = 0) {
 
 function importWebChat(providerInput, file, options = {}, env = process.env) {
   const provider = canonicalWebProvider(providerInput);
-  const source = readExportBundle(file);
+  reportWebImportProgress(options, provider, {
+    current: 0,
+    total: 0,
+    message: "reading export"
+  });
+  const source = readExportBundle(file, provider);
+  reportWebImportProgress(options, provider, {
+    current: 0,
+    total: source.entries.length || 0,
+    message: source.entries.length ? `parsed ${source.entries.length} export files` : "parsed export"
+  });
   const sourceAccountId = options.accountId || inferWebSourceAccountId(provider, source);
   let accountId = options.accountId || sourceAccountId;
   const existing = accountId ? getWebAccount(provider, accountId, env) : null;
@@ -1416,6 +1983,11 @@ function importWebChat(providerInput, file, options = {}, env = process.env) {
     displayName: options.displayName || existing?.displayName || inferredUsername,
     sourceAccountId
   }, env);
+  reportWebImportProgress(options, provider, {
+    current: 0,
+    total: source.entries.length || 0,
+    message: "normalizing conversations"
+  });
   const normalized = normalizeWebConversations(provider, source, account);
   const conversations = normalized.conversations;
   const summary = {
@@ -1431,19 +2003,39 @@ function importWebChat(providerInput, file, options = {}, env = process.env) {
   };
   const state = loadImportState(env);
   const archived = archivedSessionKeys(env);
-  const sharedRaw = options.dryRun ? null : ensureSharedWebExportRaw(provider, source, account, env);
+  reportWebImportProgress(options, provider, {
+    current: 0,
+    total: conversations.length,
+    message: `found ${conversations.length} conversations`
+  });
+  const sharedRaw = options.dryRun ? null : ensureSharedWebExportRaw(provider, source, account, env, options);
 
-  for (const conversation of conversations) {
+  conversations.forEach((conversation, index) => {
+    const current = index + 1;
     if (!conversation.messages.length) {
       summary.skipped++;
-      continue;
+      reportWebImportProgress(options, provider, {
+        current,
+        total: conversations.length,
+        imported: summary.imported,
+        skipped: summary.skipped,
+        errors: summary.errors.length
+      });
+      return;
     }
     const sourceType = conversation.sourceType || webConversationSourceType(provider, conversation);
     const sessionId = webConversationSessionId(provider, account.accountId, conversation.id);
     const fingerprint = webConversationFingerprint(sourceType, account.accountId, conversation);
     if (alreadyImported(state, sessionId, fingerprint, archived, provider)) {
       summary.skipped++;
-      continue;
+      reportWebImportProgress(options, provider, {
+        current,
+        total: conversations.length,
+        imported: summary.imported,
+        skipped: summary.skipped,
+        errors: summary.errors.length
+      });
+      return;
     }
     const scopeCanonical = webConversationScope(provider, account.accountId, conversation.projectPath);
     const displayPath = webConversationDisplayPath(account.displayName, conversation.projectPath);
@@ -1489,12 +2081,36 @@ function importWebChat(providerInput, file, options = {}, env = process.env) {
       archived.add(archiveSessionKey(provider, sessionId));
     }
     summary.imported++;
-  }
+    reportWebImportProgress(options, provider, {
+      current,
+      total: conversations.length,
+      imported: summary.imported,
+      skipped: summary.skipped,
+      errors: summary.errors.length
+    });
+  });
 
   if (!options.dryRun) saveImportState(state, env);
+  reportWebImportProgress(options, provider, {
+    current: conversations.length,
+    total: conversations.length,
+    imported: summary.imported,
+    skipped: summary.skipped,
+    errors: summary.errors.length,
+    message: `${options.dryRun ? "dry run complete" : "import complete"}: imported=${summary.imported} skipped=${summary.skipped}`
+  });
   return summary;
 }
 
+function reportWebImportProgress(options, provider, event) {
+  if (typeof options.onProgress !== "function") return;
+  options.onProgress({
+    kind: "import",
+    provider: providerLabelForWeb(provider),
+    ...event
+  });
+}
+
 function importWindsurfTrajectoryExport(target, options = {}, env = process.env) {
   const since = parseSince(options.since || "all");
   return importStructuredProvider(
@@ -1514,7 +2130,8 @@ function readExportJson(file) {
   return bundle.entries.map((entry) => entry.data);
 }
 
-function readExportBundle(file) {
+function readExportBundle(file, provider = "") {
+  if (Array.isArray(file)) return readExportBundleList(file, provider);
   const resolved = path.resolve(file);
   let stat;
   try {
@@ -1522,31 +2139,96 @@ function readExportBundle(file) {
   } catch (error) {
     throw exportAccessError(resolved, error);
   }
-  const entries = stat.isDirectory() ? readExportFolder(resolved) : readExportFile(resolved);
+  const bundle = stat.isDirectory()
+    ? readExportFolder(resolved, provider)
+    : { entries: readExportFile(resolved, provider), rawFiles: [resolved] };
+  const entries = bundle.entries;
   if (!entries.length) {
-    throw new Error(`${file} did not contain readable JSON, JSONL, or NDJSON export files. If this is an external path such as Downloads, Desktop, Documents, iCloud Drive, or an attached volume, make sure the terminal app running agentlog has permission to read it, or import the original .zip file.`);
+    throw new Error(`${compactExportPath(file)} did not contain readable JSON, JSONL, NDJSON, or recognized nested export ZIP files. If this is an external path such as Downloads, Desktop, Documents, iCloud Drive, or an attached volume, make sure the terminal app running agentlog has permission to read it, unzip the relevant conversation part ZIPs, or copy the export into a readable folder and rerun.`);
   }
   return {
     root: resolved,
     kind: stat.isDirectory() ? "folder" : path.extname(resolved).toLowerCase() === ".zip" ? "zip" : "json",
     entries,
+    rawFiles: bundle.rawFiles || [],
+    fingerprint: hashId(entries.map((entry) => `${entry.name}:${entry.sha256}`).sort().join("\n"))
+  };
+}
+
+function readExportBundleList(files, provider = "") {
+  const resolved = files.map((file) => path.resolve(file)).filter(Boolean);
+  if (!resolved.length) throw new Error("no export paths provided");
+  const bundles = resolved.map((file) => readExportBundle(file, provider));
+  const entries = [];
+  const rawFiles = [];
+  for (const bundle of bundles) {
+    const prefix = exportBundleMergePrefix(bundle.root, resolved);
+    for (const entry of bundle.entries || []) entries.push(prefixExportEntry(entry, prefix));
+    for (const rawFile of bundle.rawFiles || []) rawFiles.push(prefixExportRawFile(rawFile, prefix));
+  }
+  return {
+    root: resolved.join(path.delimiter),
+    kind: "multi",
+    entries: entries.sort((a, b) => a.name.localeCompare(b.name)),
+    rawFiles: rawFiles.sort((a, b) => a.name.localeCompare(b.name)),
     fingerprint: hashId(entries.map((entry) => `${entry.name}:${entry.sha256}`).sort().join("\n"))
   };
 }
 
-function readExportFolder(root) {
+function exportBundleMergePrefix(root, roots) {
+  if (roots.length <= 1) return "";
+  const base = safeArchiveRelativePath(path.basename(root)) || hashId(root);
+  return `${base}/`;
+}
+
+function prefixExportEntry(entry, prefix) {
+  if (!prefix) return entry;
+  return {
+    ...entry,
+    name: `${prefix}${entry.name}`
+  };
+}
+
+function prefixExportRawFile(rawFile, prefix) {
+  if (!prefix) return rawFile;
+  return {
+    ...rawFile,
+    name: `${prefix}${rawFile.name}`
+  };
+}
+
+function readExportFolder(root, provider = "") {
   const entries = [];
+  const rawFiles = [];
   collectExportFiles(root, (file) => {
-    if (!isExportDataFile(file)) return;
+    const relativeName = path.relative(root, file).split(path.sep).join("/");
+    if (!ignoredExportRawFile(relativeName)) rawFiles.push(exportRawFile(root, file, relativeName));
+    if (nestedExportZipEntryName(relativeName, provider)) {
+      const zipPrefix = `${relativeName.replace(/\.zip$/i, "")}/`;
+      entries.push(...readZipExportEntries(file, provider, {
+        entryPrefix: zipPrefix,
+        sourcePrefix: `${file}#`
+      }));
+      return;
+    }
+    const namedJson = isExportEntryName(file);
+    if (!namedJson && !looksLikeJsonPayload(file)) return;
     let text;
     try {
       text = readExportText(file);
     } catch (error) {
       throw exportAccessError(root, error, file);
     }
-    entries.push(exportEntry(path.relative(root, file).split(path.sep).join("/"), text, file));
+    try {
+      entries.push(exportEntry(relativeName, text, file));
+    } catch (error) {
+      if (namedJson) throw error;
+    }
   });
-  return entries.sort((a, b) => a.name.localeCompare(b.name));
+  return {
+    entries: entries.sort((a, b) => a.name.localeCompare(b.name)),
+    rawFiles: rawFiles.sort((a, b) => a.name.localeCompare(b.name))
+  };
 }
 
 function collectExportFiles(root, visit) {
@@ -1568,26 +2250,88 @@ function collectExportFiles(root, visit) {
 
 function exportAccessError(root, error, target = root) {
   const code = error?.code ? ` (${error.code})` : "";
-  const message = error?.message || String(error || "unknown error");
+  const message = compactExportPath(error?.message || String(error || "unknown error"));
   const hint = "Grant Full Disk Access to Terminal/iTerm or the Node process running agentlog, import the original .zip file, or copy the export into a readable folder and rerun.";
-  const wrapped = new Error(`Cannot read web export path ${target}${code}: ${message}. ${hint}`);
+  const wrapped = new Error(`Cannot read web export path ${compactExportPath(target)}${code}: ${message}. ${hint}`);
   wrapped.code = "AGENTLOG_WEB_EXPORT_ACCESS";
   wrapped.causeCode = error?.code || "";
   return wrapped;
 }
 
-function readExportFile(file) {
+function compactExportPath(value) {
+  let text = String(value || "");
+  const home = os.homedir();
+  if (home) {
+    const escaped = home.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    text = text.replace(new RegExp(escaped, "g"), "~");
+  }
+  return text.replace(/\/Users\/[^/\s'"]+/g, "~");
+}
+
+function readExportFile(file, provider = "") {
   if (path.extname(file).toLowerCase() !== ".zip") {
     return [exportEntry(path.basename(file), readExportText(file), file)];
   }
+  return readZipExportEntries(file, provider);
+}
+
+function readZipExportEntries(file, provider = "", context = {}) {
   const list = spawnSync("unzip", ["-Z1", file], { encoding: "utf8" });
   if (list.status !== 0) throw new Error("reading zip exports requires the `unzip` command");
-  const names = list.stdout.split(/\r?\n/).filter(isExportEntryName);
-  return names.map((name) => {
-    const content = spawnSync("unzip", ["-p", file, name], { encoding: "utf8", maxBuffer: 1024 * 1024 * 200 });
-    if (content.status !== 0) throw new Error(`failed to read ${name} from zip`);
-    return exportEntry(name, content.stdout, `${file}#${name}`);
-  }).sort((a, b) => a.name.localeCompare(b.name));
+  const names = list.stdout.split(/\r?\n/).filter(Boolean);
+  const entryPrefix = context.entryPrefix || "";
+  const sourcePrefix = context.sourcePrefix || `${file}#`;
+  const depth = context.depth || 0;
+  const entries = [];
+  for (const name of names.filter(isExportEntryName)) {
+    const content = readZipEntryText(file, name);
+    entries.push(exportEntry(`${entryPrefix}${name}`, content, `${sourcePrefix}${name}`));
+  }
+  if (depth < 2) {
+    for (const name of names.filter((entry) => nestedExportZipEntryName(entry, provider))) {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "agentlog-nested-export-"));
+      const tempZip = path.join(tempDir, safeArchiveRelativePath(path.basename(name)) || "nested.zip");
+      try {
+        extractZipEntryToFile(file, name, tempZip);
+        const nestedPrefix = `${entryPrefix}${name.replace(/\.zip$/i, "")}/`;
+        entries.push(...readZipExportEntries(tempZip, provider, {
+          entryPrefix: nestedPrefix,
+          sourcePrefix: `${sourcePrefix}${name}#`,
+          depth: depth + 1
+        }));
+      } finally {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      }
+    }
+  }
+  return entries.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function readZipEntryText(file, name) {
+  const content = spawnSync("unzip", ["-p", file, name], { encoding: "utf8", maxBuffer: EXPORT_ZIP_ENTRY_MAX_BUFFER });
+  if (content.status !== 0) throw new Error(`failed to read ${name} from zip`);
+  return content.stdout;
+}
+
+function extractZipEntryToFile(file, name, target) {
+  ensureDir(path.dirname(target));
+  const fd = fs.openSync(target, "w", 0o600);
+  try {
+    const result = spawnSync("unzip", ["-p", file, name], { stdio: ["ignore", fd, "pipe"] });
+    if (result.status !== 0) {
+      const message = result.stderr ? result.stderr.toString("utf8").trim() : "";
+      throw new Error(`failed to extract ${name} from zip${message ? `: ${message}` : ""}`);
+    }
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+function nestedExportZipEntryName(name, provider = "") {
+  const text = String(name || "");
+  if (!/\.zip$/i.test(text) || ignoredExportRawFile(text)) return false;
+  if (provider === "chatgpt") return openAiConversationExportPath(text);
+  return /(^|\/)Conversations__[^/]*\.zip$/i.test(text);
 }
 
 function exportEntry(name, text, sourcePath) {
@@ -1603,6 +2347,16 @@ function exportEntry(name, text, sourcePath) {
   };
 }
 
+function exportRawFile(root, file, name = path.relative(root, file).split(path.sep).join("/")) {
+  const stat = safeStat(file);
+  return {
+    name,
+    sourcePath: file,
+    size: stat?.size || 0,
+    mtime: stat?.mtimeMs ? new Date(stat.mtimeMs).toISOString() : ""
+  };
+}
+
 function readExportText(file) {
   const buffer = fs.readFileSync(file);
   const bytes = file.toLowerCase().endsWith(".gz") ? zlib.gunzipSync(buffer) : buffer;
@@ -1633,11 +2387,6 @@ function parseJsonLines(text, name = "", options = {}) {
   return rows;
 }
 
-function isExportDataFile(file) {
-  if (isExportEntryName(file)) return true;
-  return looksLikeJsonPayload(file);
-}
-
 function isExportEntryName(name) {
   const lower = String(name || "").toLowerCase();
   return /\.(json|jsonl|ndjson)(\.gz)?$/.test(lower);
@@ -1665,6 +2414,12 @@ function looksLikeJsonPayload(file) {
   }
 }
 
+function ignoredExportRawFile(name) {
+  return String(name || "")
+    .split(/[\\/]+/)
+    .some((part) => part === ".DS_Store" || part === "__MACOSX" || part.startsWith("._"));
+}
+
 function normalizeWebConversations(provider, source, account) {
   if (provider === "chatgpt") return { conversations: normalizeChatGptExport(source, account) };
   return { conversations: normalizeClaudeWebExport(source, account) };
@@ -1675,7 +2430,7 @@ function normalizeChatGptExport(source) {
   return entries.flatMap((entry) => chatgptRawConversations(entry.data).map((conversation, index) => {
     const id = firstString(conversation.id, conversation.uuid, conversation.conversation_id) || `chatgpt-${hashId(`${entry.name}:${index}`)}`;
     const title = firstString(conversation.title, conversation.name, conversation.summary) || "ChatGPT conversation";
-    const messages = chatgptMessages(conversation).filter((message) => message.content.trim());
+    const messages = chatgptMessages(conversation).filter(chatgptMessageHasDisplayContent);
     const sorted = sortConversationMessages(messages);
     return {
       id,
@@ -1687,34 +2442,41 @@ function normalizeChatGptExport(source) {
       projectPath: "",
       entryPath: entry.name,
       sourceType: "chatgpt-export",
-      kind: "conversation"
+      kind: "conversation",
+      sessionSummary: chatgptSessionSummary(conversation)
     };
   }));
 }
 
 function chatConversationEntries(source) {
-  const preferred = source.entries.filter((entry) => /(^|\/)conversations\.json$/i.test(entry.name));
-  return preferred.length ? preferred : source.entries.filter((entry) => Array.isArray(entry.data) || Array.isArray(entry.data?.conversations));
+  const preferred = source.entries.filter((entry) => /(^|\/)conversations(?:-\d+)?\.json$/i.test(entry.name));
+  return preferred.length ? preferred : source.entries.filter((entry) => chatgptRawConversations(entry.data).length);
 }
 
 function chatgptRawConversations(data) {
-  if (Array.isArray(data)) return data;
-  if (Array.isArray(data?.conversations)) return data.conversations;
+  if (Array.isArray(data)) return data.filter(chatgptLooksLikeConversation);
+  if (Array.isArray(data?.conversations)) return data.conversations.filter(chatgptLooksLikeConversation);
   if (data?.mapping || Array.isArray(data?.messages)) return [data];
   return [];
 }
 
+function chatgptLooksLikeConversation(value) {
+  return Boolean(value && typeof value === "object" && (value.mapping || Array.isArray(value.messages) || value.conversation_id || value.current_node));
+}
+
 function chatgptMessages(conversation) {
   if (conversation.mapping && typeof conversation.mapping === "object") {
     const nodes = chatgptMainPathNodes(conversation);
     return nodes.map((node) => node && node.message).filter(Boolean).map((message) => {
       const role = normalizeEventRole(message.author?.role) || "unknown";
-      const content = extractChatGptContent(message.content);
+      const content = extractChatGptContent(message);
+      const toolCall = chatgptToolCallFromMessage(message, content);
+      const toolResult = role === "tool" ? chatgptToolResultFromMessage(message, content) : null;
       return {
         role,
-        content,
+        content: toolCall ? "" : content,
         timestamp: toIso(message.create_time || message.update_time),
-        metadata: chatgptMessageMetadata(message, role, content)
+        metadata: chatgptMessageMetadata(message, role, content, { toolCall, toolResult })
       };
     });
   }
@@ -1738,22 +2500,266 @@ function chatgptMainPathNodes(conversation) {
   );
 }
 
-function extractChatGptContent(content) {
-  if (!content) return "";
-  if (Array.isArray(content.parts)) return extractText(content.parts);
-  if (Array.isArray(content.text)) return extractText(content.text);
-  if (typeof content.text === "string") return content.text;
-  return extractText(content);
+function extractChatGptContent(message) {
+  const content = message?.content || {};
+  const parts = [];
+  if (Array.isArray(content.parts)) {
+    for (const part of content.parts) {
+      const text = chatgptContentPartText(part);
+      if (text) parts.push(text);
+    }
+  } else if (Array.isArray(content.text)) {
+    parts.push(extractText(content.text));
+  } else if (typeof content.text === "string") {
+    parts.push(content.text);
+  } else {
+    parts.push(extractText(content));
+  }
+  return parts.filter((part) => String(part || "").trim()).join("\n").trim();
+}
+
+function chatgptContentPartText(part) {
+  if (typeof part === "string") return part;
+  if (!part || typeof part !== "object") return extractText(part);
+  const text = extractText(part);
+  if (text) return text;
+  const contentType = firstString(part.content_type, part.type, "asset");
+  const pointer = firstString(part.asset_pointer, part.assetPointer, part.file_id, part.fileId);
+  if (pointer || /image|file|asset/i.test(contentType)) {
+    return "";
+  }
+  return "";
 }
 
-function chatgptMessageMetadata(message, role, content) {
+function chatgptMessageMetadata(message, role, content, options = {}) {
+  const assetPointers = chatgptAssetPointers(message);
+  const attachments = chatgptNormalizedAttachments(message);
   return webWithUsage({
     source: "chatgpt-export",
     messageId: message.id || undefined,
-    model: firstString(message.metadata?.model_slug, message.metadata?.model, message.metadata?.default_model_slug) || undefined
+    model: firstString(message.metadata?.model_slug, message.metadata?.model, message.metadata?.default_model_slug) || undefined,
+    contentType: firstString(message.content?.content_type) || undefined,
+    channel: firstString(message.channel) || undefined,
+    recipient: firstString(message.recipient) || undefined,
+    status: firstString(message.status) || undefined,
+    attachments: chatgptAttachAssetPointers(attachments, assetPointers),
+    assetPointers,
+    toolCalls: options.toolCall ? [options.toolCall] : undefined,
+    toolResult: options.toolResult || undefined
   }, webMessageUsage(message, role, { inputText: content, outputText: content }));
 }
 
+function chatgptSessionSummary(conversation) {
+  const summary = firstString(conversation.summary);
+  if (!summary) return undefined;
+  return {
+    summary,
+    source: "chatgpt-export",
+    summaryKind: "conversation_summary"
+  };
+}
+
+function chatgptMessageHasDisplayContent(message) {
+  if (!message || typeof message !== "object") return false;
+  if (String(message.content || "").trim()) return true;
+  const metadata = message.metadata || {};
+  return Boolean(
+      (Array.isArray(metadata.attachments) && metadata.attachments.length) ||
+      (Array.isArray(metadata.assetPointers) && metadata.assetPointers.length) ||
+      (Array.isArray(metadata.toolCalls) && metadata.toolCalls.length) ||
+      metadata.toolResult
+  );
+}
+
+function chatgptToolCallFromMessage(message, content) {
+  const recipient = firstString(message?.recipient);
+  if (!recipient || recipient === "all" || recipient === "assistant") return null;
+  const rawInput = String(content || "").trim();
+  if (!rawInput) return null;
+  const args = parseToolArgsValue(rawInput);
+  const name = chatgptToolName(recipient, args);
+  const summary = summarizeToolArguments(args) || rawInput.slice(0, 240);
+  return compactObject({
+    provider: "chatgpt",
+    name,
+    displayName: toolDisplayName(name),
+    category: chatgptToolCategory(recipient, name),
+    rawCategory: "chatgpt_tool_call",
+    title: toolDisplayName(name),
+    status: "tool_call",
+    argument: summary,
+    rawInputSummary: summary,
+    inputPreview: chatgptToolInputPreview(args, rawInput),
+    arguments: args && typeof args === "object" && !Array.isArray(args) ? args : undefined
+  });
+}
+
+function chatgptToolName(recipient, args) {
+  const base = String(recipient || "tool").trim();
+  if (base === "web.run" && args && typeof args === "object" && !Array.isArray(args)) {
+    if (args.search_query || args.searchQuery) return "web.search";
+    if (args.open) return "web.open";
+    if (args.image_query || args.imageQuery) return "web.image_search";
+    if (args.finance) return "web.finance";
+    if (args.weather) return "web.weather";
+    if (args.sports) return "web.sports";
+    if (args.time) return "web.time";
+  }
+  return base || "tool";
+}
+
+function chatgptToolCategory(recipient, name) {
+  const text = `${recipient || ""} ${name || ""}`.toLowerCase();
+  if (text.includes("web.")) return "web";
+  return "";
+}
+
+function chatgptToolInputPreview(args, rawInput) {
+  if (!args || typeof args !== "object") return rawInput.slice(0, 2000);
+  try {
+    return JSON.stringify(args, null, 2).slice(0, 2000);
+  } catch {
+    return rawInput.slice(0, 2000);
+  }
+}
+
+function chatgptToolResultFromMessage(message, content) {
+  const text = String(content || "").trim();
+  if (!text) return null;
+  const parsedFile = chatgptParsedFileToolResult(text);
+  if (parsedFile) return parsedFile;
+  if (/^All the files uploaded by the user have been fully loaded\./i.test(text)) {
+    return compactObject({
+      provider: "chatgpt",
+      kind: "Uploaded files loaded",
+      title: "Uploaded files loaded",
+      category: "read",
+      categoryLabel: "Files",
+      rawCategory: "chatgpt_file_tool",
+      summary: firstLine(text),
+      output: text,
+      lineCount: text.split("\n").length,
+      collapsed: false,
+      status: "completed"
+    });
+  }
+  return null;
+}
+
+function chatgptParsedFileToolResult(text) {
+  if (!/<PARSED TEXT FOR PAGE:\s*\d+\s*\/\s*\d+>/i.test(text)) return null;
+  const pageMatches = [...text.matchAll(/<PARSED TEXT FOR PAGE:\s*(\d+)\s*\/\s*(\d+)>/gi)];
+  const pageCount = pageMatches.reduce((max, match) => Math.max(max, Number(match[2]) || 0), 0);
+  const citationMatch = text.match(/\uE200filecite\uE202([^\uE201]+)\uE201/i);
+  const citation = citationMatch ? chatgptCitationText(citationMatch[1]) : "";
+  const detail = [citation, pageCount ? `${pageCount} page${pageCount === 1 ? "" : "s"}` : ""].filter(Boolean).join(" · ");
+  return compactObject({
+    provider: "chatgpt",
+    kind: "Parsed uploaded file",
+    title: "Parsed uploaded file",
+    category: "read",
+    categoryLabel: "Files",
+    rawCategory: "chatgpt_file_tool",
+    summary: detail ? `Parsed uploaded file text · ${detail}` : "Parsed uploaded file text",
+    output: text,
+    lineCount: text.split("\n").length,
+    collapsed: true,
+    status: "completed"
+  });
+}
+
+function chatgptCitationText(value) {
+  return String(value || "").split("\uE202").map((part) => part.trim()).filter(Boolean).join(" ");
+}
+
+function chatgptNormalizedAttachments(message) {
+  const attachments = Array.isArray(message?.metadata?.attachments) ? message.metadata.attachments : [];
+  const normalized = attachments.map((attachment) => {
+    if (!attachment || typeof attachment !== "object") return null;
+    return compactObject({
+      id: firstString(attachment.id, attachment.file_id, attachment.fileId),
+      name: firstString(attachment.name, attachment.filename, attachment.file_name),
+      mimeType: firstString(attachment.mime_type, attachment.mimeType),
+      size: finiteNumber(attachment.size, attachment.size_bytes, attachment.sizeBytes),
+      width: finiteNumber(attachment.width),
+      height: finiteNumber(attachment.height),
+      source: firstString(attachment.source),
+      libraryFileId: firstString(attachment.library_file_id, attachment.libraryFileId)
+    });
+  }).filter((attachment) => attachment && Object.keys(attachment).length);
+  return normalized.length ? normalized : undefined;
+}
+
+function chatgptAssetPointers(message) {
+  const parts = Array.isArray(message?.content?.parts) ? message.content.parts : [];
+  const pointers = parts
+    .filter((part) => part && typeof part === "object" && (part.asset_pointer || part.assetPointer))
+    .map((part) => compactObject({
+      assetPointer: firstString(part.asset_pointer, part.assetPointer),
+      contentType: firstString(part.content_type, part.type),
+      mimeType: firstString(part.mime_type, part.mimeType),
+      width: finiteNumber(part.width),
+      height: finiteNumber(part.height),
+      size: finiteNumber(part.size_bytes, part.sizeBytes)
+    }))
+    .filter((pointer) => Object.keys(pointer).length);
+  return pointers.length ? pointers : undefined;
+}
+
+function chatgptAttachAssetPointers(attachments, assetPointers) {
+  if (!Array.isArray(attachments) || !attachments.length) return undefined;
+  if (!Array.isArray(assetPointers) || !assetPointers.length) return attachments;
+  return attachments.map((attachment, index) => {
+    const pointer = chatgptAssetPointerForAttachment(attachment, assetPointers, index, attachments.length);
+    if (!pointer) return attachment;
+    return compactObject({
+      ...attachment,
+      assetPointer: pointer.assetPointer,
+      pointerContentType: pointer.contentType,
+      pointerMimeType: pointer.mimeType
+    });
+  });
+}
+
+function chatgptAssetPointerForAttachment(attachment, assetPointers, index, attachmentCount) {
+  const id = normalizeAttachmentToken(attachment?.id || "");
+  if (id) {
+    const match = assetPointers.find((pointer) => normalizeAttachmentToken(pointer.assetPointer || "").endsWith(id));
+    if (match) return match;
+  }
+  if (attachmentCount === assetPointers.length) return assetPointers[index] || null;
+  if (attachmentCount === 1 && assetPointers.length === 1) return assetPointers[0];
+  return null;
+}
+
+function normalizeAttachmentToken(value) {
+  return String(value || "")
+    .trim()
+    .toLowerCase()
+    .replace(/^file-service:\/\//, "")
+    .replace(/^sandbox:\/\//, "")
+    .replace(/^attachment:\/\//, "")
+    .replace(/[?#].*$/, "")
+    .split(/[\\/]+/)
+    .filter(Boolean)
+    .pop() || "";
+}
+
+function compactObject(input) {
+  const output = {};
+  for (const [key, value] of Object.entries(input || {})) {
+    if (value === undefined || value === null || value === "") continue;
+    if (Array.isArray(value) && !value.length) continue;
+    output[key] = value;
+  }
+  return output;
+}
+
+function finiteNumber(...values) {
+  const value = numericValue(...values);
+  return Number.isFinite(value) ? value : undefined;
+}
+
 function webWithUsage(metadata, usage) {
   if (!usage) return metadata;
   return { ...metadata, usage };
@@ -2345,12 +3351,19 @@ function webConversationSourcePath(source, conversation) {
 }
 
 function inferWebSourceAccountId(provider, source) {
+  const accountMetadataName = provider === "chatgpt"
+    ? /(user|account|profile)/
+    : /(user|account|profile|organization|export|memories)/;
   for (const entry of source.entries) {
     const name = entry.name.toLowerCase();
-    if (!/(user|account|profile|organization|export|memories)/.test(name)) continue;
+    if (!accountMetadataName.test(name) || /(^|\/)conversations(?:-\d+)?\.json$/i.test(name)) continue;
     const id = webAccountIdFromData(entry.data);
     if (id) return id;
   }
+  if (provider === "chatgpt") {
+    const id = openAiConversationExportAccountId(source);
+    if (id) return id;
+  }
   if (provider === "claude_web") {
     const match = path.basename(source.root).match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i);
     if (match) return match[0].toLowerCase();
@@ -2358,6 +3371,19 @@ function inferWebSourceAccountId(provider, source) {
   return "";
 }
 
+function openAiConversationExportAccountId(source) {
+  const values = [
+    source.root,
+    ...(Array.isArray(source.entries) ? source.entries.map((entry) => entry.name) : []),
+    ...(Array.isArray(source.rawFiles) ? source.rawFiles.map((file) => file.name) : [])
+  ];
+  for (const value of values) {
+    const match = String(value || "").match(/Conversations__([A-Za-z0-9]+)-chatgpt-\d+/i);
+    if (match) return match[1];
+  }
+  return "";
+}
+
 function inferWebUsername(provider, source) {
   for (const entry of source.entries) {
     const name = entry.name.toLowerCase();
@@ -2402,10 +3428,15 @@ function providerLabelForWeb(provider) {
   return provider === "chatgpt" ? "ChatGPT" : "Claude.ai";
 }
 
-function ensureSharedWebExportRaw(provider, source, account, env = process.env) {
+function ensureSharedWebExportRaw(provider, source, account, env = process.env, options = {}) {
   const root = path.join(archiveRoot(env), "raw", "web-exports", provider, account.accountId, source.fingerprint);
   const manifestPath = path.join(root, "manifest.json");
   if (fs.existsSync(manifestPath)) {
+    reportWebImportProgress(options, provider, {
+      current: 1,
+      total: 1,
+      message: "raw export already preserved"
+    });
     return { root, manifestPath, sha256: source.fingerprint };
   }
   ensureDir(root);
@@ -2413,6 +3444,11 @@ function ensureSharedWebExportRaw(provider, source, account, env = process.env)
   const records = [];
   let containerPath = "";
   if (source.kind === "zip" || source.kind === "json") {
+    reportWebImportProgress(options, provider, {
+      current: 0,
+      total: 1,
+      message: "preserving raw export"
+    });
     const extension = source.kind === "zip" ? ".zip" : path.extname(source.root) || ".json";
     containerPath = path.join(root, `source${extension}`);
     fs.copyFileSync(source.root, containerPath);
@@ -2423,22 +3459,55 @@ function ensureSharedWebExportRaw(provider, source, account, env = process.env)
       size: stat?.size || 0,
       sha256: fileSha256(containerPath)
     });
+    reportWebImportProgress(options, provider, {
+      current: 1,
+      total: 1,
+      message: "preserved raw export"
+    });
   }
-  for (const entry of source.entries) {
-    let archivedPath = containerPath;
-    if (source.kind === "folder" && fs.existsSync(entry.sourcePath)) {
-      archivedPath = path.join(root, "entries", safeArchiveRelativePath(entry.name));
+  const rawFiles = webExportRawFilesForProvider(source, provider);
+  const entryBySourcePath = new Map(source.entries.map((entry) => [path.resolve(entry.sourcePath), entry]));
+  const copiedRaw = new Set();
+  if (source.kind === "folder" || source.kind === "multi") {
+    let rawIndex = 0;
+    for (const rawFile of rawFiles) {
+      rawIndex++;
+      if (!rawFile?.sourcePath || !fs.existsSync(rawFile.sourcePath)) continue;
+      const resolved = path.resolve(rawFile.sourcePath);
+      if (copiedRaw.has(resolved)) continue;
+      copiedRaw.add(resolved);
+      const archivedPath = path.join(root, "entries", safeArchiveRelativePath(rawFile.name));
       ensureDir(path.dirname(archivedPath));
-      fs.copyFileSync(entry.sourcePath, archivedPath);
+      fs.copyFileSync(rawFile.sourcePath, archivedPath);
+      const stat = safeStat(archivedPath);
+      const parsedEntry = entryBySourcePath.get(resolved);
+      records.push({
+        entryPath: rawFile.name,
+        originalPath: rawFile.sourcePath,
+        archivedPath,
+        size: stat?.size || rawFile.size || 0,
+        mtime: rawFile.mtime || (stat?.mtimeMs ? new Date(stat.mtimeMs).toISOString() : undefined),
+        sha256: parsedEntry?.sha256 || fileSha256(archivedPath),
+        parsed: Boolean(parsedEntry) || undefined
+      });
+      reportWebImportProgress(options, provider, {
+        current: rawIndex,
+        total: rawFiles.length,
+        message: `preserving raw export files: ${rawIndex}/${rawFiles.length}`
+      });
+    }
+  } else {
+    for (const entry of source.entries) {
+      records.push({
+        entryPath: entry.name,
+        originalPath: entry.sourcePath,
+        archivedPath: containerPath,
+        containerPath: containerPath || undefined,
+        size: entry.size,
+        sha256: entry.sha256,
+        parsed: true
+      });
     }
-    records.push({
-      entryPath: entry.name,
-      originalPath: entry.sourcePath,
-      archivedPath,
-      containerPath: containerPath || undefined,
-      size: entry.size,
-      sha256: entry.sha256
-    });
   }
   writeJson(manifestPath, {
     version: 1,
@@ -2454,6 +3523,20 @@ function ensureSharedWebExportRaw(provider, source, account, env = process.env)
   return { root, manifestPath, sha256: source.fingerprint };
 }
 
+function webExportRawFilesForProvider(source, provider) {
+  const rawFiles = Array.isArray(source.rawFiles) ? source.rawFiles : [];
+  if (!rawFiles.length) return [];
+  if (provider !== "chatgpt") return rawFiles;
+  const hasOpenAiConversationParts = rawFiles.some((file) => openAiConversationExportPath(file.name));
+  if (!hasOpenAiConversationParts) return rawFiles;
+  return rawFiles.filter((file) => openAiConversationExportPath(file.name));
+}
+
+function openAiConversationExportPath(name) {
+  const text = String(name || "");
+  return /(^|\/)Conversations__[^/]*chatgpt[^/]*(?:\/|$)/i.test(text) || /(^|\/)Conversations__[^/]*chatgpt[^/]*\.zip$/i.test(text);
+}
+
 function webRawReference(sharedRaw, conversation) {
   return {
     filename: "web-export-reference",
@@ -2487,6 +3570,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 +3697,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 +3713,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() {
@@ -2724,90 +3822,534 @@ function summarizeCursor(env = process.env, options = {}) {
       errors++;
     }
   }
-  const transcriptSessions = readCursorProjectTranscriptSessions({ env });
-  const rawCompanionMerge = mergeCursorRawCompanionSessions(sessions.concat(transcriptSessions), { withStats: true });
-  sessions = dedupeCursorSessions(rawCompanionMerge.sessions);
-  const oldest = sessions.length ? sessions.map((session) => session.startedAt).sort()[0]?.slice(0, 10) || "" : "";
-  return {
-    sessions: sessions.length,
-    oldest,
-    details: {
-      workspaceDbs: dbs.length,
-      globalDbs: globalDbs.length,
-      projectTranscripts: transcriptSessions.length,
-      rawCompanionFragmentsMerged: rawCompanionMerge.merged,
-      rawCompanionFragmentsDropped: rawCompanionMerge.dropped,
-      unreadable: errors
-    },
-    note: "Cursor workspace/global SQLite, raw SQLite salvage, plus ~/.cursor/projects agent transcripts"
-  };
+  const transcriptSessions = readCursorProjectTranscriptSessions({ env });
+  const rawCompanionMerge = mergeCursorRawCompanionSessions(sessions.concat(transcriptSessions), { withStats: true });
+  sessions = dedupeCursorSessions(rawCompanionMerge.sessions);
+  const oldest = sessions.length ? sessions.map((session) => session.startedAt).sort()[0]?.slice(0, 10) || "" : "";
+  return {
+    sessions: sessions.length,
+    oldest,
+    details: {
+      workspaceDbs: dbs.length,
+      globalDbs: globalDbs.length,
+      projectTranscripts: transcriptSessions.length,
+      rawCompanionFragmentsMerged: rawCompanionMerge.merged,
+      rawCompanionFragmentsDropped: rawCompanionMerge.dropped,
+      unreadable: errors
+    },
+    note: "Cursor workspace/global SQLite, raw SQLite salvage, plus ~/.cursor/projects agent transcripts"
+  };
+}
+
+function summarizeDevin(env = process.env, options = {}) {
+  const sessions = readDevinSessions(env, options);
+  const oldest = sessions.length ? sessions.map((session) => session.startedAt).sort()[0]?.slice(0, 10) || "" : "";
+  const db = devinSessionsDb(env);
+  return {
+    sessions: sessions.length,
+    oldest,
+    details: { database: fs.existsSync(db) ? 1 : 0, messages: sessions.reduce((sum, session) => sum + session.messages.length, 0) },
+    note: "Devin for Terminal SQLite sessions.db"
+  };
+}
+
+function summarizeStructuredSessions(sessions, note = "") {
+  const importable = sessions.filter((session) => session.messages.length);
+  const oldest = importable.length ? importable.map((session) => session.startedAt).sort()[0]?.slice(0, 10) || "" : "";
+  return {
+    sessions: importable.length,
+    oldest,
+    details: summarizeStructuredSessionDetails(sessions),
+    note
+  };
+}
+
+function summarizeStructuredSessionDetails(sessions) {
+  return sessions.reduce((acc, session) => {
+    if (session.detailKey) acc[session.detailKey] = (acc[session.detailKey] || 0) + 1;
+    if (session.artifactCount) acc.artifacts = (acc.artifacts || 0) + session.artifactCount;
+    if (session.binaryCount) acc.binaryOnly = (acc.binaryOnly || 0) + session.binaryCount;
+    if (session.partialSummary) acc.partialSummaries = (acc.partialSummaries || 0) + 1;
+    if (session.stateDbCount) acc.stateDbs = (acc.stateDbs || 0) + session.stateDbCount;
+    return acc;
+  }, {});
+}
+
+function codexRoots(env = process.env) {
+  const home = codexHome(env);
+  return [path.join(home, "sessions"), path.join(home, "archived_sessions")];
+}
+
+function claudeRoots(env = process.env) {
+  const home = env && env.HOME ? env.HOME : os.homedir();
+  return [path.join(home, ".claude", "projects")];
+}
+
+function claudeFileHistoryRoot(env = process.env) {
+  const home = env && env.HOME ? env.HOME : os.homedir();
+  return path.join(home, ".claude", "file-history");
+}
+
+function claudeFileHistoryFiles(sessionId, env = process.env) {
+  if (!sessionId) return [];
+  const dir = path.join(claudeFileHistoryRoot(env), String(sessionId));
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT" || error.code === "ENOTDIR" || error.code === "EACCES") return [];
+    throw error;
+  }
+  const files = [];
+  for (const entry of entries) {
+    if (entry.isFile()) files.push(path.join(dir, entry.name));
+  }
+  files.sort((a, b) => a.localeCompare(b));
+  return files;
+}
+
+function claudeSubagentImportContext(cwd, env = process.env, cache = null) {
+  const key = `${claudeSubagentUserRoot(env)}\0${path.resolve(String(cwd || ""))}`;
+  if (cache?.has(key)) return cache.get(key);
+  const definitions = readClaudeSubagentDefinitions(cwd, env);
+  const effective = effectiveClaudeSubagentDefinitions(definitions);
+  const sourceFiles = definitions.map((definition) => definition.sourcePath).filter(Boolean);
+  const projectCount = effective.filter((definition) => definition.scope === "project").length;
+  const userCount = effective.filter((definition) => definition.scope === "user").length;
+  const names = effective.map((definition) => definition.name).sort((a, b) => a.localeCompare(b));
+  const shadowedNames = shadowedClaudeSubagentNames(definitions);
+  const sessionSummary = effective.length
+    ? {
+        claudeSubagents: compactMetadata({
+          count: effective.length,
+          parsedCount: definitions.length !== effective.length ? definitions.length : undefined,
+          projectCount: projectCount || undefined,
+          userCount: userCount || undefined,
+          shadowedNames: shadowedNames.length ? shadowedNames : undefined,
+          names,
+          definitions: effective.map(claudeSubagentDefinitionSummary)
+        })
+      }
+    : null;
+  const result = { sessionSummary, sourceFiles };
+  if (cache) cache.set(key, result);
+  return result;
+}
+
+function readClaudeSubagentDefinitions(cwd, env = process.env) {
+  return claudeSubagentDefinitionFiles(cwd, env)
+    .map((entry) => parseClaudeSubagentDefinitionFile(entry.file, entry))
+    .filter(Boolean)
+    .sort((a, b) => {
+      const scope = subagentScopePriority(a.scope) - subagentScopePriority(b.scope);
+      return scope || a.name.localeCompare(b.name) || a.sourcePath.localeCompare(b.sourcePath);
+    });
+}
+
+function claudeSubagentDefinitionFiles(cwd, env = process.env) {
+  const roots = [];
+  const userRoot = claudeSubagentUserRoot(env);
+  if (safeStat(userRoot)?.isDirectory()) roots.push({ root: userRoot, scope: "user" });
+  const projectRoot = findClaudeProjectSubagentRoot(cwd);
+  if (projectRoot && path.resolve(projectRoot) !== path.resolve(userRoot)) {
+    roots.push({ root: projectRoot, scope: "project" });
+  }
+  const seen = new Set();
+  const files = [];
+  for (const root of roots) {
+    collectFiles(root.root, (file) => {
+      if (!/\.md$/i.test(file)) return;
+      const resolved = path.resolve(file);
+      if (seen.has(resolved)) return;
+      seen.add(resolved);
+      files.push({ ...root, file: resolved });
+    });
+  }
+  return files.sort((a, b) => {
+    const scope = subagentScopePriority(a.scope) - subagentScopePriority(b.scope);
+    return scope || a.file.localeCompare(b.file);
+  });
+}
+
+function parseClaudeSubagentDefinitionFile(file, context = {}) {
+  let text;
+  try {
+    text = fs.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+  const document = splitMarkdownFrontmatter(text);
+  if (!document.frontmatter) return null;
+  const metadata = parseSimpleYamlFrontmatter(document.frontmatter);
+  const name = firstString(metadata.name, path.basename(file, path.extname(file)));
+  if (!name) return null;
+  const sourceRoot = context.root || path.dirname(file);
+  const body = String(document.body || "").trim();
+  const stat = safeStat(file);
+  return compactMetadata({
+    name,
+    description: firstString(metadata.description),
+    tools: normalizeClaudeSubagentTools(metadata.tools),
+    model: firstString(metadata.model),
+    scope: context.scope || "unknown",
+    sourcePath: path.resolve(file),
+    relativePath: relativePathWithin(sourceRoot, file),
+    frontmatterKeys: Object.keys(metadata).sort((a, b) => a.localeCompare(b)),
+    instructionPreview: previewString(body, 600),
+    instructionLineCount: body ? body.split(/\r?\n/).length : undefined,
+    mtime: stat?.mtimeMs ? new Date(stat.mtimeMs).toISOString() : undefined
+  });
+}
+
+function effectiveClaudeSubagentDefinitions(definitions) {
+  const byName = new Map();
+  for (const definition of definitions) {
+    const key = definition.name.toLowerCase();
+    const existing = byName.get(key);
+    if (!existing || subagentScopePriority(definition.scope) >= subagentScopePriority(existing.scope)) {
+      byName.set(key, definition);
+    }
+  }
+  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function shadowedClaudeSubagentNames(definitions) {
+  const seen = new Map();
+  const shadowed = new Set();
+  for (const definition of definitions) {
+    const key = definition.name.toLowerCase();
+    if (seen.has(key)) shadowed.add(definition.name);
+    seen.set(key, definition);
+  }
+  return [...shadowed].sort((a, b) => a.localeCompare(b));
+}
+
+function claudeSubagentDefinitionSummary(definition) {
+  return compactMetadata({
+    name: definition.name,
+    description: definition.description,
+    tools: definition.tools,
+    model: definition.model,
+    scope: definition.scope,
+    sourcePath: definition.sourcePath,
+    relativePath: definition.relativePath,
+    instructionPreview: definition.instructionPreview,
+    instructionLineCount: definition.instructionLineCount
+  });
+}
+
+function claudeSubagentRunImportContext(parentSessionId, conversationFile, env = process.env, sourceFiles = null) {
+  const files = Array.isArray(sourceFiles)
+    ? sourceFiles
+    : claudeSubagentRunSourceFilesForSession(parentSessionId, conversationFile, env);
+  const transcriptFiles = files.filter((file) => /\.jsonl$/i.test(file));
+  const sourceRoot = conversationFile ? path.dirname(conversationFile) : "";
+  const sessions = [];
+  const runs = [];
+  for (const file of transcriptFiles) {
+    const parsed = parseClaudeSubagentRunFile(file, parentSessionId, sourceRoot);
+    if (!parsed) continue;
+    sessions.push(parsed.session);
+    runs.push(parsed.summary);
+  }
+  const sourceFileList = [...new Set(files)].sort((a, b) => a.localeCompare(b));
+  return {
+    sourceFiles: sourceFileList,
+    sessions,
+    sessionSummary: runs.length
+      ? {
+          claudeSubagentRuns: compactMetadata({
+            count: runs.length,
+            agentIds: [...new Set(runs.map((run) => run.agentId).filter(Boolean))].sort((a, b) => a.localeCompare(b)),
+            agentTypes: [...new Set(runs.map((run) => run.agentType).filter(Boolean))].sort((a, b) => a.localeCompare(b)),
+            messageCount: runs.reduce((sum, run) => sum + (run.messageCount || 0), 0),
+            userMessageCount: runs.reduce((sum, run) => sum + (run.userMessageCount || 0), 0),
+            assistantMessageCount: runs.reduce((sum, run) => sum + (run.assistantMessageCount || 0), 0),
+            toolCallCount: runs.reduce((sum, run) => sum + (run.toolCallCount || 0), 0),
+            toolResultCount: runs.reduce((sum, run) => sum + (run.toolResultCount || 0), 0),
+            runs
+          })
+        }
+      : null
+  };
+}
+
+function parseClaudeSubagentRunFile(file, parentSessionId, sourceRoot = "") {
+  let parsed;
+  try {
+    parsed = parseAgentJsonl(file, "claude_code");
+  } catch {
+    return null;
+  }
+  if (!parsed.messages.length) return null;
+  const meta = readClaudeSubagentRunMeta(file);
+  const agentId = claudeSubagentRunAgentId(parsed, file);
+  const agentType = firstString(meta?.agentType, meta?.type, meta?.name);
+  const models = sessionMessageModels(parsed.messages);
+  const usage = computeSessionUsage(parsed.messages);
+  const promptPreview = previewString(firstClaudeSubagentUserPrompt(parsed.messages), 360);
+  const resultPreview = previewString(lastClaudeSubagentAssistantText(parsed.messages), 360);
+  const toolCallCount = parsed.messages.reduce((sum, message) => sum + (Array.isArray(message.metadata?.toolCalls) ? message.metadata.toolCalls.length : 0), 0);
+  const toolResultCount = parsed.messages.reduce((sum, message) => sum + (message.metadata?.toolResult ? 1 : 0), 0);
+  const sourceFiles = claudeSubagentRunSourceFilesForTranscript(file);
+  const sessionId = `claude-subagent-${hashId(`${parentSessionId}:${agentId}:${file}`)}`;
+  const title = claudeSubagentRunTitle(agentType, parsed.title, promptPreview, agentId);
+  const relativePath = relativePathWithin(sourceRoot || path.dirname(file), file);
+  const summary = compactMetadata({
+    sessionId,
+    parentSessionId,
+    agentId,
+    agentType,
+    title,
+    startedAt: parsed.startedAt,
+    endedAt: parsed.endedAt,
+    messageCount: parsed.messages.length,
+    userMessageCount: parsed.messages.filter((message) => message.role === "user").length,
+    assistantMessageCount: parsed.messages.filter((message) => message.role === "assistant").length,
+    toolCallCount,
+    toolResultCount,
+    models,
+    usage,
+    promptPreview,
+    resultPreview,
+    sourcePath: file,
+    relativePath
+  });
+  return {
+    summary,
+    session: {
+      provider: "claude_code",
+      sessionId,
+      cwd: parsed.cwd,
+      messages: parsed.messages,
+      startedAt: parsed.startedAt,
+      endedAt: parsed.endedAt,
+      sourcePath: file,
+      sourceFiles,
+      title,
+      conversationKind: "claude_subagent",
+      parentComposerId: parentSessionId,
+      sessionSummary: mergeSessionSummaries(parsed.sessionSummary, {
+        claudeSubagentRun: compactMetadata({
+          parentSessionId,
+          agentId,
+          agentType,
+          title,
+          promptPreview,
+          resultPreview,
+          sourcePath: file,
+          relativePath
+        })
+      })
+    }
+  };
+}
+
+function claudeSubagentRunSourceFilesForSession(parentSessionId, conversationFile, env = process.env) {
+  const files = [];
+  for (const dir of claudeSubagentRunDirs(parentSessionId, conversationFile, env)) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch (error) {
+      if (error.code === "ENOENT" || error.code === "ENOTDIR" || error.code === "EACCES") continue;
+      throw error;
+    }
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      if (!/\.jsonl$/i.test(entry.name) && !/\.meta\.json$/i.test(entry.name)) continue;
+      files.push(path.join(dir, entry.name));
+    }
+  }
+  return [...new Set(files)].sort((a, b) => a.localeCompare(b));
 }
 
-function summarizeDevin(env = process.env, options = {}) {
-  const sessions = readDevinSessions(env, options);
-  const oldest = sessions.length ? sessions.map((session) => session.startedAt).sort()[0]?.slice(0, 10) || "" : "";
-  const db = devinSessionsDb(env);
-  return {
-    sessions: sessions.length,
-    oldest,
-    details: { database: fs.existsSync(db) ? 1 : 0, messages: sessions.reduce((sum, session) => sum + session.messages.length, 0) },
-    note: "Devin for Terminal SQLite sessions.db"
-  };
+function claudeSubagentRunDirs(parentSessionId, conversationFile, env = process.env) {
+  if (!parentSessionId || !conversationFile) return [];
+  const dirs = [
+    path.join(path.dirname(conversationFile), String(parentSessionId), "subagents"),
+    path.join(path.dirname(conversationFile), "subagents")
+  ];
+  const root = claudeRoots(env)[0];
+  const directParent = path.join(root, path.basename(path.dirname(conversationFile)), String(parentSessionId), "subagents");
+  dirs.push(directParent);
+  const seen = new Set();
+  return dirs.filter((dir) => {
+    const resolved = path.resolve(dir);
+    if (seen.has(resolved)) return false;
+    seen.add(resolved);
+    return safeStat(resolved)?.isDirectory();
+  });
 }
 
-function summarizeStructuredSessions(sessions, note = "") {
-  const importable = sessions.filter((session) => session.messages.length);
-  const oldest = importable.length ? importable.map((session) => session.startedAt).sort()[0]?.slice(0, 10) || "" : "";
-  return {
-    sessions: importable.length,
-    oldest,
-    details: summarizeStructuredSessionDetails(sessions),
-    note
-  };
+function claudeSubagentRunSourceFilesForTranscript(file) {
+  const files = [file];
+  const meta = claudeSubagentRunMetaFile(file);
+  if (safeStat(meta)?.isFile()) files.push(meta);
+  return files;
 }
 
-function summarizeStructuredSessionDetails(sessions) {
-  return sessions.reduce((acc, session) => {
-    if (session.detailKey) acc[session.detailKey] = (acc[session.detailKey] || 0) + 1;
-    if (session.artifactCount) acc.artifacts = (acc.artifacts || 0) + session.artifactCount;
-    if (session.binaryCount) acc.binaryOnly = (acc.binaryOnly || 0) + session.binaryCount;
-    if (session.partialSummary) acc.partialSummaries = (acc.partialSummaries || 0) + 1;
-    if (session.stateDbCount) acc.stateDbs = (acc.stateDbs || 0) + session.stateDbCount;
-    return acc;
-  }, {});
+function claudeSubagentRunMetaFile(file) {
+  return String(file || "").replace(/\.jsonl$/i, ".meta.json");
 }
 
-function codexRoots(env = process.env) {
-  const home = codexHome(env);
-  return [path.join(home, "sessions"), path.join(home, "archived_sessions")];
+function readClaudeSubagentRunMeta(file) {
+  const metaFile = claudeSubagentRunMetaFile(file);
+  try {
+    return readJson(metaFile, null);
+  } catch {
+    return null;
+  }
 }
 
-function claudeRoots(env = process.env) {
-  const home = env && env.HOME ? env.HOME : os.homedir();
-  return [path.join(home, ".claude", "projects")];
+function claudeSubagentRunAgentId(parsed, file) {
+  const agentIds = parsed?.sessionSummary?.claudeJsonl?.agentIds;
+  if (Array.isArray(agentIds) && agentIds.length) return agentIds[0];
+  if (typeof agentIds === "string" && agentIds.trim()) return agentIds.trim();
+  return path.basename(String(file || ""), path.extname(String(file || ""))).replace(/^agent-/, "");
 }
 
-function claudeFileHistoryRoot(env = process.env) {
+function claudeSubagentRunTitle(agentType, parsedTitle, promptPreview, agentId) {
+  const promptTitle = titleFromPrompt(promptPreview) || titleFromPrompt(parsedTitle) || firstString(parsedTitle);
+  const prefix = firstString(agentType);
+  const title = prefix && promptTitle ? `${prefix}: ${promptTitle}` : firstString(promptTitle, prefix, agentId, "Claude subagent");
+  return titleFromPrompt(title) || title;
+}
+
+function firstClaudeSubagentUserPrompt(messages) {
+  return (messages || []).find((message) => message.role === "user" && String(message.content || "").trim())?.content || "";
+}
+
+function lastClaudeSubagentAssistantText(messages) {
+  return [...(messages || [])].reverse().find((message) => message.role === "assistant" && String(message.content || "").trim())?.content || "";
+}
+
+function sessionMessageModels(messages) {
+  return [...new Set((messages || []).map((message) => message.metadata?.model).filter((model) => typeof model === "string" && model.trim()).map((model) => model.trim()))]
+    .sort((a, b) => a.localeCompare(b));
+}
+
+function claudeSubagentUserRoot(env = process.env) {
   const home = env && env.HOME ? env.HOME : os.homedir();
-  return path.join(home, ".claude", "file-history");
+  return path.join(home, ".claude", "agents");
 }
 
-function claudeFileHistoryFiles(sessionId, env = process.env) {
-  if (!sessionId) return [];
-  const dir = path.join(claudeFileHistoryRoot(env), String(sessionId));
-  let entries;
-  try {
-    entries = fs.readdirSync(dir, { withFileTypes: true });
-  } catch (error) {
-    if (error.code === "ENOENT" || error.code === "ENOTDIR" || error.code === "EACCES") return [];
-    throw error;
+function findClaudeProjectSubagentRoot(cwd) {
+  if (!cwd) return "";
+  let dir = path.resolve(cwd);
+  if (!safeStat(dir)?.isDirectory()) return "";
+  for (;;) {
+    const candidate = path.join(dir, ".claude", "agents");
+    if (safeStat(candidate)?.isDirectory()) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir || fs.existsSync(path.join(dir, ".git"))) return "";
+    dir = parent;
   }
-  const files = [];
-  for (const entry of entries) {
-    if (entry.isFile()) files.push(path.join(dir, entry.name));
+}
+
+function subagentScopePriority(scope) {
+  if (scope === "project") return 2;
+  if (scope === "user") return 1;
+  return 0;
+}
+
+function splitMarkdownFrontmatter(text) {
+  const normalized = String(text || "").replace(/^\uFEFF/, "");
+  const match = normalized.match(/^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)([\s\S]*)$/);
+  if (!match) return { frontmatter: "", body: normalized };
+  return { frontmatter: match[1], body: match[2] || "" };
+}
+
+function parseSimpleYamlFrontmatter(text) {
+  const lines = String(text || "").split(/\r?\n/);
+  const result = {};
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index];
+    if (!line.trim() || /^\s*#/.test(line)) continue;
+    const match = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (!match) continue;
+    const key = match[1];
+    const raw = match[2] || "";
+    if (/^[>|]/.test(raw.trim())) {
+      const block = [];
+      while (index + 1 < lines.length && (/^(?:\s+|$)/.test(lines[index + 1]))) {
+        index++;
+        block.push(lines[index].replace(/^\s{2}/, ""));
+      }
+      result[key] = raw.trim().startsWith(">") ? block.join(" ").replace(/\s+/g, " ").trim() : block.join("\n").trim();
+    } else if (!raw.trim()) {
+      const values = [];
+      while (index + 1 < lines.length) {
+        const item = lines[index + 1].match(/^\s*-\s*(.*)$/);
+        if (!item) break;
+        index++;
+        values.push(parseYamlScalar(item[1]));
+      }
+      result[key] = values.length ? values : "";
+    } else {
+      result[key] = parseYamlScalar(raw);
+    }
   }
-  files.sort((a, b) => a.localeCompare(b));
-  return files;
+  return result;
+}
+
+function parseYamlScalar(value) {
+  const text = stripYamlComment(String(value || "").trim());
+  if (!text) return "";
+  if (text.startsWith("[") && text.endsWith("]")) {
+    return text
+      .slice(1, -1)
+      .split(",")
+      .map((item) => stripYamlString(item.trim()))
+      .filter(Boolean);
+  }
+  return stripYamlString(text);
+}
+
+function stripYamlComment(value) {
+  let quote = "";
+  for (let index = 0; index < value.length; index++) {
+    const char = value[index];
+    if ((char === '"' || char === "'") && value[index - 1] !== "\\") {
+      quote = quote === char ? "" : quote || char;
+    }
+    if (char === "#" && !quote && (index === 0 || /\s/.test(value[index - 1]))) {
+      return value.slice(0, index).trimEnd();
+    }
+  }
+  return value;
+}
+
+function stripYamlString(value) {
+  const text = String(value || "").trim();
+  if ((text.startsWith('"') && text.endsWith('"')) || (text.startsWith("'") && text.endsWith("'"))) {
+    return text.slice(1, -1);
+  }
+  return text;
+}
+
+function normalizeClaudeSubagentTools(value) {
+  const values = Array.isArray(value)
+    ? value
+    : typeof value === "string"
+      ? value.split(",")
+      : [];
+  return values
+    .map((item) => String(item || "").trim())
+    .filter(Boolean)
+    .filter((item) => !/^none$/i.test(item))
+    .sort((a, b) => a.localeCompare(b));
+}
+
+function relativePathWithin(root, file) {
+  const relative = path.relative(root || path.dirname(file), file);
+  return relative && !relative.startsWith("..") && !path.isAbsolute(relative) ? relative : path.basename(file);
+}
+
+function previewString(value, max = 600) {
+  const text = String(value || "").replace(/\s+/g, " ").trim();
+  if (!text) return "";
+  return text.length > max ? `${text.slice(0, max - 3).trimEnd()}...` : text;
 }
 
 function jsonlFiles(roots) {
@@ -2888,11 +4430,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 +4444,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) {
@@ -2936,59 +4485,196 @@ function readInitialLines(file, maxLines, maxBytes = 1024 * 1024) {
 function readCodexThreads(env = process.env) {
   const db = codexStateDb(env);
   if (!fs.existsSync(db)) return [];
+  const sessionIndex = readCodexSessionIndex(env);
+  const threadColumns = sqliteTableColumns(db, "threads");
   const hasStage1Outputs = sqliteTableExists(db, "stage1_outputs");
-  const query = hasStage1Outputs
-    ? [
-        "select t.id, t.rollout_path, t.created_at, t.updated_at, t.source, t.cwd, t.title,",
-        "s.raw_memory, s.rollout_summary, s.generated_at as summary_generated_at,",
-        "s.source_updated_at as summary_source_updated_at, s.rollout_slug",
-        "from threads t",
-        "left join stage1_outputs s on s.thread_id = t.id",
-        "where t.rollout_path != ''",
-        "order by t.updated_at desc"
-      ].join(" ")
-    : [
-        "select id, rollout_path, created_at, updated_at, source, cwd, title",
-        "from threads",
-        "where rollout_path != ''",
-        "order by updated_at desc"
-      ].join(" ");
+  const hasSpawnEdges = sqliteTableExists(db, "thread_spawn_edges");
+  const select = [
+    "t.id",
+    "t.rollout_path",
+    "t.created_at",
+    "t.updated_at",
+    "t.source",
+    "t.cwd",
+    "t.title",
+    sqliteSelectMaybe(threadColumns, "t", "created_at_ms"),
+    sqliteSelectMaybe(threadColumns, "t", "updated_at_ms"),
+    sqliteSelectMaybe(threadColumns, "t", "agent_nickname"),
+    sqliteSelectMaybe(threadColumns, "t", "agent_role"),
+    sqliteSelectMaybe(threadColumns, "t", "agent_path"),
+    sqliteSelectMaybe(threadColumns, "t", "thread_source"),
+    sqliteSelectMaybe(threadColumns, "t", "tokens_used"),
+    sqliteSelectMaybe(threadColumns, "t", "model"),
+    sqliteSelectMaybe(threadColumns, "t", "model_provider", "model_provider"),
+    hasStage1Outputs ? "s.raw_memory" : "null as raw_memory",
+    hasStage1Outputs ? "s.rollout_summary" : "null as rollout_summary",
+    hasStage1Outputs ? "s.generated_at as summary_generated_at" : "null as summary_generated_at",
+    hasStage1Outputs ? "s.source_updated_at as summary_source_updated_at" : "null as summary_source_updated_at",
+    hasStage1Outputs ? "s.rollout_slug" : "null as rollout_slug",
+    hasSpawnEdges ? "e.parent_thread_id as spawn_parent_thread_id" : "null as spawn_parent_thread_id",
+    hasSpawnEdges ? "e.status as spawn_status" : "null as spawn_status"
+  ];
+  const joins = [
+    hasStage1Outputs ? "left join stage1_outputs s on s.thread_id = t.id" : "",
+    hasSpawnEdges ? "left join thread_spawn_edges e on e.child_thread_id = t.id" : ""
+  ].filter(Boolean).join(" ");
+  const query = [
+    `select ${select.join(", ")}`,
+    "from threads t",
+    joins,
+    "where t.rollout_path != ''",
+    "order by t.updated_at desc"
+  ].filter(Boolean).join(" ");
   const result = spawnSync("sqlite3", [db, "-json", query], { argv0: "agentlog-sqlite", encoding: "utf8", maxBuffer: 1024 * 1024 * 50 });
   if (result.status !== 0 || !result.stdout.trim()) return [];
   try {
-    return JSON.parse(result.stdout).map((row) => ({
-      id: row.id,
-      rolloutPath: row.rollout_path,
-      createdAt: toIso(row.created_at),
-      updatedAt: toIso(row.updated_at),
-      source: row.source,
-      cwd: row.cwd,
-      title: row.title,
-      rawMemory: row.raw_memory || "",
-      rolloutSummary: row.rollout_summary || "",
-      summaryGeneratedAt: toIso(row.summary_generated_at),
-      summarySourceUpdatedAt: toIso(row.summary_source_updated_at),
-      rolloutSlug: row.rollout_slug || ""
-    }));
+    const rows = JSON.parse(result.stdout).map((row) => {
+      const sourceInfo = codexThreadSourceInfo(row.source);
+      return {
+        id: row.id,
+        rolloutPath: row.rollout_path,
+        createdAt: toIso(row.created_at_ms || row.created_at),
+        updatedAt: toIso(row.updated_at_ms || row.updated_at),
+        source: row.source,
+        rawSource: row.source,
+        threadSource: row.thread_source || "",
+        tokensUsed: numberValue(row.tokens_used),
+        model: firstString(row.model),
+        modelProvider: firstString(row.model_provider),
+        cwd: row.cwd,
+        stateTitle: row.title,
+        rawMemory: row.raw_memory || "",
+        rolloutSummary: row.rollout_summary || "",
+        summaryGeneratedAt: toIso(row.summary_generated_at),
+        summarySourceUpdatedAt: toIso(row.summary_source_updated_at),
+        rolloutSlug: row.rollout_slug || "",
+        parentThreadId: firstString(row.spawn_parent_thread_id, sourceInfo.parentThreadId),
+        spawnStatus: firstString(row.spawn_status, sourceInfo.status),
+        agentNickname: firstString(row.agent_nickname, sourceInfo.agentNickname),
+        agentRole: firstString(row.agent_role, sourceInfo.agentRole),
+        agentPath: firstString(row.agent_path, sourceInfo.agentPath),
+        subagentDepth: numberValue(sourceInfo.depth),
+        isCodexSubagent: Boolean(row.spawn_parent_thread_id || sourceInfo.isSubagent || row.agent_nickname || row.agent_role || row.agent_path)
+      };
+    });
+    return resolveCodexThreadSources(rows).map((thread) => applyCodexSessionIndexTitle({ ...thread, title: thread.stateTitle || "" }, sessionIndex));
   } catch {
     return [];
   }
 }
 
+function resolveCodexThreadSources(threads) {
+  const byId = new Map((threads || []).map((thread) => [thread.id, thread]));
+  const resolved = new Map();
+  const sourceForThread = (thread, seen = new Set()) => {
+    if (!thread) return "cli";
+    const cached = resolved.get(thread.id);
+    if (cached) return cached;
+    const direct = codexSourceKind(thread.rawSource || thread.source) || codexSourceKind(thread.threadSource);
+    if (direct) {
+      resolved.set(thread.id, direct);
+      return direct;
+    }
+    if (thread.parentThreadId && !seen.has(thread.id)) {
+      seen.add(thread.id);
+      const parentSource = sourceForThread(byId.get(thread.parentThreadId), seen);
+      resolved.set(thread.id, parentSource);
+      return parentSource;
+    }
+    resolved.set(thread.id, "cli");
+    return "cli";
+  };
+  return (threads || []).map((thread) => ({
+    ...thread,
+    source: sourceForThread(thread),
+    isCodexSubagent: Boolean(thread.isCodexSubagent || thread.parentThreadId)
+  }));
+}
+
+function codexSourceKind(value) {
+  const text = String(value || "").trim();
+  return ["cli", "vscode", "exec"].includes(text) ? text : "";
+}
+
+function codexThreadSourceInfo(value) {
+  let parsed = null;
+  try {
+    parsed = typeof value === "string" && value.trim().startsWith("{") ? JSON.parse(value) : null;
+  } catch {
+    parsed = null;
+  }
+  const spawn = parsed?.subagent?.thread_spawn || parsed?.thread_spawn || null;
+  if (!spawn || typeof spawn !== "object") return {};
+  return {
+    isSubagent: true,
+    parentThreadId: firstString(spawn.parent_thread_id, spawn.parentThreadId, spawn.parent_id, spawn.parentId),
+    agentNickname: firstString(spawn.agent_nickname, spawn.agentNickname, spawn.nickname),
+    agentRole: firstString(spawn.agent_role, spawn.agentRole, spawn.role),
+    agentPath: firstString(spawn.agent_path, spawn.agentPath, spawn.path),
+    status: firstString(spawn.status),
+    depth: spawn.depth
+  };
+}
+
+function applyCodexSessionIndexTitle(thread, sessionIndex) {
+  if (!thread) return thread;
+  const indexedTitle = sessionIndex.get(thread.id);
+  if (!indexedTitle?.title) return thread;
+  return {
+    ...thread,
+    title: indexedTitle.title,
+    titleSource: "session-index",
+    sessionIndexPath: indexedTitle.path,
+    sessionIndexUpdatedAt: indexedTitle.updatedAt,
+    sessionIndexTitle: indexedTitle.title
+  };
+}
+
+function readCodexSessionIndex(env = process.env) {
+  const file = codexSessionIndexPath(env);
+  if (!fs.existsSync(file)) return new Map();
+  const byId = new Map();
+  let lines = [];
+  try {
+    lines = fs.readFileSync(file, "utf8").split(/\r?\n/);
+  } catch {
+    return byId;
+  }
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const id = firstString(entry.id, entry.thread_id, entry.threadId, entry.session_id, entry.sessionId);
+    const title = titleFromPrompt(firstString(entry.thread_name, entry.threadName, entry.title, entry.name));
+    if (!id || !title) continue;
+    const updatedAt = toIso(entry.updated_at || entry.updatedAt || entry.time || entry.timestamp);
+    const previous = byId.get(id);
+    if (!previous || String(updatedAt || "").localeCompare(String(previous.updatedAt || "")) >= 0) {
+      byId.set(id, { title, updatedAt, path: file });
+    }
+  }
+  return byId;
+}
+
 function readCodexSessionEntries(env = process.env) {
+  const sessionIndex = readCodexSessionIndex(env);
   const indexed = readCodexThreads(env).map((thread) => ({ ...thread, indexed: true }));
   const seen = new Set(indexed.map((thread) => normalizeSourcePath(thread.rolloutPath)));
   const discovered = [];
   for (const file of codexRolloutFiles(env)) {
     const key = normalizeSourcePath(file);
     if (seen.has(key)) continue;
-    const thread = codexRolloutFileThread(file);
+    const thread = applyCodexSessionIndexTitle(codexRolloutFileThread(file), sessionIndex);
     if (thread) {
       discovered.push(thread);
       seen.add(key);
     }
   }
-  return indexed.concat(discovered).sort((a, b) => String(b.updatedAt || "").localeCompare(String(a.updatedAt || "")));
+  return indexed.concat(discovered).sort((a, b) => String(codexThreadImportUpdatedAt(b)).localeCompare(String(codexThreadImportUpdatedAt(a))));
 }
 
 function codexRolloutFiles(env = process.env) {
@@ -3060,18 +4746,174 @@ function readCodexRolloutInfo(file) {
       info.cwd ||= firstString(payload.cwd, event.cwd);
     }
     info.cwd ||= firstString(event.cwd, payload.cwd);
-    info.title ||= firstUserTextFromCodexEvent(event).replace(/\s+/g, " ").slice(0, 100);
-    if (info.id && info.cwd && info.title && lastTimestamp) break;
+    const threadTitle = codexThreadNameFromEvent(event);
+    if (threadTitle) {
+      info.title = threadTitle;
+      info.titleSource = "thread-name";
+    } else if (!info.title) {
+      const promptTitle = titleFromPrompt(firstUserTextFromCodexEvent(event));
+      if (promptTitle) {
+        info.title = promptTitle;
+        info.titleSource = "prompt";
+      }
+    }
+    if (info.id && info.cwd && info.title && lastTimestamp && info.titleSource === "thread-name") break;
   }
   if (lastTimestamp) info.updatedAt = lastTimestamp;
   return info;
 }
 
+function codexSessionTitleForImport(thread, parsed) {
+  const indexedTitle = firstString(thread?.sessionIndexTitle);
+  if (indexedTitle) return indexedTitle;
+  const parsedTitle = firstString(parsed?.title);
+  if (parsedTitle && (parsed?.titleSource === "thread-name" || codexPromptLikeThreadTitle(thread?.title))) return parsedTitle;
+  return firstString(thread?.title, parsedTitle);
+}
+
+function codexSubagentRunImportContext(parentThread, childThreads = [], env = process.env) {
+  if (!parentThread?.id || !Array.isArray(childThreads) || !childThreads.length) return null;
+  const runs = [];
+  for (const childThread of childThreads) {
+    const parsed = parseCodexSubagentThread(childThread);
+    const summary = codexSubagentRunSummary(parentThread, childThread, parsed, env);
+    if (summary) runs.push(summary);
+  }
+  runs.sort((a, b) => {
+    const time = String(a.startedAt || a.endedAt || "").localeCompare(String(b.startedAt || b.endedAt || ""));
+    return time || String(a.sessionId || "").localeCompare(String(b.sessionId || ""));
+  });
+  if (!runs.length) return null;
+  return {
+    sessionSummary: {
+      codexSubagentRuns: compactMetadata({
+        count: runs.length,
+        agentIds: [...new Set(runs.map((run) => run.agentId).filter(Boolean))].sort((a, b) => a.localeCompare(b)),
+        agentNicknames: [...new Set(runs.map((run) => run.agentNickname).filter(Boolean))].sort((a, b) => a.localeCompare(b)),
+        agentRoles: [...new Set(runs.map((run) => run.agentRole).filter(Boolean))].sort((a, b) => a.localeCompare(b)),
+        statuses: [...new Set(runs.map((run) => run.status).filter(Boolean))].sort((a, b) => a.localeCompare(b)),
+        messageCount: runs.reduce((sum, run) => sum + (run.messageCount || 0), 0),
+        userMessageCount: runs.reduce((sum, run) => sum + (run.userMessageCount || 0), 0),
+        assistantMessageCount: runs.reduce((sum, run) => sum + (run.assistantMessageCount || 0), 0),
+        toolCallCount: runs.reduce((sum, run) => sum + (run.toolCallCount || 0), 0),
+        toolResultCount: runs.reduce((sum, run) => sum + (run.toolResultCount || 0), 0),
+        runs
+      })
+    }
+  };
+}
+
+function codexSubagentSessionSummary(thread, parsed, env = process.env) {
+  if (!thread?.isCodexSubagent && !thread?.parentThreadId) return null;
+  const summary = codexSubagentRunSummary(null, thread, parsed, env);
+  return summary ? { sessionSummary: { codexSubagentRun: summary } } : null;
+}
+
+function parseCodexSubagentThread(thread) {
+  if (!thread?.rolloutPath) return null;
+  try {
+    return finalizeCodexParsedThread(thread, parseAgentJsonl(thread.rolloutPath, "codex"));
+  } catch {
+    return null;
+  }
+}
+
+function codexSubagentRunSummary(parentThread, childThread, parsed, env = process.env) {
+  if (!childThread?.id && !parsed?.sessionId) return null;
+  const messages = Array.isArray(parsed?.messages) ? parsed.messages : [];
+  const sessionId = parsed?.sessionId || childThread.id;
+  const parentSessionId = firstString(parentThread?.id, childThread.parentThreadId);
+  const promptPreview = previewString(firstCodexSubagentUserPrompt(messages) || childThread.title, 360);
+  const resultPreview = previewString(lastCodexSubagentAssistantText(messages), 360);
+  const toolCallCount = messages.reduce((sum, message) => sum + (Array.isArray(message.metadata?.toolCalls) ? message.metadata.toolCalls.length : 0), 0);
+  const toolResultCount = messages.reduce((sum, message) => sum + (message.metadata?.toolResult ? 1 : 0), 0);
+  const usage = messages.length ? computeSessionUsage(messages) : null;
+  const sourceRoot = codexHome(env);
+  return compactMetadata({
+    sessionId,
+    parentSessionId,
+    agentId: childThread.id || sessionId,
+    agentNickname: childThread.agentNickname,
+    agentRole: childThread.agentRole,
+    agentType: childThread.agentRole,
+    agentPath: childThread.agentPath,
+    status: childThread.spawnStatus,
+    depth: childThread.subagentDepth,
+    provider: "codex",
+    providerLabel: "Codex",
+    title: codexSubagentRunTitle(childThread, parsed?.title, promptPreview),
+    startedAt: parsed?.startedAt || childThread.createdAt,
+    endedAt: parsed?.endedAt || childThread.updatedAt,
+    messageCount: messages.length || undefined,
+    userMessageCount: messages.filter((message) => message.role === "user").length || undefined,
+    assistantMessageCount: messages.filter((message) => message.role === "assistant").length || undefined,
+    toolCallCount: toolCallCount || undefined,
+    toolResultCount: toolResultCount || undefined,
+    models: sessionMessageModels(messages),
+    usage,
+    promptPreview,
+    resultPreview,
+    sourcePath: childThread.rolloutPath,
+    relativePath: childThread.rolloutPath ? relativePathWithin(sourceRoot, childThread.rolloutPath) : ""
+  });
+}
+
+function codexSubagentRunTitle(thread, parsedTitle, promptPreview) {
+  const prefix = firstString(thread?.agentNickname, thread?.agentRole);
+  const promptTitle = titleFromPrompt(firstString(parsedTitle, thread?.title, promptPreview));
+  if (prefix && promptTitle) return `${prefix}: ${promptTitle}`;
+  return firstString(promptTitle, prefix, thread?.id, "Codex subagent");
+}
+
+function firstCodexSubagentUserPrompt(messages) {
+  return (messages || []).find((message) => message.role === "user" && String(message.content || "").trim())?.content || "";
+}
+
+function lastCodexSubagentAssistantText(messages) {
+  return [...(messages || [])].reverse().find((message) => message.role === "assistant" && String(message.content || "").trim())?.content || "";
+}
+
+function codexThreadImportUpdatedAt(thread, childThreads = []) {
+  return latestIso(thread?.updatedAt, thread?.sessionIndexUpdatedAt, thread?.createdAt, ...(childThreads || []).map((child) => codexThreadImportUpdatedAt(child)));
+}
+
+function latestIso(...values) {
+  let latest = 0;
+  for (const value of values) {
+    const iso = toIso(value);
+    if (!iso) continue;
+    const time = new Date(iso).getTime();
+    if (Number.isFinite(time) && time > latest) latest = time;
+  }
+  return latest ? new Date(latest).toISOString() : "";
+}
+
+function codexPromptLikeThreadTitle(value) {
+  const text = String(value || "").trim();
+  return text.length > 160 || /^# Files mentioned by the user:/m.test(text) || /\[\$[^\]\n]+\]\([^)]+SKILL\.md\)/i.test(text);
+}
+
+function codexThreadNameFromEvent(event) {
+  const item = event?.payload || event?.item || event?.data || event;
+  const type = String(item?.type || event?.type || item?.kind || "").toLowerCase();
+  if (!["thread_name_updated", "thread_title_updated", "conversation_title_updated"].includes(type)) return "";
+  return titleFromPrompt(firstString(item.thread_name, item.threadName, item.title, item.name));
+}
+
 function firstUserTextFromCodexEvent(event) {
   const payload = event.payload || event;
-  if (payload.type === "message" && payload.role === "user") return extractText(payload.content);
-  if (payload.type === "user_message") return firstString(payload.message, payload.text, extractText(payload.content));
-  return "";
+  let content = "";
+  if (payload.type === "message" && payload.role === "user") content = extractText(payload.content);
+  else if (payload.type === "user_message") content = firstString(payload.message, payload.text, extractText(payload.content));
+  if (!content) return "";
+  const classification = providerGeneratedContext(content, "codex", event);
+  if (!classification) return content;
+  return classification.kind === "attachment_context" ? codexAttachmentRequestText(content) : "";
+}
+
+function codexAttachmentRequestText(value) {
+  const match = String(value || "").match(/(?:^|\n)## My request for Codex:\s*\n([\s\S]*)$/i);
+  return match ? match[1].trim() : "";
 }
 
 function codexTimestampFromFilename(file) {
@@ -3125,12 +4967,20 @@ function codexStateDb(env = process.env) {
   return env.CODEX_STATE_DB || path.join(codexHome(env), "state_5.sqlite");
 }
 
+function codexSessionIndexPath(env = process.env) {
+  return env.CODEX_SESSION_INDEX || path.join(codexHome(env), "session_index.jsonl");
+}
+
 function codexHome(env = process.env) {
   return env.CODEX_HOME || path.join(os.homedir(), ".codex");
 }
 
-function codexSourceFiles(thread, env = process.env) {
-  return [thread.rolloutPath, thread.indexed ? codexStateDb(env) : ""].filter(Boolean);
+function codexSourceFiles(thread, env = process.env, childThreads = []) {
+  const files = [thread.rolloutPath, thread.indexed ? codexStateDb(env) : "", thread.sessionIndexPath || ""].filter(Boolean);
+  for (const child of childThreads || []) {
+    files.push(...codexSourceFiles(child, env));
+  }
+  return [...new Set(files)].sort((a, b) => a.localeCompare(b));
 }
 
 function codexSupplementaryMessages(thread, fallbackTimestamp = "") {
@@ -3163,19 +5013,59 @@ function codexSupplementFingerprint(thread) {
     thread.rolloutSummary || "",
     thread.summaryGeneratedAt || "",
     thread.summarySourceUpdatedAt || "",
-    thread.rolloutSlug || ""
+    thread.rolloutSlug || "",
+    thread.sessionIndexTitle || "",
+    thread.sessionIndexUpdatedAt || ""
   ].join("\0");
   if (!payload.replace(/\0/g, "")) return "summaries:none";
   const hash = crypto.createHash("sha256").update(payload).digest("hex").slice(0, 24);
   return `summaries:${hash}`;
 }
 
+function codexThreadMetadataFingerprint(thread) {
+  const payload = [
+    thread?.rawSource || "",
+    thread?.threadSource || "",
+    thread?.parentThreadId || "",
+    thread?.spawnStatus || "",
+    thread?.agentNickname || "",
+    thread?.agentRole || "",
+    thread?.agentPath || "",
+    thread?.subagentDepth || "",
+    thread?.tokensUsed || ""
+  ].join("\0");
+  if (!payload.replace(/\0/g, "")) return "";
+  const hash = crypto.createHash("sha256").update(payload).digest("hex").slice(0, 24);
+  return `thread-meta:${hash}`;
+}
+
+function codexSubagentRunsFingerprint(childThreads = []) {
+  const payload = (childThreads || [])
+    .map((thread) => [
+      thread.id || "",
+      thread.rolloutPath || "",
+      thread.parentThreadId || "",
+      thread.spawnStatus || "",
+      thread.agentNickname || "",
+      thread.agentRole || "",
+      thread.agentPath || "",
+      thread.tokensUsed || "",
+      thread.rolloutPath ? fileFingerprint(thread.rolloutPath, safeStat(thread.rolloutPath)) : ""
+    ].join("\t"))
+    .join("\n");
+  if (!payload) return "";
+  const hash = crypto.createHash("sha256").update(payload).digest("hex").slice(0, 24);
+  return `codex-subagent-runs:${hash}`;
+}
+
 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 } : {}) };
+  const subagents = threads.filter((thread) => thread.isCodexSubagent).length;
+  return { cli, desktop, ...(exec ? { exec } : {}), ...(subagents ? { subagents } : {}), ...(archived ? { archived } : {}), ...(summaries ? { summaries } : {}) };
 }
 
 function readClaudeDesktopSessions(options = {}, env = process.env) {
@@ -6967,10 +8857,10 @@ function readOpenCodeSqliteSessionsFromDb(dbPath, options = {}, env = process.en
   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"]);
+  const classifications = openCodeSqliteSessionClassifications(sessionRows, dbPath, env, options, messageRows);
   const messagesBySession = groupRowsBy(messageRows, "session_id");
   const partsByMessage = groupRowsBy(partRows, "message_id");
   const storageRoot = path.join(path.dirname(dbPath), "storage");
@@ -7061,9 +8951,10 @@ function readOpenCodeSqliteSessionRows(dbPath, options = {}) {
   return readSqliteJson(dbPath, queryParts.join(" "), "OpenCode SQLite sessions");
 }
 
-function openCodeSqliteSessionClassifications(sessionRows, dbPath, env = process.env, options = {}) {
+function openCodeSqliteSessionClassifications(sessionRows, dbPath, env = process.env, options = {}, messageRows = []) {
   const baseSourceType = openCodeSqliteSourceType(dbPath, env, options);
   const rowsById = new Map((sessionRows || []).map((row) => [String(row.id || ""), row]).filter(([id]) => id));
+  const messagesBySession = groupRowsBy(messageRows, "session_id");
   const desktopHints = openCodeDesktopSessionHints(env);
   const sourceTypes = new Map();
   const hintFiles = new Map();
@@ -7088,7 +8979,7 @@ function openCodeSqliteSessionClassifications(sessionRows, dbPath, env = process
         return parentSourceType;
       }
     }
-    const sourceType = openCodeSqliteRowSourceType(row, dbPath, env, options, baseSourceType);
+    const sourceType = openCodeSqliteRowSourceType(row, dbPath, env, options, baseSourceType, messagesBySession.get(id) || []);
     sourceTypes.set(id, sourceType);
     return sourceType;
   };
@@ -7096,10 +8987,10 @@ function openCodeSqliteSessionClassifications(sessionRows, dbPath, env = process
   return { sourceTypes, hintFiles };
 }
 
-function openCodeSqliteRowSourceType(row, dbPath, env = process.env, options = {}, baseSourceType = openCodeSqliteSourceType(dbPath, env, options)) {
+function openCodeSqliteRowSourceType(row, dbPath, env = process.env, options = {}, baseSourceType = openCodeSqliteSourceType(dbPath, env, options), messageRows = []) {
   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 (openCodeSqliteRowHasCliMetadata(row) || openCodeSqliteMessagesHaveCliMetadata(messageRows)) return "opencode-cli-sqlite-history";
   if (openCodeSqliteRowLooksWeb(row, dbPath, env)) return "opencode-web-sqlite-history";
   return baseSourceType;
 }
@@ -7108,6 +8999,13 @@ function openCodeSqliteRowHasCliMetadata(row) {
   return Boolean(firstString(row?.agent, row?.model));
 }
 
+function openCodeSqliteMessagesHaveCliMetadata(rows = []) {
+  return rows.some((row) => {
+    const data = parseJsonObject(row?.data);
+    return Boolean(firstString(data.agent, data.mode, data.path?.cwd, data.path?.root));
+  });
+}
+
 function openCodeSqliteRowLooksWeb(row, dbPath, env = process.env) {
   const version = firstString(row?.version);
   if (!version || version === "local") return false;
@@ -7171,7 +9069,7 @@ function readOpenCodeSqliteMessageRows(dbPath, sessionIds = []) {
     "session_id",
     sqliteSelectMaybe(columns, "message", "time_created"),
     sqliteSelectMaybe(columns, "message", "time_updated"),
-    sqliteSelectMaybe(columns, "message", "data")
+    openCodeSqliteMessageDataSelect(dbPath, columns)
   ];
   return readOpenCodeSqliteRowsForSessionIds(
     dbPath,
@@ -7182,6 +9080,20 @@ function readOpenCodeSqliteMessageRows(dbPath, sessionIds = []) {
   );
 }
 
+function openCodeSqliteMessageDataSelect(dbPath, columns) {
+  if (!columns.has("data")) return "null as data";
+  if (!sqliteJsonFunctionsAvailable(dbPath)) return "message.data";
+  return "case when json_valid(message.data) then json_remove(message.data, '$.summary') else message.data end as data";
+}
+
+function sqliteJsonFunctionsAvailable(dbPath) {
+  try {
+    return readSqliteJson(dbPath, "select json_valid('{\"ok\":true}') as ok", "SQLite JSON function check")[0]?.ok === 1;
+  } catch {
+    return false;
+  }
+}
+
 function readOpenCodeSqlitePartRows(dbPath, sessionIds = []) {
   const columns = sqliteTableColumns(dbPath, "part");
   if (!columns.has("id") || !columns.has("message_id") || !columns.has("session_id")) return [];
@@ -9136,6 +11048,22 @@ function fileFingerprint(file, stat = safeStat(file)) {
   return `${file}:${stat?.size || 0}:${Math.floor(stat?.mtimeMs || 0)}`;
 }
 
+function filesFingerprint(files) {
+  return (files || [])
+    .map((file) => fileFingerprint(file, safeStat(file)))
+    .sort((a, b) => a.localeCompare(b))
+    .join("|");
+}
+
+function latestFileMtimeMs(files, primaryStat = null) {
+  let latest = primaryStat?.mtimeMs || 0;
+  for (const file of files || []) {
+    const stat = safeStat(file);
+    if (stat?.mtimeMs && stat.mtimeMs > latest) latest = stat.mtimeMs;
+  }
+  return latest;
+}
+
 function fileSha256(file) {
   return crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex");
 }
@@ -9259,6 +11187,7 @@ module.exports = {
   importWebChat,
   normalizeEventRole,
   parseClaudeDesktopSessionFile,
+  parseClaudeSubagentDefinitionFile,
   parseAgentJsonl,
   parseJsonlHistoryFile,
   parseSince,
@@ -9273,6 +11202,7 @@ module.exports = {
   readAiderSessions,
   readAntigravitySessions,
   readClineSessions,
+  readClaudeSubagentDefinitions,
   readDevinSessionsFromDb,
   readGeminiCliSessions,
   readOpenCodeSessions,