agentel 0.2.6 → 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");
@@ -23,6 +23,7 @@ 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;
 
@@ -81,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 = {
@@ -100,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;
@@ -130,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);
@@ -156,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: mergeSessionSummaries(claudeCodeSidecarSessionSummary(sessionMetadata), parsed.sessionSummary)
+          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);
   }
 
@@ -187,6 +240,46 @@ function codexThreadSourceType(thread) {
   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);
@@ -268,6 +361,7 @@ function importCodexProvider(provider, since, options = {}, env = process.env) {
     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: {} };
   }
@@ -277,7 +371,7 @@ function importCodexProvider(provider, since, options = {}, env = process.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,
@@ -299,7 +393,13 @@ function importCodexProvider(provider, since, options = {}, env = process.env) {
       continue;
     }
     const sourceType = codexThreadSourceType(thread);
-    const fingerprint = `${fingerprintPrefix(sourceType)}:${fileFingerprint(thread.rolloutPath, stat)}:${codexSupplementFingerprint(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);
@@ -313,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++;
@@ -338,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(
         {
@@ -350,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
       );
@@ -616,7 +718,11 @@ function parseAgentJsonl(file, provider) {
       event.payload?.session_id,
       event.sessionId
     );
-    if (!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) {
@@ -953,18 +1059,48 @@ 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";
 }
@@ -1230,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;
 }
@@ -1260,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;
@@ -1764,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;
@@ -1782,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 = {
@@ -1797,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);
@@ -1855,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(
@@ -1880,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 {
@@ -1888,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) {
@@ -1934,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) {
@@ -1969,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;
@@ -1999,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);
@@ -2031,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) };
@@ -2041,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,
@@ -2053,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 })
       };
     });
   }
@@ -2104,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 };
@@ -2711,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();
@@ -2724,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();
@@ -2768,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);
@@ -2779,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);
@@ -2789,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,
@@ -2820,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",
@@ -3191,6 +3908,450 @@ function claudeFileHistoryFiles(sessionId, env = process.env) {
   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 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 claudeSubagentRunSourceFilesForTranscript(file) {
+  const files = [file];
+  const meta = claudeSubagentRunMetaFile(file);
+  if (safeStat(meta)?.isFile()) files.push(meta);
+  return files;
+}
+
+function claudeSubagentRunMetaFile(file) {
+  return String(file || "").replace(/\.jsonl$/i, ".meta.json");
+}
+
+function readClaudeSubagentRunMeta(file) {
+  const metaFile = claudeSubagentRunMetaFile(file);
+  try {
+    return readJson(metaFile, null);
+  } catch {
+    return null;
+  }
+}
+
+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 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", "agents");
+}
+
+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;
+  }
+}
+
+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);
+    }
+  }
+  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) {
   const files = [];
   for (const root of roots) {
@@ -3324,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) {
@@ -3448,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) {
@@ -3513,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 = "") {
@@ -3551,20 +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, ...(exec ? { exec } : {}), ...(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) {
@@ -7356,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");
@@ -7450,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();
@@ -7477,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;
   };
@@ -7485,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;
 }
@@ -7497,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;
@@ -7560,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,
@@ -7571,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 [];
@@ -9525,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");
 }
@@ -9648,6 +11187,7 @@ module.exports = {
   importWebChat,
   normalizeEventRole,
   parseClaudeDesktopSessionFile,
+  parseClaudeSubagentDefinitionFile,
   parseAgentJsonl,
   parseJsonlHistoryFile,
   parseSince,
@@ -9662,6 +11202,7 @@ module.exports = {
   readAiderSessions,
   readAntigravitySessions,
   readClineSessions,
+  readClaudeSubagentDefinitions,
   readDevinSessionsFromDb,
   readGeminiCliSessions,
   readOpenCodeSessions,