agentel 0.2.5 → 0.2.8

package/src/cli.js

@@ -9,7 +9,7 @@ const readline = require("readline");
 const { spawnSync } = require("child_process");
 const { pathToFileURL } = require("url");
 const { disableAutostart, enableAutostart, autostartStatus, recallInvocation } = require("./autostart");
-const { archiveRoot, countSessions, ensureConversationMarkdown, ensureSessionView, findSessionById, listSessions, readEvents, readTranscript, revealSession, sessionViewPathForSession, usageTokenSummary, VIEW_SCHEMA_VERSION, writeSession } = require("./archive");
+const { archiveRoot, cachedListSessionsSnapshot, countSessions, ensureConversationMarkdown, ensureSessionView, findSessionById, isWebChatProvider, listSessions, readEvents, readTranscript, revealSession, sessionViewPathForSession, usageTokenSummary, VIEW_SCHEMA_VERSION, walk, writeSession } = require("./archive");
 const { logsCommand } = require("./commands/logs");
 const { serverCommand: runServerCommand } = require("./commands/server");
 const { effectiveImportSources, getConfigKey, initConfig, loadConfig, normalizeRemoteEndpointInput, saveConfig, setConfigKey } = require("./config");
@@ -18,15 +18,28 @@ const { discoverCliHistory, importCliHistory, importWebChat, importWindsurfTraje
 const { runMcpServer } = require("./mcp");
 const { defaultRedactionConfig, loadRedactionConfig, redactionBuiltInNames, redactionLabel, saveRedactionConfig } = require("./redaction");
 const { buildIndex, listHistorySessions, listRecentSessions, readIndexSummary, searchPastSessions } = require("./search");
-const { IMPORT_SOURCE_ORDER } = require("./sources");
+const { HISTORY_PROVIDER_OPTIONS, IMPORT_SOURCE_ORDER } = require("./sources");
 const { ensureBaseDirs, ensureDir, paths, readJson, writeJson } = require("./paths");
 const { runSupervisorForeground, startSupervisorDetached, stopSupervisor, supervisorStatus } = require("./supervisor");
 const { configureRemoteFromFlags, hasRemoteTarget, listRemoteSnapshots, replaceRemoteArchive, snapshotArchive, syncArchive, wipeRemoteArchive } = require("./sync");
 const { version } = require("./version");
 const { listWebAccounts, renameWebAccount } = require("./web-accounts");
+const { webExportInstructions } = require("./web-export-instructions");
 
 const HISTORY_AUTH_COOKIE = "agentlog_history";
-const SESSION_WEB_PAYLOAD_VERSION = 3;
+const SESSION_WEB_PAYLOAD_VERSION = 6;
+// Bumped when any list-derived payload shape changes (recent/tree/repo-sessions/stats).
+// Combined with the listSessions snapshot fingerprint to form the etag, so a
+// client receiving a 304 is guaranteed to have a payload that still matches the
+// current renderer.
+const LIST_PAYLOAD_VERSION = 1;
+// Memoize statsPayload between requests. Stats are archive-wide aggregates
+// derived purely from the listSessions snapshot, so the snapshot fingerprint
+// + filter shape is a complete cache key. Bounded at a small number of
+// distinct filter shapes (today: includeWebChats true/false × the empty
+// filter set) to keep memory trivial.
+const _statsPayloadCache = new Map();
+const STATS_PAYLOAD_CACHE_LIMIT = 8;
 
 async function main(argv = process.argv.slice(2), env = process.env) {
   const { positionals, flags } = parseArgs(argv);
@@ -152,10 +165,12 @@ async function initCommand(flags, env) {
   });
   discoveryProgress.done();
   const importSources = await chooseImportSources(flags, discovered);
+  let backfillSince = "";
 
   if (!flags["skip-import"]) {
     const since = await chooseImportSince(flags);
     if (since) {
+      backfillSince = since;
       printSection("Backfill");
       printMuted(`Backing up existing history into ${fullPath(cfg.storage.root || paths(env).data)}`);
       const progress = createProgressReporter();
@@ -169,6 +184,7 @@ async function initCommand(flags, env) {
   }
 
   const watcherSetup = await chooseWatcherSources(flags, discovered, importSources);
+  if (backfillSince) applyUpdateSincePreference(cfg, backfillSince);
   cfg.imports.sources = watcherSetup.sources;
   cfg.imports.autoDiscoverSources = watcherSetup.autoDiscoverSources;
   saveConfig(cfg, env);
@@ -1444,6 +1460,7 @@ function printConfigSetupSummary(cfg, env, loginStatus = null, changed = false)
   printCheck("Config", fullPath(paths(env).config));
   printCheck("Watcher sources", (cfg.imports?.sources || []).join(", ") || "none");
   printCheck("Import window", `${cfg.imports?.defaultSinceDays ?? 30} days`);
+  printCheck("Update rebuild window", defaultImportSince(cfg));
   printCheck("Auto-discover sources", cfg.imports?.autoDiscoverSources === false ? "disabled" : "enabled");
   printCheck("Sync interval", formatConfigInterval(cfg.sync?.intervalMinutes ?? 30));
   if (loginStatus) {
@@ -1795,19 +1812,35 @@ async function updateCommand(flags, env) {
     return;
   }
 
-  if (running.running) {
-    const stopped = stopSupervisor(env);
-    if (stopped) {
-      printCheck("Watcher", "stop signal sent");
-      await waitForSupervisorExit(running.pid);
+  const preservedWebChats = preserveUpdateWebChatArchives(env);
+  let restoredWebChats = false;
+  try {
+    if (running.running) {
+      const stopped = stopSupervisor(env);
+      if (stopped) {
+        printCheck("Watcher", "stop signal sent");
+        await waitForSupervisorExit(running.pid);
+      }
     }
-  }
 
-  for (const target of targets) {
-    fs.rmSync(target.path, { recursive: true, force: true });
-    printCheck("Removed", fullPath(target.path));
+    for (const target of targets) {
+      fs.rmSync(target.path, { recursive: true, force: true });
+      printCheck("Removed", fullPath(target.path));
+    }
+    ensureBaseDirs(p);
+    const restored = restoreUpdateWebChatArchives(preservedWebChats, env);
+    restoredWebChats = true;
+    cleanupUpdatePreservedWebChats(preservedWebChats);
+    if (restored.sessionCount) printCheck("Preserved web chats", `${restored.sessionCount} session(s)`);
+  } catch (error) {
+    if (!restoredWebChats) {
+      const restored = restoreUpdateWebChatArchives(preservedWebChats, env);
+      restoredWebChats = true;
+      if (restored.sessionCount) printMuted(`Restored preserved web chats after update interruption: ${restored.sessionCount} session(s).`);
+    }
+    cleanupUpdatePreservedWebChats(preservedWebChats);
+    throw error;
   }
-  ensureBaseDirs(p);
 
   printSection("Import");
   const progress = flags.json ? null : createProgressReporter();
@@ -1851,7 +1884,128 @@ async function updateCommand(flags, env) {
     }
   }
 
-  printMuted("Config, redaction settings, web account labels, source histories, and recall integrations were not changed.");
+  printMuted("Config, redaction settings, web account labels, web chat archives, source histories, and recall integrations were not changed.");
+}
+
+function preserveUpdateWebChatArchives(env) {
+  const sessions = listSessions(env).filter(updatePreservedWebChatSession);
+  if (!sessions.length) return { tempRoot: "", sessions: [], sessionCount: 0, fileCount: 0 };
+  const archive = archiveRoot(env);
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "agentlog-update-web-chats-"));
+  const copied = new Set();
+  let fileCount = 0;
+  for (const session of sessions) {
+    for (const sourcePath of updateWebChatArchivePaths(session)) {
+      if (copyUpdateArchivePath(sourcePath, archive, tempRoot, copied)) fileCount++;
+    }
+  }
+  return { tempRoot, sessions, sessionCount: sessions.length, fileCount };
+}
+
+function updatePreservedWebChatSession(session) {
+  if (isWebChatProvider(session?.provider, session?.sourceType)) return true;
+  return /^\[(chatgpt|claude)\]conversations\//i.test(String(session?.scopeCanonical || ""));
+}
+
+function updateWebChatArchivePaths(session) {
+  const values = [
+    session?.conversationPath,
+    session?.metadataPath,
+    session?.transcriptPath,
+    session?.eventPath,
+    session?.viewPath,
+    session?.rawPath
+  ];
+  const rawRecords = Array.isArray(session?.rawFiles) ? session.rawFiles : [];
+  for (const record of rawRecords) {
+    values.push(record?.archivedPath, record?.sharedRawPath);
+  }
+  if (session?.rawPath) {
+    const manifest = readJson(path.join(session.rawPath, "manifest.json"), null);
+    for (const record of Array.isArray(manifest?.files) ? manifest.files : []) {
+      values.push(record?.archivedPath, record?.sharedRawPath);
+    }
+  }
+  return values.filter(Boolean);
+}
+
+function copyUpdateArchivePath(sourcePath, archive, tempRoot, copied) {
+  const archiveRootPath = path.resolve(archive);
+  const resolved = path.resolve(String(sourcePath || ""));
+  const relative = path.relative(archiveRootPath, resolved);
+  if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) return false;
+  if (copied.has(relative)) return false;
+  const stat = safeUpdateStat(resolved);
+  if (!stat) return false;
+  const target = path.join(tempRoot, relative);
+  ensureDir(path.dirname(target));
+  if (stat.isDirectory()) {
+    fs.cpSync(resolved, target, { recursive: true, force: true, preserveTimestamps: true });
+  } else if (stat.isFile()) {
+    fs.copyFileSync(resolved, target);
+  } else {
+    return false;
+  }
+  copied.add(relative);
+  return true;
+}
+
+function restoreUpdateWebChatArchives(snapshot, env) {
+  if (!snapshot?.tempRoot) return { sessionCount: 0, fileCount: 0 };
+  const archive = archiveRoot(env);
+  ensureDir(archive);
+  let fileCount = 0;
+  walk(snapshot.tempRoot, (file) => {
+    const relative = path.relative(snapshot.tempRoot, file);
+    if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) return;
+    const target = path.join(archive, relative);
+    ensureDir(path.dirname(target));
+    fs.copyFileSync(file, target);
+    fileCount++;
+  });
+  writeUpdatePreservedWebChatManifest(snapshot.sessions || [], env);
+  return { sessionCount: snapshot.sessionCount || (snapshot.sessions || []).length, fileCount };
+}
+
+function writeUpdatePreservedWebChatManifest(sessions, env) {
+  if (!sessions.length) return;
+  const entries = sessions
+    .map((session) => {
+      const metadata = readJson(session.metadataPath, null) || session;
+      if (!metadata?.sessionId) return null;
+      return {
+        sessionId: metadata.sessionId,
+        provider: metadata.provider,
+        repoCanonical: metadata.repoCanonical || "",
+        scopeCanonical: metadata.scopeCanonical || "",
+        startedAt: metadata.startedAt || "",
+        conversationPath: metadata.conversationPath || session.conversationPath || "",
+        metadataPath: session.metadataPath || "",
+        transcriptPath: metadata.transcriptPath || session.transcriptPath || "",
+        eventPath: metadata.eventPath || session.eventPath || "",
+        viewPath: metadata.viewPath || session.viewPath || "",
+        rawPath: metadata.rawPath || session.rawPath || ""
+      };
+    })
+    .filter(Boolean)
+    .sort((a, b) => String(b.startedAt).localeCompare(String(a.startedAt)));
+  if (!entries.length) return;
+  const manifestPath = path.join(archiveRoot(env), "sessions", "manifest.json");
+  ensureDir(path.dirname(manifestPath));
+  writeJson(manifestPath, { sessions: entries });
+}
+
+function cleanupUpdatePreservedWebChats(snapshot) {
+  if (snapshot?.tempRoot) fs.rmSync(snapshot.tempRoot, { recursive: true, force: true });
+}
+
+function safeUpdateStat(target) {
+  try {
+    return fs.statSync(target);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
 }
 
 async function waitForSupervisorExit(pid, timeoutMs = 5000) {
@@ -1906,11 +2060,41 @@ function updateTargets(env) {
 }
 
 function defaultImportSince(config) {
-  const value = config?.imports?.defaultSinceDays;
-  if (String(value || "").trim().toLowerCase() === "all") return "all";
-  const days = Number(value);
-  if (!Number.isFinite(days) || days <= 0) return "30d";
-  return `${Math.round(days)}d`;
+  const updateSince = normalizeUpdateSincePreference(config?.imports?.updateSince);
+  if (updateSince) return updateSince;
+  return "all";
+}
+
+function shouldRememberUpdateSince(source, flags = {}) {
+  if (!(flags.since || flags["import-since"])) return false;
+  return String(source || "").trim().toLowerCase() === "all";
+}
+
+function rememberUpdateSincePreference(since, env) {
+  const cfg = loadConfig(env);
+  if (!applyUpdateSincePreference(cfg, since)) return false;
+  cfg.updatedAt = new Date().toISOString();
+  saveConfig(cfg, env);
+  return true;
+}
+
+function applyUpdateSincePreference(cfg, since) {
+  const normalized = normalizeUpdateSincePreference(since);
+  if (!normalized) return false;
+  cfg.imports = {
+    ...(cfg.imports || {}),
+    updateSince: normalized
+  };
+  return true;
+}
+
+function normalizeUpdateSincePreference(value) {
+  const text = String(value || "").trim().toLowerCase();
+  if (!text) return "";
+  if (text === "all") return "all";
+  const match = text.match(/^(\d+)([dhm])$/);
+  if (!match) return "";
+  return `${Math.max(1, Math.round(Number(match[1])))}${match[2]}`;
 }
 
 function coalesceTargets(targets) {
@@ -2185,33 +2369,39 @@ async function importCommand(args, flags, env) {
     printImportResults([result]);
     return;
   }
-  if (sub === "claude-web" || sub === "chatgpt") {
-    let importFile = flags.file || args[1] || "";
-    if (!importFile && process.stdin.isTTY) {
-      printSection(`${sub} Export`);
-      printMuted("Choose the official export JSON, ZIP, or extracted folder.");
-      importFile = (await ask("  Export path: ")).trim();
+  if (sub === "claude-web" || sub === "claude_web" || sub === "chatgpt") {
+    const instructions = webExportInstructions(sub);
+    if (flags.instructions || flags.instruction || flags.docs) {
+      return printWebExportInstructions(instructions, flags);
+    }
+    let importFiles = webImportFiles(args, flags);
+    if (!importFiles.length) {
+      if (process.stdin.isTTY && !flags.json) return interactiveWebChatImport(sub, instructions, flags, env);
+      return printWebExportInstructions(instructions, flags);
     }
-    if (!importFile) throw new Error(`usage: agentlog import ${sub} <path> --username <name> [--display-name <name>] [--account-id <id>] [--scope local|team]`);
     let username = flags.username || "";
     let displayName = flags["display-name"] || flags.displayName || "";
     if (!username && process.stdin.isTTY) {
       username = (await ask(`${sub} account username/email: `)).trim();
       if (!displayName) displayName = (await ask(`Display name [${username}]: `)).trim() || username;
     }
-    const result = importWebChat(sub, path.resolve(importFile), {
+    importFiles = importFiles.map((file) => resolveUserPath(file, { base: process.cwd() }));
+    const progress = flags.json ? null : createProgressReporter();
+    const result = importWebChat(instructions.source, importFiles.length === 1 ? importFiles[0] : importFiles, {
       scope: flags.scope || "local",
       dryRun: flags["dry-run"],
       username,
       displayName,
-      accountId: flags["account-id"] || flags.accountId || ""
+      accountId: flags["account-id"] || flags.accountId || "",
+      onProgress: progress?.update
     }, env);
+    progress?.done();
     if (flags.json) {
       console.log(JSON.stringify(result, null, 2));
       return;
     }
     printPageTitle("agentlog import", `${sub} ${flags["dry-run"] ? "dry run" : "complete"}`);
-    printCheck("File", fullPath(result.file));
+    printCheck(importFiles.length === 1 ? "File" : "Files", importFiles.length === 1 ? fullPath(result.file) : importFiles.map(fullPath).join(", "));
     printCheck("Account", `${result.displayName || result.username} (${result.accountId})`);
     printCheck("Conversations", String(result.conversations));
     printCheck("Imported", String(result.imported));
@@ -2226,12 +2416,13 @@ async function importCommand(args, flags, env) {
     : source === "all"
       ? loadConfig(env).imports?.sources
       : undefined;
+  const since = flags.since || flags["import-since"] || "30d";
   const progress = flags.json ? null : createProgressReporter();
   const results = importCliHistory(
     {
       source,
       sources: explicitSources,
-      since: flags.since || "30d",
+      since,
       repos,
       dryRun: flags["dry-run"],
       explainSkips: Boolean(flags["explain-skips"]),
@@ -2240,6 +2431,9 @@ async function importCommand(args, flags, env) {
     env
   );
   progress?.done();
+  if (!flags["dry-run"] && shouldRememberUpdateSince(source, flags)) {
+    rememberUpdateSincePreference(since, env);
+  }
   if (flags.json) {
     console.log(JSON.stringify(results, null, 2));
     return;
@@ -2248,6 +2442,92 @@ async function importCommand(args, flags, env) {
   printImportResults(results, { explainSkips: Boolean(flags["explain-skips"]) });
 }
 
+function webImportFiles(args = [], flags = {}) {
+  const files = [];
+  const flagValue = flags.file || flags.files;
+  if (Array.isArray(flagValue)) files.push(...flagValue);
+  else if (flagValue) files.push(...String(flagValue).split(","));
+  files.push(...args.slice(1));
+  return files.map((item) => String(item || "").trim()).filter(Boolean);
+}
+
+async function interactiveWebChatImport(sub, instructions, flags = {}, env = process.env) {
+  if (!instructions) throw new Error("unknown web export instruction source");
+  printPageTitle("agentlog import", `${instructions.source} walkthrough`);
+  printWebExportWalkthroughIntro(instructions);
+
+  const defaultPath = defaultWebExportPath(instructions.source);
+  const defaultPathLabel = defaultPath ? compactPath(defaultPath) : "";
+  const importFiles = [];
+  while (true) {
+    const prompt = importFiles.length
+      ? "Additional export path (blank when done): "
+      : `Export path${defaultPathLabel ? ` [${defaultPathLabel}]` : ""}: `;
+    let answer = (await ask(prompt)).trim();
+    if (!answer && !importFiles.length && defaultPath) answer = defaultPath;
+    if (!answer) break;
+    importFiles.push(resolveUserPath(answer, { base: process.cwd() }));
+  }
+  if (!importFiles.length) {
+    printMuted("No export path provided.");
+    printWebExportInstructionBlock(instructions);
+    return;
+  }
+
+  const usernameDefault = flags.username || "";
+  const usernamePrompt = usernameDefault ? `Account username/email [${usernameDefault}]: ` : "Account username/email: ";
+  const username = flags.username || (await ask(usernamePrompt)).trim();
+  if (!username) throw new Error(`--username is required for a new ${instructions.label} export account`);
+  const displayDefault = flags["display-name"] || flags.displayName || username;
+  const displayName = flags["display-name"] || flags.displayName || ((await ask(`Display name [${displayDefault}]: `)).trim() || displayDefault);
+  const shouldDryRun = Boolean(flags["dry-run"]);
+  const runOptions = {
+    scope: flags.scope || "local",
+    dryRun: shouldDryRun,
+    username,
+    displayName,
+    accountId: flags["account-id"] || flags.accountId || ""
+  };
+  const target = importFiles.length === 1 ? importFiles[0] : importFiles;
+  const progress = createProgressReporter();
+  const result = importWebChat(instructions.source, target, { ...runOptions, onProgress: progress.update }, env);
+  progress.done();
+  printWebChatImportResult(sub, result, importFiles, shouldDryRun);
+}
+
+function printWebExportWalkthroughIntro(instructions) {
+  printSection(`${instructions.label} Export`);
+  if (instructions.source === "chatgpt") {
+    printMuted("If you have OpenAI-export.zip and it is large, unzip it first.");
+    printMuted("Best path: the extracted OpenAI-export/User Online Activity folder.");
+    printMuted("If your export is split, enter the parent folder or enter each Conversations__...chatgpt...part folder one at a time, then press Enter on a blank line.");
+  } else {
+    printMuted(`Enter the ${instructions.fileDescription} path. Press Enter on a blank line when done.`);
+  }
+  printCheck("Request page", instructions.requestUrl);
+  printCheck("Help", instructions.helpUrl);
+}
+
+function printWebChatImportResult(sub, result, importFiles, dryRun) {
+  printPageTitle("agentlog import", `${sub} ${dryRun ? "dry run" : "complete"}`);
+  printCheck(importFiles.length === 1 ? "File" : "Files", importFiles.length === 1 ? fullPath(result.file) : importFiles.map(fullPath).join(", "));
+  printCheck("Account", `${result.displayName || result.username} (${result.accountId})`);
+  printCheck("Conversations", String(result.conversations));
+  printCheck("Imported", String(result.imported));
+  printCheck("Skipped", String(result.skipped));
+  for (const error of result.errors || []) console.log(`  ! ${error}`);
+}
+
+function defaultWebExportPath(source) {
+  if (source === "chatgpt") {
+    const activity = path.join(os.homedir(), "Downloads", "OpenAI-export", "User Online Activity");
+    if (fs.existsSync(activity)) return activity;
+    const root = path.join(os.homedir(), "Downloads", "OpenAI-export");
+    if (fs.existsSync(root)) return root;
+  }
+  return "";
+}
+
 async function accountsCommand(args, flags, env, title = "agentlog accounts") {
   const action = args[0] || "list";
   if (action === "list") {
@@ -2427,7 +2707,11 @@ function readSessionView(sessionId, env) {
 
 function sessionViewPayload(view, env = process.env, options = {}) {
   const baked = ensureSessionView(view.session, env);
-  const transcriptMessages = viewerTranscriptMessages(baked.transcript_messages || [], options);
+  const transcriptMessages = viewerTranscriptMessages(baked.transcript_messages || [], {
+    ...options,
+    session: view.session,
+    env
+  });
   const canonicalEvents = viewerCanonicalEvents(baked.canonical_events || [], options);
   const resumeCommand = resumeCommandForSession(view.session);
   const payload = {
@@ -2444,6 +2728,7 @@ function sessionViewPayload(view, env = process.env, options = {}) {
     chat_display_name: view.session.chatDisplayName || undefined,
     chat_project_path: view.session.chatProjectPath || undefined,
     conversation_kind: view.session.conversationKind || undefined,
+    parent_composer_id: view.session.parentComposerId || undefined,
     pinned: Boolean(view.session.pinned) || undefined,
     cwd: view.session.cwd || undefined,
     title: view.session.title || undefined,
@@ -2469,8 +2754,44 @@ function sessionViewPayload(view, env = process.env, options = {}) {
 }
 
 function viewerTranscriptMessages(messages, options = {}) {
-  if (!options.compactTranscriptMetadata) return messages;
-  return messages.map(compactViewerTranscriptMessage);
+  const withAttachments = options.session?.sessionId
+    ? messages.map((message, index) => viewerMessageWithAttachmentUrls(message, options.session, index, options.env || process.env))
+    : messages;
+  if (!options.compactTranscriptMetadata) return withAttachments;
+  return withAttachments.map(compactViewerTranscriptMessage);
+}
+
+function viewerMessageWithAttachmentUrls(message, session, position, env = process.env) {
+  if (!message || typeof message !== "object") return message;
+  const metadata = message.metadata && typeof message.metadata === "object" ? message.metadata : null;
+  const attachments = Array.isArray(metadata?.attachments) ? metadata.attachments : [];
+  if (!attachments.length) return message;
+  const messageIndex = Number.isFinite(Number(message.index)) ? Number(message.index) : position;
+  return {
+    ...message,
+    metadata: {
+      ...metadata,
+      attachments: attachments.map((attachment, attachmentIndex) => ({
+        ...attachment,
+        ...viewerAttachmentAvailability(session, message, attachment, attachmentIndex, env, messageIndex)
+      }))
+    }
+  };
+}
+
+function viewerAttachmentAvailability(session, message, attachment, attachmentIndex, env, messageIndex) {
+  if (attachment?.url) return { url: attachment.url, available: true };
+  const resolved = resolveSessionAttachmentRecord(session, message, attachment, attachmentIndex, env, { probeOnly: true });
+  if (!resolved) return { available: false };
+  if (resolved.cleanup) resolved.cleanup();
+  return {
+    url: sessionAttachmentUrl(session.sessionId, messageIndex, attachmentIndex),
+    available: true
+  };
+}
+
+function sessionAttachmentUrl(sessionId, messageIndex, attachmentIndex) {
+  return `/api/session-attachment?id=${encodeURIComponent(sessionId)}&message=${encodeURIComponent(String(messageIndex))}&attachment=${encodeURIComponent(String(attachmentIndex))}`;
 }
 
 function compactViewerTranscriptMessage(message) {
@@ -2652,19 +2973,30 @@ function historyWebCommand(flags, env) {
     }
     if (url.pathname === "/api/recent") {
       const filters = historyFiltersFromSearchParams(url.searchParams, 20);
-      writeJsonResponse(res, listRecentSessions(filters.limit, filters, env));
+      respondWithListSnapshot(req, res, "recent", filterShapeKey(filters), env, () =>
+        listRecentSessions(filters.limit, filters, env)
+      );
       return;
     }
     if (url.pathname === "/api/tree") {
       const filters = historyFiltersFromSearchParams(url.searchParams, 20);
-      writeJsonResponse(res, sessionTreePayload(filters, env));
+      respondWithListSnapshot(req, res, "tree", filterShapeKey(filters), env, () =>
+        sessionTreePayload(filters, env)
+      );
       return;
     }
     if (url.pathname === "/api/repo-sessions") {
       const filters = historyFiltersFromSearchParams(url.searchParams, 20);
       const repoKey = url.searchParams.get("repo_key") || "";
       const offset = Math.max(0, Number(url.searchParams.get("offset") || 0));
-      writeJsonResponse(res, repoSessionsPayload(repoKey, filters, offset, env));
+      respondWithListSnapshot(
+        req,
+        res,
+        "repo-sessions",
+        repoSessionsFilterKey(repoKey, filters, offset),
+        env,
+        () => repoSessionsPayload(repoKey, filters, offset, env)
+      );
       return;
     }
     if (url.pathname === "/api/search" || url.pathname === "/search") {
@@ -2677,6 +3009,10 @@ function historyWebCommand(flags, env) {
       writeJsonResponse(res, results);
       return;
     }
+    if (url.pathname === "/api/session-attachment") {
+      serveSessionAttachment(res, url.searchParams, env);
+      return;
+    }
     if (url.pathname === "/api/session") {
       try {
         const includeMarkdown = url.searchParams.get("markdown") === "1";
@@ -2713,7 +3049,9 @@ function historyWebCommand(flags, env) {
     }
     if (url.pathname === "/api/stats") {
       const filters = statsFiltersFromSearchParams(url.searchParams);
-      writeJsonResponse(res, statsPayload(filters, env));
+      respondWithListSnapshot(req, res, "stats", filterShapeKey({ ...filters, limit: 0 }), env, (snapshot) =>
+        memoizedStatsPayload(snapshot, filters, env)
+      );
       return;
     }
     if (isHome) {
@@ -2775,6 +3113,7 @@ function statsFiltersFromSearchParams(params) {
 function sessionTreePayload(filters, env) {
   const pageSize = clampLimit(filters.limit, 20);
   const sessions = listHistorySessions(filters, env);
+  const sourceOptionSessions = listHistorySessions(historySourceOptionFilters(filters), env);
   const repos = new Map();
   for (const session of sessions) {
     const repoKey = sessionRepoKey(session);
@@ -2805,10 +3144,60 @@ function sessionTreePayload(filters, env) {
   return {
     generated_at: new Date().toISOString(),
     count: sessions.length,
+    available_source_options: availableHistorySourceOptions(sourceOptionSessions),
     groups
   };
 }
 
+function historySourceOptionFilters(filters) {
+  return {
+    ...(filters || {}),
+    provider: "",
+    source: "",
+    sourceType: "",
+    source_type: ""
+  };
+}
+
+function availableHistorySourceOptions(sessions) {
+  const rows = Array.isArray(sessions) ? sessions : [];
+  return HISTORY_PROVIDER_OPTIONS
+    .map((option) => {
+      const count = rows.filter((session) => historySourceOptionMatchesSession(option.source, session)).length;
+      return count ? { value: option.source, label: option.label, count } : null;
+    })
+    .filter(Boolean);
+}
+
+function historySourceOptionMatchesSession(source, session) {
+  const provider = String(session?.provider || "").toLowerCase();
+  const sourceType = String(session?.source_type || session?.sourceType || "").toLowerCase();
+  const sourceTypes = {
+    "codex-cli": ["codex-cli-history", "cli-history"],
+    "codex-desktop": ["codex-desktop-history"],
+    "codex-sdk": ["codex-sdk-history"],
+    "claude-code-desktop": ["claude-code-desktop-metadata"],
+    "claude-workspace": ["claude-workspace-desktop"],
+    "claude-sdk": ["claude-sdk-history"],
+    "devin-cli": ["devin-cli-history"],
+    cline: ["cline-task-history"],
+    "opencode-cli": ["opencode-cli-history", "opencode-cli-sqlite-history"],
+    "opencode-desktop": ["opencode-desktop-history", "opencode-desktop-sqlite-history"],
+    "opencode-web": ["opencode-web-sqlite-history"],
+    aider: ["aider-chat-history"]
+  }[source];
+  if (sourceTypes) return sourceTypes.includes(sourceType);
+  const providers = {
+    chatgpt: ["chatgpt"],
+    claude: ["claude_code"],
+    "claude-web": ["claude_web"],
+    "gemini-cli": ["gemini_cli"],
+    antigravity: ["antigravity"],
+    cursor: ["cursor"]
+  }[source];
+  return providers ? providers.includes(provider) : false;
+}
+
 function historySessionUpdatedAt(session) {
   if (session.time_status === "recovered-time-unknown") return "";
   return session.ended_at || session.started_at || session.archived_at || "";
@@ -2827,10 +3216,13 @@ function compareHistorySessionsForTree(a, b) {
 
 function statsPayload(filters, env) {
   const sessions = listHistorySessions({ ...filters, limit: 5000 }, env);
-  return statsPayloadForSessions(sessions);
+  return statsPayloadForSessions(sessions, { includeSdk: statsFiltersTargetSdk(filters) });
 }
 
 function statsPayloadForSessions(sessions, options = {}) {
+  const allSessions = Array.isArray(sessions) ? sessions : [];
+  const sdkSessions = allSessions.filter(isSdkStatsSession);
+  const statsSessions = options.includeSdk ? allSessions : allSessions.filter((session) => !isSdkStatsSession(session));
   const providerSet = new Set();
   const companySet = new Set();
   const modelGroupSet = new Set();
@@ -2847,13 +3239,14 @@ function statsPayloadForSessions(sessions, options = {}) {
   let totalInputTokens = 0;
   let totalOutputTokens = 0;
   let totalCacheTokens = 0;
+  let totalReasoningTokens = 0;
   let totalEstimatedTokens = 0;
   let totalConversations = 0;
   let totalMessages = 0;
   let totalUserMessages = 0;
   let peakSessionTokens = 0;
   let peakSessionLabel = "";
-  for (const session of sessions) {
+  for (const session of statsSessions) {
     const provider = String(session.provider || "unknown");
     const modelGroup = statsSessionPrimaryModel(session);
     const companyGroup = statsSessionCompany(session, provider, modelGroup);
@@ -2870,6 +3263,7 @@ function statsPayloadForSessions(sessions, options = {}) {
     totalInputTokens += usageTokens.tokens_input;
     totalOutputTokens += usageTokens.tokens_output;
     totalCacheTokens += usageTokens.tokens_cache;
+    totalReasoningTokens += usageTokens.tokens_reasoning;
     totalEstimatedTokens += usageTokens.tokens_estimated;
     totalConversations += 1;
     totalMessages += Number.isFinite(messageCount) ? messageCount : 0;
@@ -2897,7 +3291,7 @@ function statsPayloadForSessions(sessions, options = {}) {
       dayBucket.models[modelGroup].conversations += 1;
       dayBucket.models[modelGroup].user_messages += userMessageCount;
 
-      if (!dailyActivity.has(dayKey)) dailyActivity.set(dayKey, { sessions: 0, conversations: 0, user_messages: 0, tokens: 0, tokens_input: 0, tokens_output: 0, tokens_cache: 0, tokens_estimated: 0, messages: 0 });
+      if (!dailyActivity.has(dayKey)) dailyActivity.set(dayKey, { sessions: 0, conversations: 0, user_messages: 0, tokens: 0, tokens_input: 0, tokens_output: 0, tokens_cache: 0, tokens_reasoning: 0, tokens_estimated: 0, messages: 0 });
       const activity = dailyActivity.get(dayKey);
       activity.sessions += 1;
       activity.conversations += 1;
@@ -2909,7 +3303,7 @@ function statsPayloadForSessions(sessions, options = {}) {
     if (!isWebChatStatsProvider(provider)) {
       const repoKey = sessionRepoKey(session);
       const repoLabel = sessionRepoLabel(session);
-      if (!repoMap.has(repoKey)) repoMap.set(repoKey, { repo_key: repoKey, repo_display: repoLabel, providers: {}, companies: {}, models: {}, tokens: 0, tokens_input: 0, tokens_output: 0, tokens_cache: 0, tokens_estimated: 0, conversations: 0, user_messages: 0 });
+      if (!repoMap.has(repoKey)) repoMap.set(repoKey, { repo_key: repoKey, repo_display: repoLabel, providers: {}, companies: {}, models: {}, tokens: 0, tokens_input: 0, tokens_output: 0, tokens_cache: 0, tokens_reasoning: 0, tokens_estimated: 0, conversations: 0, user_messages: 0 });
       const repoBucket = repoMap.get(repoKey);
       repoBucket.repo_display = repoLabel;
       if (!repoBucket.providers[provider]) repoBucket.providers[provider] = statsBucket();
@@ -2931,7 +3325,7 @@ function statsPayloadForSessions(sessions, options = {}) {
       if (dayKey) {
         if (!dailyRepoMap.has(dayKey)) dailyRepoMap.set(dayKey, new Map());
         const dailyRepos = dailyRepoMap.get(dayKey);
-        if (!dailyRepos.has(repoKey)) dailyRepos.set(repoKey, { repo_key: repoKey, repo_display: repoLabel, providers: {}, companies: {}, models: {}, tokens: 0, tokens_input: 0, tokens_output: 0, tokens_cache: 0, tokens_estimated: 0, conversations: 0, user_messages: 0 });
+        if (!dailyRepos.has(repoKey)) dailyRepos.set(repoKey, { repo_key: repoKey, repo_display: repoLabel, providers: {}, companies: {}, models: {}, tokens: 0, tokens_input: 0, tokens_output: 0, tokens_cache: 0, tokens_reasoning: 0, tokens_estimated: 0, conversations: 0, user_messages: 0 });
         const dailyRepoBucket = dailyRepos.get(repoKey);
         dailyRepoBucket.repo_display = repoLabel;
         if (!dailyRepoBucket.providers[provider]) dailyRepoBucket.providers[provider] = statsBucket();
@@ -3012,6 +3406,7 @@ function statsPayloadForSessions(sessions, options = {}) {
           tokens_input: entry.tokens_input,
           tokens_output: entry.tokens_output,
           tokens_cache: entry.tokens_cache,
+          tokens_reasoning: entry.tokens_reasoning,
           tokens_estimated: entry.tokens_estimated,
           conversations: entry.conversations,
           user_messages: entry.user_messages,
@@ -3034,6 +3429,7 @@ function statsPayloadForSessions(sessions, options = {}) {
       tokens_input: entry.tokens_input,
       tokens_output: entry.tokens_output,
       tokens_cache: entry.tokens_cache,
+      tokens_reasoning: entry.tokens_reasoning,
       tokens_estimated: entry.tokens_estimated,
       conversations: entry.conversations,
       user_messages: entry.user_messages,
@@ -3080,7 +3476,7 @@ function statsPayloadForSessions(sessions, options = {}) {
   const favoriteProviderEntry = byProvider[0] || null;
   const dailyActivityList = activitySorted.map((day) => {
     const entry = dailyActivity.get(day);
-    return { date: day, sessions: entry.sessions, conversations: entry.conversations, user_messages: entry.user_messages, messages: entry.messages, tokens: entry.tokens, tokens_input: entry.tokens_input, tokens_output: entry.tokens_output, tokens_cache: entry.tokens_cache, tokens_estimated: entry.tokens_estimated };
+    return { date: day, sessions: entry.sessions, conversations: entry.conversations, user_messages: entry.user_messages, messages: entry.messages, tokens: entry.tokens, tokens_input: entry.tokens_input, tokens_output: entry.tokens_output, tokens_cache: entry.tokens_cache, tokens_reasoning: entry.tokens_reasoning, tokens_estimated: entry.tokens_estimated };
   });
   const monthAgg = new Map();
   let peakDayTokens = 0;
@@ -3114,21 +3510,33 @@ function statsPayloadForSessions(sessions, options = {}) {
   const avgMessagesPerConversation =
     totalConversations > 0 ? totalMessages / totalConversations : 0;
   const splitStats = options.includeSplit === false ? null : {
-    agent: statsPayloadForSessions(sessions.filter((session) => statsSessionCategory(session) === "agent"), { includeSplit: false, category: "agent" }),
-    chat: statsPayloadForSessions(sessions.filter((session) => statsSessionCategory(session) === "chat"), { includeSplit: false, category: "chat" })
+    agent: statsPayloadForSessions(allSessions.filter((session) => !isSdkStatsSession(session) && statsSessionCategory(session) === "agent"), { includeSplit: false, category: "agent" }),
+    chat: statsPayloadForSessions(allSessions.filter((session) => !isSdkStatsSession(session) && statsSessionCategory(session) === "chat"), { includeSplit: false, category: "chat" }),
+    sdk: statsPayloadForSessions(sdkSessions, { includeSplit: false, includeSdk: true, category: "sdk" })
   };
+  const sdkStats = splitStats?.sdk || null;
   return {
     category: options.category || "all",
     generated_at: new Date().toISOString(),
     session_count: totalConversations,
     agent_session_count: splitStats ? splitStats.agent.session_count : undefined,
     chat_session_count: splitStats ? splitStats.chat.session_count : undefined,
+    sdk_session_count: sdkStats ? sdkStats.session_count : undefined,
+    sdk_message_count: sdkStats ? sdkStats.message_count : undefined,
+    sdk_user_message_count: sdkStats ? sdkStats.user_message_count : undefined,
+    sdk_total_tokens: sdkStats ? sdkStats.total_tokens : undefined,
+    sdk_total_input_tokens: sdkStats ? sdkStats.total_input_tokens : undefined,
+    sdk_total_output_tokens: sdkStats ? sdkStats.total_output_tokens : undefined,
+    sdk_total_cache_tokens: sdkStats ? sdkStats.total_cache_tokens : undefined,
+    sdk_total_reasoning_tokens: sdkStats ? sdkStats.total_reasoning_tokens : undefined,
+    sdk_total_estimated_tokens: sdkStats ? sdkStats.total_estimated_tokens : undefined,
     message_count: totalMessages,
     user_message_count: totalUserMessages,
     total_tokens: totalTokens,
     total_input_tokens: totalInputTokens,
     total_output_tokens: totalOutputTokens,
     total_cache_tokens: totalCacheTokens,
+    total_reasoning_tokens: totalReasoningTokens,
     total_estimated_tokens: totalEstimatedTokens,
     active_days: activeDays,
     current_streak: currentStreak,
@@ -3221,6 +3629,20 @@ function statsSessionCategory(session) {
   return provider === "chatgpt" || provider === "claude_web" ? "chat" : "agent";
 }
 
+const SDK_STATS_SOURCE_TYPES = new Set(["codex-sdk-history", "claude-sdk-history"]);
+
+function isSdkStatsSession(session) {
+  const provider = String(session?.provider || "").toLowerCase();
+  const sourceType = String(session?.sourceType || session?.source_type || "").toLowerCase();
+  return provider === "claude_sdk" || SDK_STATS_SOURCE_TYPES.has(sourceType);
+}
+
+function statsFiltersTargetSdk(filters = {}) {
+  const provider = String(filters.provider || filters.source || "").trim().toLowerCase().replace(/[-\s]+/g, "_");
+  const sourceType = String(filters.sourceType || filters.source_type || "").trim().toLowerCase();
+  return provider === "codex_sdk" || provider === "claude_sdk" || SDK_STATS_SOURCE_TYPES.has(sourceType);
+}
+
 function isWebChatStatsProvider(provider) {
   return provider === "chatgpt" || provider === "claude_web";
 }
@@ -3234,7 +3656,7 @@ function statsUsageForSession(session) {
 }
 
 function statsBucket() {
-  return { tokens: 0, tokens_input: 0, tokens_output: 0, tokens_cache: 0, tokens_estimated: 0, conversations: 0, user_messages: 0 };
+  return { tokens: 0, tokens_input: 0, tokens_output: 0, tokens_cache: 0, tokens_reasoning: 0, tokens_estimated: 0, conversations: 0, user_messages: 0 };
 }
 
 function statsUserMessageCount(session) {
@@ -3248,6 +3670,7 @@ function addStatsTokens(bucket, usageTokens) {
   bucket.tokens_input += usageTokens.tokens_input;
   bucket.tokens_output += usageTokens.tokens_output;
   bucket.tokens_cache += usageTokens.tokens_cache;
+  bucket.tokens_reasoning += usageTokens.tokens_reasoning;
   bucket.tokens_estimated += usageTokens.tokens_estimated;
 }
 
@@ -3255,15 +3678,32 @@ function statsTokenBreakdown(usage) {
   let input = positiveStatsNumber(usage?.inputTokens);
   let output = positiveStatsNumber(usage?.outputTokens);
   const cache = positiveStatsNumber(usage?.cacheInputTokens);
-  const splitTokens = input + output;
-  const totalTokens = Number(usage?.totalTokens || 0);
-  if (!splitTokens && Number.isFinite(totalTokens) && totalTokens > 0) input = totalTokens;
+  const cacheIncluded =
+    usage?.cacheInputTokensIncludedInInput === true ||
+    usage?.cache_input_tokens_included_in_input === true ||
+    usage?.cacheReadTokensIncludedInInput === true ||
+    usage?.cache_read_tokens_included_in_input === true;
+  const countedCache = cacheIncluded ? 0 : cache;
+  const reasoning = positiveStatsNumber(usage?.reasoningOutputTokens);
+  const reasoningIncluded =
+    usage?.reasoningOutputTokensIncludedInOutput === true ||
+    usage?.reasoning_output_tokens_included_in_output === true ||
+    usage?.reasoningTokensIncludedInOutput === true ||
+    usage?.reasoning_tokens_included_in_output === true;
+  const countedReasoning = reasoningIncluded ? 0 : reasoning;
+  const splitTokens = input + output + countedCache + countedReasoning;
+  const totalTokens = positiveStatsNumber(usage?.totalTokens);
+  if (!splitTokens && totalTokens > 0) input = totalTokens;
+  const categoryTokens = input + output + countedCache + countedReasoning;
+  const authoritative = usage?.authoritativeTotalTokens === true || usage?.authoritative_total_tokens === true;
+  const tokens = authoritative && totalTokens ? totalTokens : Math.max(totalTokens, categoryTokens);
   return {
-    tokens: input + output,
+    tokens,
     tokens_input: input,
     tokens_output: output,
     tokens_cache: cache,
-    tokens_estimated: usage?.estimated ? input + output : 0
+    tokens_reasoning: reasoning,
+    tokens_estimated: usage?.estimated ? tokens : 0
   };
 }
 
@@ -3443,6 +3883,90 @@ function writeNotModifiedSessionResponse(res, etag) {
   res.end();
 }
 
+/**
+ * Compute an etag for a list-derived endpoint (recent/tree/repo-sessions/stats).
+ * Combines the listSessions snapshot fingerprint with the endpoint kind,
+ * filter shape, and renderer version. The fingerprint changes iff any
+ * session's metadata mtime/size changed or the count changed, so the etag
+ * automatically invalidates when the supervisor imports new history.
+ */
+function listSnapshotEtag(snapshot, kind, filterKey) {
+  if (!snapshot || !snapshot.fingerprint) return "";
+  const components = [
+    snapshot.fingerprint,
+    String(kind || ""),
+    String(filterKey || ""),
+    `v${LIST_PAYLOAD_VERSION}`
+  ].join("|");
+  const digest = crypto.createHash("sha1").update(components).digest("base64url");
+  return `"list-${digest}"`;
+}
+
+function filterShapeKey(filters) {
+  if (!filters || typeof filters !== "object") return "default";
+  return [
+    `repo=${filters.repo || ""}`,
+    `provider=${filters.provider || ""}`,
+    `sourceType=${filters.sourceType || ""}`,
+    `since=${filters.since || ""}`,
+    `limit=${filters.limit ?? ""}`,
+    `webChats=${filters.includeWebChats === false ? "0" : "1"}`
+  ].join("&");
+}
+
+function repoSessionsFilterKey(repoKey, filters, offset) {
+  return `${repoKey || ""}|${offset || 0}|${filterShapeKey(filters)}`;
+}
+
+/**
+ * Wrap a list endpoint with snapshot-based etag handling.
+ *
+ * - `kind` is a stable string per endpoint (e.g. "recent", "tree").
+ * - `filterKey` describes the shape of filters/pagination so distinct queries
+ *   get distinct etags.
+ * - `compute(snapshot)` builds the payload. The snapshot is passed so callers
+ *   can avoid re-walking the archive.
+ *
+ * Returns true once the response has been written (either 304 or full body),
+ * letting the dispatcher `return` immediately. Errors fall through to the
+ * caller so existing handlers keep their error shape.
+ */
+function respondWithListSnapshot(req, res, kind, filterKey, env, compute) {
+  const snapshot = cachedListSessionsSnapshot(env);
+  const etag = listSnapshotEtag(snapshot, kind, filterKey);
+  if (etag && requestMatchesEtag(req, etag)) {
+    res.writeHead(304, {
+      ...securityHeaders("application/json; charset=utf-8"),
+      ...sessionCacheHeaders(etag)
+    });
+    res.end();
+    return true;
+  }
+  const payload = compute(snapshot);
+  writeJsonResponse(res, payload, 200, { headers: sessionCacheHeaders(etag) });
+  return true;
+}
+
+function memoizedStatsPayload(snapshot, filters, env) {
+  const filterKey = filterShapeKey({ ...filters, limit: 0 });
+  const cacheKey = `${snapshot.fingerprint}|${filterKey}`;
+  const cached = _statsPayloadCache.get(cacheKey);
+  if (cached) {
+    // Refresh LRU position so frequently-used payloads don't get evicted by
+    // less-used filter combinations.
+    _statsPayloadCache.delete(cacheKey);
+    _statsPayloadCache.set(cacheKey, cached);
+    return cached;
+  }
+  const payload = statsPayload(filters, env);
+  _statsPayloadCache.set(cacheKey, payload);
+  while (_statsPayloadCache.size > STATS_PAYLOAD_CACHE_LIMIT) {
+    const oldest = _statsPayloadCache.keys().next().value;
+    _statsPayloadCache.delete(oldest);
+  }
+  return payload;
+}
+
 function writeJsonResponse(res, payload, status = 200, options = {}) {
   res.writeHead(status, {
     ...securityHeaders("application/json; charset=utf-8"),
@@ -3451,6 +3975,469 @@ function writeJsonResponse(res, payload, status = 200, options = {}) {
   res.end(options.pretty ? JSON.stringify(payload, null, 2) : JSON.stringify(payload));
 }
 
+function serveSessionAttachment(res, params, env = process.env) {
+  let resolved;
+  try {
+    resolved = resolveSessionAttachmentFile(params, env);
+  } catch (error) {
+    writeJsonResponse(res, { error: error.message }, 404);
+    return;
+  }
+  let stat;
+  try {
+    stat = fs.statSync(resolved.file);
+  } catch (error) {
+    if (resolved.cleanup) resolved.cleanup();
+    writeJsonResponse(res, { error: error.message }, 404);
+    return;
+  }
+  const headers = {
+    ...securityHeaders(resolved.contentType || "application/octet-stream"),
+    "cache-control": "private, max-age=3600",
+    "content-length": String(stat.size),
+    "content-disposition": contentDispositionInline(resolved.name || path.basename(resolved.file))
+  };
+  res.writeHead(200, headers);
+  const stream = fs.createReadStream(resolved.file);
+  let cleaned = false;
+  const cleanup = () => {
+    if (cleaned) return;
+    cleaned = true;
+    if (resolved.cleanup) resolved.cleanup();
+  };
+  stream.on("error", (error) => {
+    cleanup();
+    res.destroy(error);
+  });
+  stream.on("close", cleanup);
+  res.on("close", cleanup);
+  stream.pipe(res);
+}
+
+function contentDispositionInline(name) {
+  const safe = String(name || "attachment")
+    .replace(/[\\/\r\n"]/g, "_")
+    .slice(0, 180) || "attachment";
+  return `inline; filename="${safe}"`;
+}
+
+function resolveSessionAttachmentFile(params, env = process.env, options = {}) {
+  const sessionId = paramValue(params, "id");
+  const messageNumber = Number(paramValue(params, "message"));
+  const attachmentNumber = Number(paramValue(params, "attachment"));
+  if (!sessionId) throw new Error("missing session id");
+  if (!Number.isInteger(messageNumber) || messageNumber < 0) throw new Error("missing message index");
+  if (!Number.isInteger(attachmentNumber) || attachmentNumber < 0) throw new Error("missing attachment index");
+  const session = findSessionById(sessionId, env);
+  if (!session) throw new Error(`no archived session found for ${sessionId}`);
+  const messages = readTranscript(session.transcriptPath);
+  const message = messages.find((item) => Number(item?.index) === messageNumber) || messages[messageNumber];
+  const attachments = Array.isArray(message?.metadata?.attachments) ? message.metadata.attachments : [];
+  const attachment = attachments[attachmentNumber];
+  if (!attachment) throw new Error("attachment not found");
+  const record = resolveSessionAttachmentRecord(session, message, attachment, attachmentNumber, env, options);
+  if (!record) throw new Error("attachment file was not included in the raw export");
+  return record;
+}
+
+function resolveSessionAttachmentRecord(session, message, attachment, attachmentNumber, env = process.env, options = {}) {
+  const context = attachmentResolutionContext(session, message, attachment, attachmentNumber);
+  const resolved = resolveAttachmentFromRawManifests(session, context, env, options);
+  if (!resolved) return null;
+  return {
+    ...resolved,
+    name: attachment.name || resolved.name,
+    contentType: attachmentContentType(attachment, resolved.name || resolved.file)
+  };
+}
+
+function paramValue(params, key) {
+  if (params && typeof params.get === "function") return params.get(key) || "";
+  return params?.[key] || "";
+}
+
+function attachmentResolutionContext(session, message, attachment, attachmentIndex) {
+  const conversationEntryPath = webRawReferenceEntryPath(session);
+  const conversationDir = conversationEntryPath ? posixDirname(conversationEntryPath) : "";
+  const conversationPart = conversationDir.split("/").filter(Boolean).pop() || "";
+  const assetPointers = Array.isArray(message?.metadata?.assetPointers) ? message.metadata.assetPointers : [];
+  const names = new Set();
+  const ids = new Set();
+  const pointers = new Set();
+  addAttachmentName(names, attachment?.name);
+  addAttachmentId(ids, attachment?.id);
+  addAttachmentId(ids, attachment?.libraryFileId);
+  addAttachmentPointer(pointers, attachment?.assetPointer);
+  if (assetPointers.length === 1 || assetPointers.length === attachmentIndex + 1) {
+    addAttachmentPointer(pointers, assetPointers[attachmentIndex]?.assetPointer);
+  }
+  for (const pointer of pointers) addAttachmentId(ids, pointer);
+  return {
+    attachment,
+    attachmentIndex,
+    names: [...names],
+    ids: [...ids],
+    pointers: [...pointers],
+    conversationEntryPath,
+    conversationDir,
+    conversationPart,
+    isImage: attachmentIsImage(attachment)
+  };
+}
+
+function addAttachmentName(set, value) {
+  const base = posixBasename(String(value || "").trim());
+  if (base) set.add(base);
+}
+
+function addAttachmentId(set, value) {
+  const token = attachmentToken(value);
+  if (token) set.add(token);
+}
+
+function addAttachmentPointer(set, value) {
+  const text = String(value || "").trim();
+  if (text) set.add(text);
+}
+
+function attachmentToken(value) {
+  return posixBasename(String(value || "")
+    .trim()
+    .toLowerCase()
+    .replace(/^file-service:\/\//, "")
+    .replace(/^sandbox:\/\//, "")
+    .replace(/^attachment:\/\//, "")
+    .replace(/[?#].*$/, ""));
+}
+
+function webRawReferenceEntryPath(session) {
+  const ref = (Array.isArray(session?.rawFiles) ? session.rawFiles : [])
+    .find((item) => item?.filename === "web-export-reference" && item.entryPath);
+  return ref?.entryPath || "";
+}
+
+function resolveAttachmentFromRawManifests(session, context, env = process.env, options = {}) {
+  const manifests = webRawExportManifests(session, env);
+  for (const manifest of manifests) {
+    const direct = bestDirectRawAttachment(manifest, context);
+    if (direct) return direct;
+  }
+  for (const manifest of manifests) {
+    const zipped = bestZipRawAttachment(manifest, context, options);
+    if (zipped) return zipped;
+  }
+  return null;
+}
+
+function webRawExportManifests(session, env = process.env) {
+  const manifests = [];
+  for (const raw of Array.isArray(session?.rawFiles) ? session.rawFiles : []) {
+    if (raw?.filename !== "web-export-reference" && !/web export raw manifest/i.test(String(raw?.note || ""))) continue;
+    const manifestPath = raw.archivedPath || "";
+    const manifest = manifestPath ? readJson(manifestPath, null) : null;
+    if (manifest && typeof manifest === "object") manifests.push({ manifest, reference: raw, manifestPath });
+  }
+  const sessionManifestPath = session?.rawPath ? path.join(session.rawPath, "manifest.json") : "";
+  const sessionManifest = sessionManifestPath ? readJson(sessionManifestPath, null) : null;
+  if (sessionManifest && typeof sessionManifest === "object") {
+    manifests.push({ manifest: sessionManifest, reference: null, manifestPath: sessionManifestPath });
+  }
+  return manifests;
+}
+
+function bestDirectRawAttachment(rawManifest, context) {
+  let best = null;
+  for (const file of Array.isArray(rawManifest?.manifest?.files) ? rawManifest.manifest.files : []) {
+    if (!file?.archivedPath || !file.entryPath) continue;
+    if (isZipPath(file.entryPath) || isZipPath(file.archivedPath)) continue;
+    const score = attachmentPathScore(file.entryPath, context);
+    if (score < 100) continue;
+    if (!best || score > best.score) best = { score, file };
+  }
+  if (!best) return null;
+  return {
+    kind: "file",
+    file: best.file.archivedPath,
+    name: posixBasename(best.file.entryPath),
+    entryPath: best.file.entryPath
+  };
+}
+
+function bestZipRawAttachment(rawManifest, context, options = {}) {
+  let best = null;
+  for (const container of zipContainersForManifest(rawManifest)) {
+    const match = bestZipContainerAttachment(container, context);
+    if (!match) continue;
+    if (!best || match.score > best.score) best = match;
+  }
+  if (!best) return null;
+  if (options.probeOnly) {
+    return {
+      kind: "zip-entry",
+      name: best.name,
+      entryPath: best.entryPath,
+      containerPath: best.containerPath
+    };
+  }
+  const extracted = extractZipChainToTemp(best.containerPath, best.chain, best.name);
+  return {
+    kind: "zip-entry",
+    file: extracted.file,
+    cleanup: extracted.cleanup,
+    name: best.name,
+    entryPath: best.entryPath,
+    containerPath: best.containerPath
+  };
+}
+
+function zipContainersForManifest(rawManifest) {
+  const result = [];
+  const seen = new Set();
+  const add = (item, entryPath = "") => {
+    const archivedPath = item?.archivedPath || item?.containerPath || "";
+    if (!archivedPath || !isZipPath(archivedPath) || seen.has(archivedPath)) return;
+    seen.add(archivedPath);
+    result.push({ path: archivedPath, entryPath: entryPath || item.entryPath || item.originalPath || path.basename(archivedPath) });
+  };
+  for (const container of Array.isArray(rawManifest?.manifest?.containers) ? rawManifest.manifest.containers : []) add(container);
+  for (const file of Array.isArray(rawManifest?.manifest?.files) ? rawManifest.manifest.files : []) {
+    if (isZipPath(file?.entryPath || "")) add(file);
+  }
+  return result;
+}
+
+function bestZipContainerAttachment(container, context) {
+  const entries = cachedZipEntries(container.path);
+  const containerPrefix = isZipPath(container.entryPath) ? container.entryPath.replace(/\.zip$/i, "") : container.entryPath;
+  const directZipIsConversationPart = zipEntryMatchesConversationPart(container.entryPath, context);
+  let best = null;
+  for (const entry of entries) {
+    if (!safeZipMemberName(entry)) continue;
+    if (isZipPath(entry)) {
+      if (!openAiConversationExportPath(entry) && !zipEntryMatchesConversationPart(entry, context)) continue;
+      if (context.conversationPart && !zipEntryMatchesConversationPart(entry, context)) continue;
+      const nestedBest = bestNestedZipAttachment(container.path, entry, context);
+      if (nestedBest && (!best || nestedBest.score > best.score)) best = nestedBest;
+      continue;
+    }
+    if (!directZipIsConversationPart && context.conversationPart && openAiConversationExportPath(container.entryPath)) continue;
+    const score = Math.max(
+      attachmentPathScore(entry, context),
+      attachmentPathScore(containerPrefix ? `${containerPrefix}/${entry}` : entry, context)
+    );
+    if (score < 100) continue;
+    if (!best || score > best.score) {
+      best = {
+        score,
+        containerPath: container.path,
+        chain: [entry],
+        entryPath: containerPrefix ? `${containerPrefix}/${entry}` : entry,
+        name: posixBasename(entry)
+      };
+    }
+  }
+  return best;
+}
+
+function bestNestedZipAttachment(containerPath, nestedEntry, context) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "agentlog-zip-list-"));
+  const tempZip = path.join(tempDir, "nested.zip");
+  try {
+    extractZipMemberToFile(containerPath, nestedEntry, tempZip);
+    let best = null;
+    for (const entry of listZipEntries(tempZip)) {
+      if (!safeZipMemberName(entry) || isZipPath(entry)) continue;
+      const nestedPrefix = nestedEntry.replace(/\.zip$/i, "");
+      const score = Math.max(
+        attachmentPathScore(entry, context),
+        attachmentPathScore(`${nestedPrefix}/${entry}`, context)
+      );
+      if (score < 100) continue;
+      if (!best || score > best.score) {
+        best = {
+          score,
+          containerPath,
+          chain: [nestedEntry, entry],
+          entryPath: `${nestedPrefix}/${entry}`,
+          name: posixBasename(entry)
+        };
+      }
+    }
+    return best;
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+const ZIP_ENTRY_CACHE = new Map();
+
+function cachedZipEntries(file) {
+  let stat = null;
+  try {
+    stat = fs.statSync(file);
+  } catch {
+    return [];
+  }
+  const key = `${file}:${stat.size}:${Math.trunc(stat.mtimeMs)}`;
+  if (ZIP_ENTRY_CACHE.has(key)) return ZIP_ENTRY_CACHE.get(key);
+  const entries = listZipEntries(file);
+  ZIP_ENTRY_CACHE.set(key, entries);
+  return entries;
+}
+
+function listZipEntries(file) {
+  const result = spawnSync("unzip", ["-Z1", file], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+  if (result.status !== 0) return [];
+  return result.stdout.split(/\r?\n/).filter(Boolean);
+}
+
+function extractZipChainToTemp(containerPath, chain, name) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "agentlog-attachment-"));
+  let currentZip = containerPath;
+  try {
+    for (let index = 0; index < chain.length; index++) {
+      const entry = chain[index];
+      const last = index === chain.length - 1;
+      const target = path.join(tempDir, last ? `attachment${path.extname(name || entry) || ".bin"}` : `nested-${index}.zip`);
+      extractZipMemberToFile(currentZip, entry, target);
+      currentZip = target;
+    }
+    return {
+      file: currentZip,
+      cleanup: () => fs.rmSync(tempDir, { recursive: true, force: true })
+    };
+  } catch (error) {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    throw error;
+  }
+}
+
+function extractZipMemberToFile(zipPath, entryName, target) {
+  if (!safeZipMemberName(entryName)) throw new Error("unsafe zip entry path");
+  ensureDir(path.dirname(target));
+  const fd = fs.openSync(target, "w", 0o600);
+  try {
+    const result = spawnSync("unzip", ["-p", zipPath, entryName], { stdio: ["ignore", fd, "pipe"] });
+    if (result.status !== 0) {
+      const message = result.stderr ? result.stderr.toString("utf8").trim() : "";
+      throw new Error(`failed to extract attachment${message ? `: ${message}` : ""}`);
+    }
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+function attachmentPathScore(entryPath, context) {
+  const lower = comparableAttachmentPath(entryPath);
+  if (!lower || lower.endsWith("/")) return 0;
+  const base = posixBasename(lower);
+  const baseNoExt = stripExtension(base);
+  let score = 0;
+  if (context.conversationDir && (lower.startsWith(`${context.conversationDir.toLowerCase()}/`) || lower.includes(`/${context.conversationDir.toLowerCase()}/`))) {
+    score += 25;
+  }
+  if (context.conversationPart && lower.includes(context.conversationPart.toLowerCase())) score += 20;
+  for (const name of context.names) {
+    const normalizedName = posixBasename(comparableAttachmentPath(name));
+    const normalizedNameNoExt = stripExtension(normalizedName);
+    if (!normalizedName) continue;
+    if (base === normalizedName || lower.endsWith(`/${normalizedName}`)) score = Math.max(score, 180);
+    else if (baseNoExt === normalizedNameNoExt) score = Math.max(score, 145);
+    else if (normalizedNameNoExt.length >= 6 && baseNoExt.includes(normalizedNameNoExt)) score = Math.max(score, 105);
+  }
+  for (const id of context.ids) {
+    const token = attachmentToken(id);
+    if (!token) continue;
+    if (baseNoExt === token) score = Math.max(score, 175);
+    else if (base.startsWith(`${token}.`) || base.startsWith(`${token}-`) || base.startsWith(`${token}_`)) score = Math.max(score, 165);
+    else if (token.length >= 6 && base.includes(token)) score = Math.max(score, 115);
+  }
+  if (context.isImage && imageExtension(entryPath)) score += 20;
+  if (isArchiveMetadataName(entryPath) && score < 160) return 0;
+  return score;
+}
+
+function comparableAttachmentPath(value) {
+  return String(value || "")
+    .replace(/\\/g, "/")
+    .replace(/[\u00a0\u202f]/g, " ")
+    .replace(/\s+/g, " ")
+    .toLowerCase();
+}
+
+function zipEntryMatchesConversationPart(entryPath, context) {
+  const part = String(context?.conversationPart || "").toLowerCase();
+  if (!part) return false;
+  const withoutZip = String(entryPath || "").replace(/\\/g, "/").replace(/\.zip$/i, "").toLowerCase();
+  return withoutZip === part || withoutZip.endsWith(`/${part}`);
+}
+
+function openAiConversationExportPath(name) {
+  const text = String(name || "");
+  return /(^|\/)Conversations__[^/]*chatgpt[^/]*(?:\/|$)/i.test(text) || /(^|\/)Conversations__[^/]*chatgpt[^/]*\.zip$/i.test(text);
+}
+
+function safeZipMemberName(name) {
+  const text = String(name || "");
+  if (!text || text.includes("\0") || path.isAbsolute(text)) return false;
+  return !text.split(/[\\/]+/).some((part) => part === "..");
+}
+
+function isZipPath(value) {
+  return /\.zip$/i.test(String(value || ""));
+}
+
+function isArchiveMetadataName(value) {
+  return /\.(json|jsonl|ndjson|html?|csv)$/i.test(String(value || ""));
+}
+
+function posixBasename(value) {
+  return String(value || "").replace(/\\/g, "/").split("/").filter(Boolean).pop() || "";
+}
+
+function posixDirname(value) {
+  const parts = String(value || "").replace(/\\/g, "/").split("/").filter(Boolean);
+  parts.pop();
+  return parts.join("/");
+}
+
+function stripExtension(value) {
+  return String(value || "").replace(/\.[^.]+$/, "");
+}
+
+function attachmentIsImage(attachment) {
+  return /^image\//i.test(String(attachment?.mimeType || attachment?.pointerMimeType || "")) ||
+    imageExtension(attachment?.name || "");
+}
+
+function imageExtension(value) {
+  return /\.(png|jpe?g|gif|webp|bmp|tiff?|heic|heif|avif)$/i.test(String(value || ""));
+}
+
+function attachmentContentType(attachment, filename = "") {
+  const explicit = String(attachment?.mimeType || attachment?.pointerMimeType || "").trim();
+  if (/^[A-Za-z0-9!#$&^_.+-]+\/[A-Za-z0-9!#$&^_.+-]+$/.test(explicit)) return explicit;
+  const ext = path.extname(String(filename || attachment?.name || "")).toLowerCase();
+  const types = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".bmp": "image/bmp",
+    ".tif": "image/tiff",
+    ".tiff": "image/tiff",
+    ".heic": "image/heic",
+    ".heif": "image/heif",
+    ".avif": "image/avif",
+    ".pdf": "application/pdf",
+    ".txt": "text/plain",
+    ".csv": "text/csv",
+    ".json": "application/json"
+  };
+  return types[ext] || "application/octet-stream";
+}
+
 function writeUnauthorizedHistoryResponse(res, pathname) {
   if (isHistoryApiPath(pathname)) {
     writeJsonResponse(res, { error: "unauthorized", code: "unauthorized" }, 401);
@@ -3513,7 +4500,7 @@ function serverCommand(flags, env) {
 }
 
 const RECALL_TARGET_SOURCE_MAP = {
-  codex: ["codex-cli", "codex-desktop"],
+  codex: ["codex-cli", "codex-desktop", "codex-sdk"],
   claude: ["claude", "claude-code-desktop", "claude-workspace"],
   gemini: ["gemini-cli"],
   antigravity: ["antigravity"],
@@ -4037,7 +5024,7 @@ function recallArchiveHints() {
   return `- Sessions live under \`~/.agentlog/data/agentlog/sessions/repo=<repo-or-path-key>/provider=<provider>/year=YYYY/month=MM/day=DD/session=<session_id>.conversation.md\`.
 - Git repositories use canonical keys like \`github.com/org/repo\`. Non-git directories may use stable \`path:<hash>\` storage keys, but history results include \`repo_display\` and \`cwd\` with the readable local path.
 - When the user names a repo or folder, add \`--repo "<repo-or-path>"\`; it matches canonical repo keys, \`path:<hash>\`, web scopes, local \`cwd\`, and display labels, so local paths and path fragments work.
-- Useful filters include \`--provider <provider>\`, \`--since 30d\`, and \`--repo "<repo-or-path>"\`. Provider aliases are ordered as OpenAI (\`codex-cli\`, \`codex-desktop\`, \`chatgpt\`), Anthropic (\`claude\`, \`claude-code-desktop\`, \`claude-workspace\`, \`claude-web\`, \`claude-sdk\`), Google (\`gemini-cli\`, \`antigravity\`), then other local tools (\`devin-cli\`, \`cursor\`, \`cline\`, \`opencode\`, \`aider\`).
+- Useful filters include \`--provider <provider>\`, \`--since 30d\`, and \`--repo "<repo-or-path>"\`. Provider aliases are ordered as OpenAI (\`codex-cli\`, \`codex-desktop\`, \`codex-sdk\`, \`chatgpt\`), Anthropic (\`claude\`, \`claude-code-desktop\`, \`claude-workspace\`, \`claude-web\`, \`claude-sdk\`), Google (\`gemini-cli\`, \`antigravity\`), then other local tools (\`devin-cli\`, \`cursor\`, \`cline\`, \`opencode\`, \`aider\`).
 - If the user is asking about the current repository, start without \`--repo\` unless results are noisy; current-repo matches are already weighted higher.`;
 }
 
@@ -4305,6 +5292,10 @@ function printDiscovery(label, result) {
 
 function printImportResults(results, options = {}) {
   for (const result of results) {
+    if (result.instructions) {
+      printWebExportInstructionBlock(result.instructions);
+      continue;
+    }
     const detailText = result.details ? formatDetails(result.details) : "";
     const details = detailText ? ` ${detailText}` : "";
     printCheck(
@@ -4326,6 +5317,37 @@ function printImportResults(results, options = {}) {
   }
 }
 
+function printWebExportInstructions(instructions, flags = {}) {
+  if (!instructions) throw new Error("unknown web export instruction source");
+  if (flags.json) {
+    console.log(JSON.stringify({
+      provider: instructions.provider,
+      source: instructions.source,
+      manual: true,
+      instructions
+    }, null, 2));
+    return;
+  }
+  printPageTitle("agentlog import", `${instructions.source} export instructions`);
+  printWebExportInstructionBlock(instructions);
+}
+
+function printWebExportInstructionBlock(instructions) {
+  printSection(`${instructions.label} Export`);
+  printMuted(`Request and download the ${instructions.fileDescription}, then import it from disk.`);
+  printCheck("Request page", instructions.requestUrl);
+  printCheck("Help", instructions.helpUrl);
+  printSection("Steps");
+  (instructions.steps || []).forEach((step, index) => {
+    console.log(`  ${index + 1}. ${step}`);
+  });
+  if (instructions.notes?.length) {
+    printSection("Notes");
+    for (const note of instructions.notes) console.log(`  - ${note}`);
+  }
+  printCommand("Import after download", instructions.importCommand);
+}
+
 function printPageTitle(title, subtitle = "") {
   if (!process.stdout.isTTY) {
     console.log(title);
@@ -4790,19 +5812,29 @@ async function chooseDataRoot(flags, env) {
 
   printSection("Archive Storage");
   printMuted("Redacted transcripts, metadata, and indexes live in one data directory.");
-  printMuted(`Enter a path relative to ${fullPath(os.homedir())}/, a ~/... path, or an absolute path.`);
+  printMuted("Enter a path relative to ~/, a ~/... path, or an absolute path.");
   printMuted("Press Enter to use the suggested data directory.");
-  const answer = (await ask(`  Data directory [${fullPath(defaultRoot)}]: `)).trim();
+  const answer = (await ask(`  Data directory [${compactPath(defaultRoot)}]: `)).trim();
   return answer ? resolveUserPath(answer) : defaultRoot;
 }
 
-function resolveUserPath(value) {
-  const input = String(value || "").trim();
+function resolveUserPath(value, options = {}) {
+  const input = normalizeUserPathInput(value);
   if (!input) return "";
   if (input === "~") return os.homedir();
   if (input.startsWith("~/")) return path.resolve(os.homedir(), input.slice(2));
   if (path.isAbsolute(input)) return path.resolve(input);
-  return path.resolve(os.homedir(), input);
+  const base = options.base ? path.resolve(options.base) : os.homedir();
+  return path.resolve(base, input);
+}
+
+function normalizeUserPathInput(value) {
+  let input = String(value || "").trim();
+  while (input.length >= 2 && ((input.startsWith("'") && input.endsWith("'")) || (input.startsWith('"') && input.endsWith('"')))) {
+    input = input.slice(1, -1).trim();
+  }
+  input = input.replace(/^['"]+|['"]+$/g, "");
+  return input.replace(/\\([\\ "'()&;<>|\[\]{}?*])/g, "$1");
 }
 
 async function chooseSetupSettings(flags) {
@@ -5089,6 +6121,14 @@ function importSourceOptions(discovered) {
       description: "Codex desktop app conversations from the local Codex state database.",
       defaultSelected: Boolean(discovered.codexDesktop?.sessions)
     },
+    {
+      source: "codex-sdk",
+      label: "Codex SDK jobs",
+      count: discovered.codexSdk?.sessions || 0,
+      summary: sourceSummary(discovered.codexSdk),
+      description: "Codex exec and SDK-style batch runs from the local Codex state database; disabled by default because volume can be high.",
+      defaultSelected: false
+    },
     {
       source: "claude",
       label: "Claude Code CLI",
@@ -5249,10 +6289,10 @@ function createProgressReporter(options = {}) {
     const file = event.path ? ` ${path.basename(event.path).slice(0, 36)}` : "";
     const eventMode = event.kind || mode;
     const label = String(event.provider || "work").padEnd(eventMode === "discovery" ? 16 : 12);
-	const detail =
-	  eventMode === "discovery" || eventMode === "sync"
-	    ? event.message || "scanning"
-	    : `imported=${event.imported || 0} skipped=${event.skipped || 0} errors=${event.errors || 0}`;
+    const detail = event.message
+      || (eventMode === "discovery" || eventMode === "sync"
+        ? "scanning"
+        : `imported=${event.imported || 0} skipped=${event.skipped || 0} errors=${event.errors || 0}`);
     const count = hasTotal ? `${current}/${total}` : `${current}`;
     const line = `${label} [${bar}] ${percent}% ${count} ${detail}${file}`;
     process.stdout.write(`\r${line.padEnd(lastLine.length)}`);
@@ -5514,6 +6554,9 @@ details[open] > summary .folder-icon-open{display:block}
 .session-meta-right .meta-project-block{display:inline-flex;align-items:center;min-width:0;max-width:min(100%,28rem);line-height:1.25}
 .session-meta-right .repo-label-github,.session-meta-right .repo-label-webchat,.session-meta-right .repo-label-plain{min-height:0;line-height:1.25}
 .session-meta-right .repo-label-github .github-repo-icon{width:13px;height:13px}
+.parent-session-link{display:inline-flex;align-items:center;gap:4px;border:1px solid #e2e8f0;background:#fff;color:#334155;border-radius:6px;padding:2px 7px;font:12px/1.25 inherit;font-weight:600;white-space:nowrap;cursor:pointer}
+.parent-session-link:hover{background:#f8fafc;border-color:#cbd5e1}
+.parent-session-link svg{width:13px;height:13px}
 .session-stat.model{max-width:min(400px,46vw);gap:5px}
 .session-model-brand{display:inline-flex;align-items:center;justify-content:center;flex:0 0 auto}
 .session-stat.model .session-model-text{display:inline-block;max-width:100%;overflow:hidden;text-overflow:ellipsis;vertical-align:bottom}
@@ -5600,17 +6643,66 @@ mark.search-match.search-match-current{background:#fde047;color:#422006;box-shad
 .bubble p{margin:0 0 8px;overflow-wrap:anywhere}
 .bubble p:last-child{margin-bottom:0}
 .plain-message{white-space:pre-wrap;overflow-wrap:anywhere}
+.attachment-list{display:grid;gap:8px;margin-top:9px}
+.tool-body + .attachment-list{margin-top:10px}
+.attachment-card{display:grid;grid-template-columns:auto minmax(0,1fr);align-items:center;gap:9px;max-width:min(420px,100%);padding:7px 9px;border:1px solid #e5e7eb;border-radius:8px;background:#fff;color:#334155;text-decoration:none}
+.attachment-card:hover{background:#f8fafc;border-color:#cbd5e1}
+.attachment-card.image{align-items:start}
+.attachment-thumb{display:inline-flex;align-items:center;justify-content:center;width:34px;height:34px;border-radius:7px;background:#f1f5f9;color:#475569;overflow:hidden;flex:0 0 auto}
+.attachment-thumb svg{width:17px;height:17px}
+.attachment-thumb.image{width:96px;height:72px;background:#f8fafc;border:1px solid #eef2f7}
+.attachment-thumb.image img{width:100%;height:100%;object-fit:cover;display:block}
+.attachment-copy{display:grid;gap:1px;min-width:0}
+.attachment-name{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:#172033;font-size:12px;font-weight:600}
+.attachment-meta{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:#64748b;font-size:11px;line-height:1.35}
 .bubble a{color:#2457a6;text-decoration:underline;text-underline-offset:2px}
+.bubble a.attachment-card{color:#334155;text-decoration:none}
 .bubble .inline-code{border:1px solid #e5e7eb;border-radius:4px;background:#f8fafc;padding:1px 4px;font:12px/1.35 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace}
+.citation-chip{display:inline-flex;align-items:center;height:17px;margin:0 1px;padding:0 5px;border-radius:999px;background:#eef2ff;color:#3730a3;font-size:10.5px;font-weight:650;line-height:1;vertical-align:baseline}
 .unsupported-device-block{display:flex;align-items:center;gap:8px;margin:5px 0 7px;padding:7px 9px;border:1px solid #e5e7eb;border-left:3px solid #cbd5e1;border-radius:7px;background:#f8fafc;color:#64748b;font-size:12px;font-weight:500;line-height:1.35}
 .unsupported-device-block:first-child{margin-top:0}
 .unsupported-device-block:last-child{margin-bottom:0}
 .unsupported-device-block:before{content:"";width:6px;height:6px;border-radius:999px;background:#94a3b8;flex:0 0 auto}
 .context-card{margin:4px 0;border:1px solid #e5e7eb;border-left:3px solid #cbd5e1;border-radius:8px;background:#fff;color:#475569;overflow:hidden;transition:border-color .15s ease}
+.context-line{display:flex;align-items:center;gap:8px;min-height:28px;margin:2px 0;color:#64748b;font-size:12px;line-height:1.35}
+.context-line .context-glyph{width:22px;height:22px}
+.context-line .context-title{flex:0 0 auto}
+.context-line .context-meta{flex:1 1 auto}
+.context-line .context-end{margin-left:auto}
+.context-line .message-copy{opacity:1;width:22px;height:22px;color:#94a3b8}
 .session-summary-message{margin-bottom:14px}
 .session-summary-card{border-left-color:#D97757;background:#fff}
 .session-summary-body{padding:11px 13px 12px;color:#334155;font-size:13px;line-height:1.55;background:#fff}
 .session-summary-body .md-heading:first-child{margin-top:0}
+.session-subagents-card{border-left-color:#7c3aed;background:#fff}
+.session-subagent-run-card{border-left-color:#7c3aed;background:#fff}
+.session-subagents-body{padding:0 12px 12px;background:#fff;color:#334155}
+.subagent-section-title{margin:10px 0 2px;color:#64748b;font-size:11px;font-weight:700;text-transform:uppercase;letter-spacing:.04em}
+.subagent-list{display:grid;gap:0}
+.subagent-row{display:grid;gap:5px;padding:10px 0;border-top:1px solid #f1f5f9}
+.subagent-row:first-child{border-top:0}
+.subagent-head{display:flex;align-items:center;gap:6px;min-width:0}
+.subagent-name{font-size:13px;font-weight:650;color:#172033;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.subagent-description{font-size:12.5px;line-height:1.45;color:#475569}
+.subagent-preview{font:12px/1.45 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;color:#64748b;background:#fafbfc;border-radius:6px;padding:7px 8px;white-space:pre-wrap;overflow-wrap:anywhere}
+.subagent-tools{display:flex;flex-wrap:wrap;gap:5px}
+.subagent-chip{display:inline-flex;align-items:center;min-height:17px;max-width:220px;padding:0 6px;border-radius:999px;background:#f1f5f9;color:#475569;font-size:11px;font-weight:500;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.subagent-open{justify-self:start;margin-top:2px;border:1px solid #e2e8f0;background:#fff;color:#334155;border-radius:6px;padding:3px 7px;font:12px/1.2 inherit;cursor:pointer}
+.subagent-open:hover{background:#f8fafc;border-color:#cbd5e1}
+.session-modal{position:fixed;inset:0;z-index:80;display:flex;align-items:center;justify-content:center;padding:28px;background:rgba(15,23,42,.34);backdrop-filter:blur(2px)}
+.session-modal[hidden]{display:none}
+.session-modal-shell{display:flex;flex-direction:column;width:min(960px,calc(100vw - 48px));height:min(82vh,860px);border:1px solid #dbe3ee;border-radius:10px;background:#fff;box-shadow:0 24px 80px rgba(15,23,42,.28);overflow:hidden}
+.session-modal-head{display:flex;align-items:flex-start;justify-content:space-between;gap:14px;padding:13px 15px;border-bottom:1px solid #e5e7eb;background:#fff}
+.session-modal-title{min-width:0}
+.session-modal-title strong{display:block;color:#172033;font-size:15px;line-height:1.25;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.session-modal-meta{display:flex;flex-wrap:wrap;gap:5px;margin-top:5px;color:#64748b;font-size:12px}
+.session-modal-close{display:inline-flex;align-items:center;justify-content:center;flex:0 0 auto;width:30px;height:30px;border:1px solid #e2e8f0;border-radius:7px;background:#fff;color:#475569;cursor:pointer}
+.session-modal-close:hover{background:#f8fafc;border-color:#cbd5e1}
+.session-modal-close-glyph{font-size:16px;font-weight:650;line-height:1}
+.session-modal-body{flex:1 1 auto;min-height:0;overflow:auto;padding:18px 18px 28px;background:#fff}
+.session-modal-body .message{max-width:100%}
+.session-modal-body .bubble{max-width:min(100%,760px)}
+.session-modal-body.inline-empty{display:flex;align-items:center;justify-content:center;color:#64748b}
 .context-card summary{display:grid;grid-template-columns:auto minmax(0,1fr) auto;align-items:center;gap:9px;min-height:38px;padding:7px 10px 7px 11px;cursor:pointer;list-style:none;transition:background .12s ease}
 .context-prefix{display:inline-flex;align-items:center;gap:6px}
 .context-end{display:inline-flex;align-items:center;gap:6px}
@@ -5648,13 +6740,31 @@ mark.search-match.search-match-current{background:#fde047;color:#422006;box-shad
 .md-table{border-collapse:collapse;width:max-content;max-width:100%;font-size:13px}
 .md-table th,.md-table td{border:1px solid #e5e7eb;padding:5px 7px;text-align:left;vertical-align:top}
 .md-table th{background:#f8fafc;font-weight:600}
-.tool-callout{display:flex;align-items:flex-start;gap:10px;margin:0;padding:8px 11px 9px 11px;border:1px solid #e5e7eb;border-radius:8px;background:#fff;color:#0f172a;transition:background .15s ease}
-.tool-callout:hover{background:#fafbfc}
-.tool-stack{display:grid;gap:5px;margin-top:4px}
+.tool-group-card{margin:0;border:0;background:transparent}
+.tool-group-card > summary{display:flex;align-items:center;gap:8px;min-height:28px;margin:0 0 5px;color:#64748b;font-size:13px;font-weight:600;line-height:1.35;cursor:pointer;list-style:none}
+.tool-group-card > summary::-webkit-details-marker{display:none}
+.tool-group-prefix{display:inline-flex;align-items:center;gap:7px;flex:0 0 auto}
+.tool-group-caret{width:0;height:0;border-top:4px solid transparent;border-bottom:4px solid transparent;border-left:5px solid #94a3b8;transition:transform .15s ease}
+.tool-group-card[open] .tool-group-caret{transform:rotate(90deg)}
+.tool-group-title{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.tool-group-card[open] > .tool-stack{gap:0;border:1px solid #e5e7eb;border-radius:8px;background:#fff;overflow:hidden}
+.tool-group-card[open] > .tool-stack > .tool-callout{border:0;border-radius:0;border-bottom:1px solid #eef2f7}
+.tool-group-card[open] > .tool-stack > .tool-callout:last-child{border-bottom:0}
+.tool-group-card[open] > .tool-stack > .tool-callout > summary{min-height:26px;padding:2px 8px}
+.tool-callout{display:block;margin:0;border:1px solid #e5e7eb;border-radius:8px;background:#fff;color:#0f172a;overflow:hidden;transition:border-color .15s ease,background .15s ease}
+.tool-callout > summary{display:flex;align-items:center;gap:7px;min-height:28px;padding:3px 8px;cursor:pointer;list-style:none;transition:background .12s ease}
+.tool-callout > summary::-webkit-details-marker{display:none}
+.tool-callout > summary:before{content:"";flex:0 0 auto;width:0;height:0;border-top:4px solid transparent;border-bottom:4px solid transparent;border-left:5px solid #94a3b8;transition:transform .15s ease}
+.tool-callout[open] > summary:before{transform:rotate(90deg)}
+.tool-callout:hover,.tool-callout[open]{border-color:#dbe3ef}
+.tool-callout > summary:hover{background:#fafbfc}
+.tool-callout[open] > summary{border-bottom:1px solid #f1f5f9}
+.tool-stack{display:grid;gap:3px;margin-top:3px}
 .tool-stack:first-child{margin-top:0}
 .tool-body + .tool-stack{margin-top:8px}
-.tool-glyph{display:inline-flex;align-items:center;justify-content:center;flex:0 0 auto;width:26px;height:26px;border-radius:6px;background:#f1f5f9;color:#475569;border:0}
-.tool-glyph svg{width:14px;height:14px}
+.tool-stack-heading{display:flex;align-items:center;min-height:24px;margin:0 0 1px;color:#64748b;font-size:12px;font-weight:600;line-height:1.35}
+.tool-glyph{display:inline-flex;align-items:center;justify-content:center;flex:0 0 auto;width:22px;height:22px;border-radius:6px;background:#f1f5f9;color:#475569;border:0}
+.tool-glyph svg{width:13px;height:13px}
 .tool-callout.shell .tool-glyph{background:#f1f5f9;color:#334155}
 .tool-callout.edit .tool-glyph{background:#fef3c7;color:#92400e}
 .tool-callout.read .tool-glyph{background:#e0f2fe;color:#075985}
@@ -5663,16 +6773,21 @@ mark.search-match.search-match-current{background:#fde047;color:#422006;box-shad
 .tool-callout.task .tool-glyph{background:#dcfce7;color:#166534}
 .tool-callout.mcp .tool-glyph{background:#ffedd5;color:#9a3412}
 .tool-callout.skill .tool-glyph{background:#e0e7ff;color:#3730a3}
-.tool-copy{display:grid;gap:3px;min-width:0;flex:1 1 auto}
-.tool-title{display:flex;align-items:center;gap:6px;flex-wrap:wrap;font-size:13px;font-weight:600;line-height:1.3;color:#0f172a;letter-spacing:-0.005em}
+.tool-call-line{display:flex;align-items:baseline;gap:5px;min-width:0;flex:1 1 auto}
+.tool-action{flex:0 0 auto;color:#0f172a;font-size:12.5px;font-weight:600;line-height:1.3}
+.tool-subject{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:#475569;font-size:12.5px;font-weight:500;line-height:1.3}
+.tool-callout.shell .tool-subject{font:12px/1.3 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;color:#475569}
+.tool-callout-body{display:grid;gap:6px;min-width:0;padding:6px 8px 8px 12px;background:#fff}
+.tool-call-meta{display:flex;align-items:center;gap:5px;flex-wrap:wrap;min-width:0}
 .tool-chip{display:inline-flex;align-items:center;height:18px;padding:0 7px;border-radius:999px;background:#f1f5f9;color:#475569;border:0;font-size:11px;font-weight:500;letter-spacing:.01em}
 .tool-status{display:inline-flex;align-items:center;height:18px;border-radius:999px;padding:0 7px;background:#f1f5f9;color:#64748b;border:0;font-size:11px;font-weight:600}
 .tool-status.completed{background:#dcfce7;color:#166534}
 .tool-status.pending{background:#fef9c3;color:#854d0e}
 .tool-status.failed,.tool-status.error{background:#fee2e2;color:#991b1b}
-.tool-detail{color:#475569;font-size:12px;line-height:1.4;overflow-wrap:anywhere}
-.tool-target{display:block;margin-top:3px;color:#64748b;font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:11px}
-.tool-preview{display:block;color:#1e293b;font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:12px;white-space:pre-wrap;overflow-wrap:anywhere}
+.tool-preview{display:block;margin:0;padding:6px 7px;border:1px solid #edf2f7;border-radius:7px;background:#fafbfc;color:#1e293b;overflow-x:hidden;overflow-y:visible;font:12px/1.4 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;white-space:pre-wrap;overflow-wrap:anywhere;word-break:break-word}
+.tool-paired-result{display:grid;gap:4px;min-width:0}
+.tool-result-meta{display:flex;align-items:center;gap:8px;min-width:0;color:#64748b;font-size:11px;font-weight:600}
+.tool-result-meta span{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
 .tool-diff{display:block;margin-top:6px;border:1px solid #e5e7eb;border-radius:6px;background:#fff;overflow:hidden;font:12px/1.55 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace}
 .tool-diff[open] .tool-diff-summary{border-bottom:1px solid #f1f5f9}
 .tool-diff-summary{display:flex;align-items:center;gap:8px;min-height:28px;padding:4px 10px;cursor:pointer;color:#475569;font-size:11px;font-weight:600;list-style:none;background:#fafbfc}
@@ -5681,24 +6796,28 @@ mark.search-match.search-match-current{background:#fde047;color:#422006;box-shad
 .tool-diff[open] .tool-diff-summary:before{transform:rotate(90deg)}
 .tool-diff-summary .add-count{color:#16a34a}
 .tool-diff-summary .del-count{color:#dc2626}
-.tool-diff-body{display:block;max-height:360px;overflow:auto;background:#f8fafc}
+.tool-diff-body{display:block;overflow-x:hidden;overflow-y:visible;background:#f8fafc}
 .tool-diff-block{display:block}
 .tool-diff-block + .tool-diff-block{border-top:1px solid #e5e7eb;margin-top:4px;padding-top:4px}
-.tool-diff-line{display:block;padding:0 10px;white-space:pre-wrap;overflow-wrap:anywhere;color:#0f172a}
+.tool-diff-line{display:block;padding:0 10px;white-space:pre-wrap;overflow-wrap:anywhere;word-break:break-word;color:#0f172a}
 .tool-diff-line.add{background:#e6ffec;color:#1a7f37}
 .tool-diff-line.del{background:#ffebe9;color:#a40e26}
 .tool-diff-line.ctx{color:#6b7280}
 .tool-diff-line.meta{color:#6b7280;font-weight:600;background:#f1f5f9}
 .tool-diff-line.hunk{color:#7c3aed;background:#faf5ff;font-weight:600}
 .tool-result{margin:0;border:1px solid #e5e7eb;border-radius:8px;background:#fff;overflow:hidden}
+.tool-result.inline{margin-top:1px;border-radius:7px;background:#f8fafc}
 .tool-result summary{display:flex;align-items:center;gap:8px;min-height:34px;padding:6px 10px 6px 11px;cursor:pointer;color:#0f172a;font-weight:600;list-style:none;transition:background .12s ease}
+.tool-result.inline summary{min-height:30px;padding:5px 9px;background:#fafbfc}
 .tool-result summary:hover{background:#fafbfc}
+.tool-result.inline summary:hover{background:#f1f5f9}
 .tool-result[open] summary{border-bottom:1px solid #f1f5f9}
 .tool-result summary::-webkit-details-marker{display:none}
 .tool-result summary:before{content:"";flex:0 0 auto;width:0;height:0;border-top:4px solid transparent;border-bottom:4px solid transparent;border-left:5px solid #94a3b8;transition:transform .15s ease}
 .tool-result[open] summary:before{transform:rotate(90deg)}
 .tool-result-kind{display:inline-flex;align-items:center;gap:7px;font-size:13px;font-weight:600;color:#0f172a;letter-spacing:-0.005em;flex:0 0 auto;white-space:nowrap}
-.tool-result-kind .tool-glyph{width:22px;height:22px;border-radius:6px}
+.tool-result-kind .tool-glyph{width:20px;height:20px;border-radius:6px}
+.tool-result.inline .tool-result-kind .tool-glyph{width:20px;height:20px}
 .tool-result-kind .tool-glyph svg{width:12px;height:12px}
 .tool-result[data-category="shell"] .tool-result-kind .tool-glyph{background:#f1f5f9;color:#334155}
 .tool-result[data-category="edit"] .tool-result-kind .tool-glyph{background:#fef3c7;color:#92400e}
@@ -5709,7 +6828,12 @@ mark.search-match.search-match-current{background:#fde047;color:#422006;box-shad
 .tool-result[data-category="mcp"] .tool-result-kind .tool-glyph{background:#ffedd5;color:#9a3412}
 .tool-result-detail{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:#64748b;font-size:12px;font-weight:500}
 .tool-result-count{margin-left:auto;flex:0 0 auto;color:#94a3b8;font-size:11px;font-weight:600;letter-spacing:.01em;white-space:nowrap}
-.tool-output{max-width:100%;max-height:520px;margin:0;padding:10px 12px;background:#f8fafc;color:#0f172a;overflow:auto;font:12px/1.55 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;white-space:pre}
+.tool-output{max-width:100%;margin:0;padding:6px 7px;background:#f8fafc;color:#0f172a;overflow-x:hidden;overflow-y:visible;font:12px/1.45 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;white-space:pre-wrap;overflow-wrap:anywhere;word-break:break-word}
+.tool-result.inline .tool-output{background:#fff}
+.tool-output-lines{display:grid;gap:0;padding:5px 0}
+.tool-output-line{display:grid;grid-template-columns:minmax(2.4em,max-content) minmax(0,1fr);gap:10px;min-width:0;padding:0 7px}
+.tool-line-number{color:#94a3b8;text-align:right;user-select:none}
+.tool-line-text{min-width:0;white-space:pre-wrap;overflow-wrap:anywhere;word-break:break-word}
 .skill-link{display:inline-flex;align-items:center;gap:4px;max-width:100%;vertical-align:middle;border:1px solid #c7d2fe;border-radius:999px;background:#eef2ff;color:#1e1b4b;padding:1px 7px 2px;font-size:.93em;line-height:1.35;white-space:nowrap}
 .skill-mark{font:700 11px/1 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;color:#4338ca}
 .skill-name,.skill-path{min-width:0;overflow:hidden;text-overflow:ellipsis}
@@ -5750,6 +6874,7 @@ mark.search-match.search-match-current{background:#fde047;color:#422006;box-shad
               <button class="select-option active" type="button" data-value="">All sources</button>
 	              <button class="select-option" type="button" data-value="codex-cli">Codex CLI</button>
 	              <button class="select-option" type="button" data-value="codex-desktop">Codex Desktop</button>
+	              <button class="select-option" type="button" data-value="codex-sdk">Codex SDK jobs</button>
 	              <button class="select-option" type="button" data-value="chatgpt">ChatGPT</button>
 	              <button class="select-option" type="button" data-value="claude">Claude Code CLI</button>
 	              <button class="select-option" type="button" data-value="claude-code-desktop">Claude Code Desktop</button>
@@ -5850,6 +6975,18 @@ mark.search-match.search-match-current{background:#fde047;color:#422006;box-shad
     <button id="jumpEnd" class="jump-end" type="button" title="Jump to end" hidden><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M12 5v14"/><path d="m19 12-7 7-7-7"/></svg></button>
   </section>
 </main>
+<div id="sessionModal" class="session-modal" hidden role="dialog" aria-modal="true" aria-labelledby="sessionModalTitle">
+  <div class="session-modal-shell">
+    <div class="session-modal-head">
+      <div class="session-modal-title">
+        <strong id="sessionModalTitle">Subagent transcript</strong>
+        <div id="sessionModalMeta" class="session-modal-meta"></div>
+      </div>
+      <button id="sessionModalClose" class="session-modal-close" type="button" aria-label="Close subagent transcript"><span class="session-modal-close-glyph" aria-hidden="true">X</span></button>
+    </div>
+    <div id="sessionModalBody" class="session-modal-body"></div>
+  </div>
+</div>
 <section id="statsPane" class="stats-pane" aria-label="Stats">
   <div class="stats-metrics" id="statsMetrics"></div>
   <div class="stats-section">
@@ -5879,6 +7016,11 @@ mark.search-match.search-match-current{background:#fde047;color:#422006;box-shad
       <div id="statsChatActivitySub" class="stats-card-meta" hidden></div>
       <div id="statsChatHeatmap" class="stats-heatmap-wrap"></div>
     </div>
+    <div class="stats-card stats-card--compact">
+      <div class="stats-card-title">SDK jobs</div>
+      <div id="statsSdkActivitySub" class="stats-card-meta" hidden></div>
+      <div id="statsSdkHeatmap" class="stats-heatmap-wrap"></div>
+    </div>
   </div>
   <div class="stats-section">
     <div class="stats-section-head stats-section-head--breakdown">
@@ -5940,6 +7082,11 @@ const copyDetailsButton = document.getElementById('copyDetailsButton');
 const copyResumeButton = document.getElementById('copyResumeButton');
 const copyDetailsWrap = document.getElementById('copyDetailsWrap');
 const copyResumeWrap = document.getElementById('copyResumeWrap');
+const sessionModal = document.getElementById('sessionModal');
+const sessionModalTitle = document.getElementById('sessionModalTitle');
+const sessionModalMeta = document.getElementById('sessionModalMeta');
+const sessionModalBody = document.getElementById('sessionModalBody');
+const sessionModalClose = document.getElementById('sessionModalClose');
 const form = document.getElementById('filters');
 const queryInput = document.getElementById('q');
 
@@ -5957,6 +7104,7 @@ const repoOffsets = new Map();
 let currentSessionId = '';
 let currentSessionPayload = null;
 let viewMode = 'readable';
+let viewScrollRestoreSerial = 0;
 let sidebarWidth = 390;
 let activeSearchTerm = '';
 let pendingSessionId = '';
@@ -6033,7 +7181,7 @@ function brandIconSvg(kind, className) {
 
 function brandKeyForSourceValue(value) {
   const key = String(value || '').trim().toLowerCase();
-  if (['codex-cli', 'codex-desktop', 'chatgpt'].includes(key)) return 'openai';
+  if (['codex-cli', 'codex-desktop', 'codex-sdk', 'chatgpt'].includes(key)) return 'openai';
   if (['claude', 'claude-code-desktop', 'claude-workspace', 'claude-web', 'claude-sdk'].includes(key)) return 'claude';
   if (['gemini-cli', 'antigravity'].includes(key)) return 'gemini';
   if (key === 'devin-cli') return 'devin';
@@ -6360,8 +7508,8 @@ function companyColor(company) {
 }
 
 const MODEL_COLOR_PALETTES = {
-  openai:      { family: 'openai', light: '#7DD3FC', base: '#0284C7', dark: PROVIDER_COLORS.codex, darker: '#4F46E5', top: '#3730A3' },
-  claude:      { family: 'claude', light: '#FDBA74', base: '#F97316', dark: PROVIDER_COLORS.claude_code, darker: '#B45309', top: '#7F1D1D' },
+  openai:      { family: 'openai', light: '#BAE6FD', base: '#06B6D4', dark: PROVIDER_COLORS.codex, darker: '#1D4ED8', top: '#172554' },
+  claude:      { family: 'claude', light: '#FED7AA', base: '#FB923C', dark: PROVIDER_COLORS.claude_code, darker: '#9A3412', top: '#831843' },
   gemini:      { family: 'gemini', light: '#C4B5FD', base: PROVIDER_COLORS.gemini_cli, dark: '#7E22CE', darker: '#581C87' },
   devin:       { family: 'devin', light: '#5EEAD4', base: PROVIDER_COLORS.devin, dark: '#0F766E', darker: '#115E59' },
   cursor:      { family: 'cursor', light: '#475569', base: PROVIDER_COLORS.cursor, dark: '#020617', darker: '#020617' },
@@ -6409,6 +7557,9 @@ function modelCapabilityColor(text, palette) {
 }
 
 function openAiModelColor(text, palette) {
+  if (text.includes('gpt-5.5') || text.includes('gpt-5-5')) return palette.top;
+  if (text.includes('gpt-5.4') || text.includes('gpt-5-4')) return palette.darker;
+  if (text.includes('gpt-5.3') || text.includes('gpt-5-3')) return palette.dark;
   if (text.includes('gpt-5.1') || text.includes('gpt-5-1')) return palette.top;
   if (text.includes('gpt-5') || modelHasToken(text, ['o3'])) return palette.darker;
   if (text.includes('gpt-4.1') || modelHasToken(text, ['o4'])) return palette.dark;
@@ -6417,10 +7568,12 @@ function openAiModelColor(text, palette) {
 }
 
 function claudeModelColor(text, palette) {
-  if (text.includes('high-thinking') || text.includes('high_thinking')) return palette.top;
-  if (modelHasToken(text, ['opus'])) return palette.darker;
-  if (modelHasToken(text, ['sonnet'])) return palette.dark;
   if (modelHasToken(text, ['haiku'])) return palette.light;
+  if (text.includes('claude-4.6') && modelHasToken(text, ['opus'])) return palette.top;
+  if (text.includes('claude-4.5') && modelHasToken(text, ['opus'])) return palette.darker;
+  if (text.includes('high-thinking') || text.includes('high_thinking')) return palette.darker;
+  if (modelHasToken(text, ['opus'])) return palette.dark;
+  if (modelHasToken(text, ['sonnet'])) return palette.base;
   return palette.base;
 }
 
@@ -6429,6 +7582,91 @@ function modelHasToken(text, tokens) {
   return new RegExp('(^|[^a-z0-9])(' + escaped + ')([^a-z0-9]|$)').test(text);
 }
 
+const CANONICAL_COMPANY_ORDER = ['openai', 'anthropic', 'google', 'cognition', 'cursor', 'stealth', 'unknown'];
+const CANONICAL_PROVIDER_ORDER = ['codex', 'chatgpt', 'claude_code', 'claude_desktop', 'claude_sdk', 'claude_web', 'gemini_cli', 'antigravity', 'devin', 'windsurf', 'cursor', 'cline', 'opencode', 'aider', 'unknown'];
+
+function canonicalCompanyRank(company) {
+  const idx = CANONICAL_COMPANY_ORDER.indexOf(String(company || '').toLowerCase());
+  return idx < 0 ? CANONICAL_COMPANY_ORDER.length : idx;
+}
+
+function canonicalProviderRank(provider) {
+  const idx = CANONICAL_PROVIDER_ORDER.indexOf(String(provider || '').toLowerCase());
+  return idx < 0 ? CANONICAL_PROVIDER_ORDER.length : idx;
+}
+
+function companyForModel(text) {
+  const value = String(text || '').toLowerCase();
+  if (value.startsWith('composer-') || value.startsWith('cursor-') || value === 'auto' || value === 'default') return 'cursor';
+  const palette = modelFamilyPalette(value);
+  if (!palette) return 'unknown';
+  if (palette.family === 'openai') return 'openai';
+  if (palette.family === 'claude') return 'anthropic';
+  if (palette.family === 'gemini' || palette.family === 'antigravity') return 'google';
+  if (palette.family === 'devin' || palette.family === 'windsurf') return 'cognition';
+  if (palette.family === 'cursor') return 'cursor';
+  return 'unknown';
+}
+
+function canonicalModelRank(model) {
+  const text = String(model || '').toLowerCase();
+  const company = companyForModel(text);
+  const companyRank = canonicalCompanyRank(company);
+  let withinRank = 950;
+  if (company === 'openai') {
+    if (modelHasToken(text, ['nano'])) withinRank = 920;
+    else if (modelHasToken(text, ['mini'])) withinRank = 900;
+    else if (text.includes('gpt-4') && !text.includes('gpt-4.1')) withinRank = 700;
+    else if (text.includes('gpt-4.1')) withinRank = 600;
+    else if (modelHasToken(text, ['o1'])) withinRank = 590;
+    else if (modelHasToken(text, ['o3', 'o4'])) withinRank = 580;
+    else if (text.includes('gpt-5.5') || text.includes('gpt-5-5')) withinRank = 100;
+    else if (text.includes('gpt-5.4') || text.includes('gpt-5-4')) withinRank = 200;
+    else if (text.includes('gpt-5.3') || text.includes('gpt-5-3')) withinRank = 300;
+    else if (text.includes('gpt-5.1') || text.includes('gpt-5-1')) withinRank = 400;
+    else if (text.includes('gpt-5')) withinRank = 500;
+  } else if (company === 'anthropic') {
+    if (modelHasToken(text, ['haiku'])) withinRank = 920;
+    else if (text.includes('opus-4-7') || text.includes('claude-4.7')) withinRank = 100;
+    else if (text.includes('claude-4.6') && modelHasToken(text, ['opus'])) withinRank = 200;
+    else if (text.includes('claude-4.5') && modelHasToken(text, ['opus'])) withinRank = 300;
+    else if (text.includes('claude-4') && modelHasToken(text, ['opus'])) withinRank = 400;
+    else if (modelHasToken(text, ['opus'])) withinRank = 500;
+    else if (text.includes('claude-4.5') && modelHasToken(text, ['sonnet'])) withinRank = 600;
+    else if (text.includes('claude-4') && modelHasToken(text, ['sonnet'])) withinRank = 700;
+    else if (modelHasToken(text, ['sonnet'])) withinRank = 800;
+  } else if (company === 'google') {
+    // Major version dictates the bucket (newer first); flash variants get +50 within their generation.
+    let base = 700;
+    if (text.includes('gemini-3')) base = 100;
+    else if (text.includes('gemini-2')) base = 300;
+    else if (text.includes('gemini-1.5')) base = 500;
+    else if (text.includes('gemini-1')) base = 600;
+    let modifier = 0;
+    if (text.includes('flash-lite')) modifier = 80;
+    else if (text.includes('flash')) modifier = 50;
+    withinRank = base + modifier;
+  } else if (company === 'cursor') {
+    if (text === 'composer-1.5') withinRank = 100;
+    else if (text === 'composer-1') withinRank = 200;
+    else if (text.startsWith('composer-')) withinRank = 300;
+    else if (text === 'auto') withinRank = 700;
+    else if (text === 'default') withinRank = 800;
+    else if (text.startsWith('cursor-')) withinRank = 600;
+  }
+  return companyRank * 10000 + withinRank;
+}
+
+function canonicalGroupRank(group) {
+  if (statsBreakdownMode === 'model') return canonicalModelRank(group);
+  if (statsBreakdownMode === 'company') return canonicalCompanyRank(group);
+  return canonicalProviderRank(group);
+}
+
+function statsCanonicalOrderedGroups(groups) {
+  return [...groups].sort((a, b) => canonicalGroupRank(a) - canonicalGroupRank(b) || String(a).localeCompare(String(b)));
+}
+
 function statsBreakdownLabel(group) {
   if (statsBreakdownMode === 'model') return modelLabel(group);
   if (statsBreakdownMode === 'company') return companyLabel(group);
@@ -6506,6 +7744,7 @@ function formatTokenCount(value) {
 function usageTokenSummary(usage) {
   if (!usage || typeof usage !== 'object') return { inputTokens: 0, outputTokens: 0, totalTokens: 0, extraTokens: 0, estimated: false };
   const estimated = usage.estimated === true || usage.estimated === 'true';
+  const authoritativeTotalTokens = usage.authoritativeTotalTokens === true || usage.authoritative_total_tokens === true;
   const inputTokens = positiveTokenNumber(firstUsageNumber(
     usage.inputTokens,
     usage.input_tokens,
@@ -6545,22 +7784,36 @@ function usageTokenSummary(usage) {
     firstUsageNumber(usage.cachedContentTokenCount, usage.cached_content_token_count),
     firstUsageNumber(usage.cachedTokens, usage.cached_tokens, usage.cacheTokens, usage.cache_tokens, usage.cached)
   );
+  const cacheInputTokensIncludedInInput =
+    usage.cacheInputTokensIncludedInInput === true ||
+    usage.cache_input_tokens_included_in_input === true ||
+    usage.cacheReadTokensIncludedInInput === true ||
+    usage.cache_read_tokens_included_in_input === true;
+  const countedCacheInputTokens = cacheInputTokensIncludedInInput ? 0 : cacheInputTokens;
   const reasoningOutputTokens = sumPositiveTokenNumbers(
     firstUsageNumber(usage.reasoningOutputTokens, usage.reasoning_output_tokens),
     firstUsageNumber(usage.thoughtsTokens, usage.thoughts_tokens, usage.thoughtsTokenCount, usage.thoughts_token_count),
     firstUsageNumber(usage.reasoningTokens, usage.reasoning_tokens, usage.reasoningTokenCount, usage.reasoning_token_count)
   );
+  const reasoningOutputTokensIncludedInOutput =
+    usage.reasoningOutputTokensIncludedInOutput === true ||
+    usage.reasoning_output_tokens_included_in_output === true ||
+    usage.reasoningTokensIncludedInOutput === true ||
+    usage.reasoning_tokens_included_in_output === true;
+  const countedReasoningOutputTokens = reasoningOutputTokensIncludedInOutput ? 0 : reasoningOutputTokens;
   const toolUsePromptTokens = sumPositiveTokenNumbers(
     firstUsageNumber(usage.toolUsePromptTokens, usage.tool_use_prompt_tokens, usage.toolUsePromptTokenCount, usage.tool_use_prompt_token_count)
   );
-  const extraTokens = cacheInputTokens + reasoningOutputTokens + toolUsePromptTokens;
+  const extraTokens = countedCacheInputTokens + countedReasoningOutputTokens + toolUsePromptTokens;
   const splitTokens = inputTokens + outputTokens;
   const cumulativeTokens = totalInputTokens + totalOutputTokens;
   const categoryTokens = splitTokens + extraTokens;
-  const totalTokens = explicitTotalTokens || categoryTokens
-    ? Math.max(explicitTotalTokens, categoryTokens)
-    : cumulativeTokens;
-  return { inputTokens, outputTokens, cacheInputTokens, reasoningOutputTokens, toolUsePromptTokens, totalTokens, extraTokens, estimated };
+  const totalTokens = authoritativeTotalTokens && explicitTotalTokens
+    ? explicitTotalTokens
+    : explicitTotalTokens || categoryTokens
+      ? Math.max(explicitTotalTokens, categoryTokens)
+      : cumulativeTokens;
+  return { inputTokens, outputTokens, cacheInputTokens, countedCacheInputTokens, cacheInputTokensIncludedInInput, reasoningOutputTokens, countedReasoningOutputTokens, reasoningOutputTokensIncludedInOutput, toolUsePromptTokens, totalTokens, extraTokens, authoritativeTotalTokens, estimated };
 }
 
 function firstUsageNumber() {
@@ -6760,11 +8013,15 @@ function sessionDisplayTitle(payload) {
 
 function renderTree(payload, options) {
   const opts = options || {};
+  const sourceFilterReset = updateSourceFilterOptions(payload.available_source_options || []);
   treeTitle.textContent = 'Sessions';
   treeCount.textContent = String(payload.count || 0);
   tree.innerHTML = '';
   if (sidebarHead) sidebarHead.classList.remove('tree-scrolled');
   repoOffsets.clear();
+  if (sourceFilterReset && !opts.skipSourceReload) {
+    window.setTimeout(() => loadTree({ skipSourceReload: true }).catch((error) => { setEmptySession(error.message); }), 0);
+  }
   if (!payload.groups || !payload.groups.length) {
     tree.innerHTML = '<div class="inline-empty">No archived sessions matched these filters.</div>';
     if (!opts.skipAutoLoad) setEmptySession('No archived sessions matched these filters.');
@@ -7064,6 +8321,14 @@ function renderSession(payload) {
   if (sessionMetaRight) {
     const innerParts = [];
     if (payload.source_type) innerParts.push('<span class="meta-source">' + esc(sourceTypeLabel(payload.provider, payload.source_type)) + '</span>');
+    if (payload.parent_composer_id) {
+      if (innerParts.length) innerParts.push('<span class="meta-dot" aria-hidden="true">\u00b7</span>');
+      innerParts.push(
+        '<button class="parent-session-link" type="button" data-parent-session="' + esc(payload.parent_composer_id) + '" title="Open parent session">' +
+        '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="m12 19-7-7 7-7"/><path d="M19 12H5"/></svg>' +
+        '<span>Parent session</span></button>'
+      );
+    }
     const repoRaw = payload.repo_display || payload.repo || payload.scope || '';
     if (repoRaw) {
       if (innerParts.length) innerParts.push('<span class="meta-dot" aria-hidden="true">\u00b7</span>');
@@ -7079,7 +8344,16 @@ function renderSession(payload) {
     sessionMetaRight.innerHTML = innerParts.length
       ? '<div class="session-meta-right-inner">' + innerParts.join('') + '</div>'
       : '';
+    const parentLink = sessionMetaRight.querySelector('[data-parent-session]');
+    if (parentLink) {
+      parentLink.addEventListener('click', (event) => {
+        event.preventDefault();
+        event.stopPropagation();
+        loadSession(parentLink.getAttribute('data-parent-session') || '', { preserveCurrent: true });
+      });
+    }
     const titleBits = [];
+    if (payload.parent_composer_id) titleBits.push('Parent session: ' + payload.parent_composer_id);
     if (payload.time_status === 'recovered-time-unknown') titleBits.push('Recovered time unknown');
     else if (payload.started_at) titleBits.push('Started ' + formatWhen(payload.started_at));
     if (payload.session_id) titleBits.push('Session ID: ' + payload.session_id);
@@ -7108,7 +8382,7 @@ function renderSession(payload) {
   );
   copyResumeButton.classList.remove('copied');
   jumpEnd.hidden = false;
-  setView(viewMode);
+  setView(viewMode, { preserveScroll: false });
   for (const button of tree.querySelectorAll('.session-node')) {
     button.classList.toggle('active', button.dataset.id === payload.session_id);
   }
@@ -7126,16 +8400,20 @@ function renderMessages(messages, sessionSummary) {
   readableView.className = '';
   readableView.innerHTML = '';
   const summaryText = sessionSummaryText(sessionSummary);
+  const subagentsElement = sessionSubagentsElement(sessionSummary);
+  const subagentRunItems = subagentRunTimelineItems(sessionSummary);
   const visibleMessages = summaryText
     ? (messages || []).filter((message) => message?.metadata?.summaryKind !== 'conversation_summary')
     : (messages || []);
-  if (!visibleMessages.length && !summaryText) {
+  const renderItems = mergeTimelineRenderItems(pairedToolRenderItems(visibleMessages), subagentRunItems);
+  if (!renderItems.length && !summaryText && !subagentsElement) {
     readableView.className = 'inline-empty';
     readableView.textContent = 'No transcript messages are available for this session.';
     return;
   }
   const summaryElement = sessionSummaryElement(sessionSummary);
   if (summaryElement) readableView.appendChild(summaryElement);
+  if (subagentsElement) readableView.appendChild(subagentsElement);
   const scheduleNext = typeof window.requestAnimationFrame === 'function'
     ? (fn) => window.requestAnimationFrame(fn)
     : (fn) => window.setTimeout(fn, 0);
@@ -7144,16 +8422,17 @@ function renderMessages(messages, sessionSummary) {
   const renderChunk = () => {
     if (renderSerial !== renderMessagesSerial) return;
     const fragment = document.createDocumentFragment();
-    const end = Math.min(visibleMessages.length, index + MESSAGE_RENDER_CHUNK_SIZE);
+    const end = Math.min(renderItems.length, index + MESSAGE_RENDER_CHUNK_SIZE);
     for (; index < end; index++) {
-      const message = visibleMessages[index];
+      const item = renderItems[index];
+      const message = item.message;
       const gap = renderTimeGap(previousTimestamp, message.timestamp);
       if (gap) fragment.appendChild(gap);
-      fragment.appendChild(messageElement(message));
-      if (message.timestamp) previousTimestamp = message.timestamp;
+      fragment.appendChild(messageElement(message, item));
+      previousTimestamp = item.lastTimestamp || message.timestamp || previousTimestamp;
     }
     readableView.appendChild(fragment);
-    if (index < visibleMessages.length) {
+    if (index < renderItems.length) {
       scheduleNext(renderChunk);
       return;
     }
@@ -7168,6 +8447,204 @@ function renderMessages(messages, sessionSummary) {
   renderChunk();
 }
 
+function mergeTimelineRenderItems(items, extras) {
+  if (!Array.isArray(extras) || !extras.length) return items || [];
+  return [
+    ...(items || []).map((item, index) => ({ ...item, _timelineOrder: index * 2 })),
+    ...extras.map((item, index) => ({ ...item, _timelineOrder: index * 2 + 1 }))
+  ]
+    .sort((left, right) => renderItemTimestampMs(left) - renderItemTimestampMs(right) || left._timelineOrder - right._timelineOrder)
+    .map((item) => {
+      const { _timelineOrder, ...rest } = item;
+      return rest;
+    });
+}
+
+function renderItemTimestampMs(item) {
+  const value = item?.message?.timestamp || item?.lastTimestamp || '';
+  const time = value ? new Date(value).getTime() : NaN;
+  return Number.isFinite(time) ? time : Number.MAX_SAFE_INTEGER;
+}
+
+function pairedToolRenderItems(messages) {
+  const pairings = pairedToolResultIndexes(messages);
+  const skippedResultIndexes = new Set(pairings.duplicateResultIndexes);
+  const result = [];
+  for (let index = 0; index < messages.length; index++) {
+    if (skippedResultIndexes.has(index)) continue;
+    const message = messages[index];
+    const calls = messageToolCalls(message);
+    if (!calls.length) {
+      result.push({ type: 'message', message });
+      continue;
+    }
+    const pairedResults = (pairings.byCallMessage.get(index) || [])
+      .filter((resultIndex) => !skippedResultIndexes.has(resultIndex))
+      .map((resultIndex) => {
+        skippedResultIndexes.add(resultIndex);
+        return messages[resultIndex];
+      });
+    let next = index + 1;
+    while (pairedResults.length < calls.length && next < messages.length && isPairableToolResultMessage(messages[next])) {
+      if (skippedResultIndexes.has(next)) {
+        next += 1;
+        continue;
+      }
+      pairedResults.push(messages[next]);
+      skippedResultIndexes.add(next);
+      next += 1;
+    }
+    if (pairedResults.length) {
+      result.push({
+        type: 'message',
+        message,
+        pairedToolResults: pairedResults,
+        lastTimestamp: pairedResults[pairedResults.length - 1].timestamp || message.timestamp
+      });
+      index = next - 1;
+    } else {
+      result.push({ type: 'message', message });
+    }
+  }
+  return groupConsecutiveToolItems(result);
+}
+
+function groupConsecutiveToolItems(items) {
+  const grouped = [];
+  let run = [];
+  const flush = () => {
+    if (run.length > 1) {
+      grouped.push({
+        type: 'tool-group',
+        message: run[0].message,
+        items: run,
+        lastTimestamp: run[run.length - 1].lastTimestamp || run[run.length - 1].message.timestamp || run[0].message.timestamp
+      });
+    } else if (run.length === 1) {
+      grouped.push(run[0]);
+    }
+    run = [];
+  };
+  for (const item of items) {
+    if (!isToolActivityRenderItem(item)) {
+      flush();
+      grouped.push(item);
+      continue;
+    }
+    run.push(item);
+  }
+  flush();
+  return grouped;
+}
+
+function isToolActivityRenderItem(item) {
+  if (!item || item.type !== 'message') return false;
+  const message = item.message || {};
+  const role = String(message.role || '').toLowerCase();
+  if (role === 'tool') return Boolean(parseToolResult(message.content || '', message));
+  if (role !== 'assistant') return false;
+  const calls = messageToolCalls(message, item.pairedToolResults || []);
+  if (!calls.length) return false;
+  return !stripToolInvocationLines(message.content || '').trim();
+}
+
+function pairedToolResultIndexes(messages) {
+  const calls = [];
+  const callsByEventId = new Map();
+  const callsById = new Map();
+  const callsByKind = new Map();
+  const addCallKey = (map, key, callIndex) => {
+    if (!key) return;
+    if (!map.has(key)) map.set(key, []);
+    map.get(key).push(callIndex);
+  };
+  for (let messagePosition = 0; messagePosition < messages.length; messagePosition++) {
+    const toolCalls = messageToolCalls(messages[messagePosition]);
+    for (const call of toolCalls) {
+      const callIndex = calls.length;
+      calls.push({ messagePosition, call });
+      addCallKey(callsByEventId, call.eventId || '', callIndex);
+      addCallKey(callsById, normalizedToolId(call.id), callIndex);
+      addCallKey(callsByKind, normalizeToolToken(call.kind || call.name || call.title || ''), callIndex);
+    }
+  }
+
+  const resultRecords = preferredToolResultRecords(messages);
+  const byCallMessage = new Map();
+  const usedCalls = new Set();
+  for (const record of resultRecords.records) {
+    const parentEventId = record.event?.parentEventId || '';
+    let callIndex = firstUnusedIndex(callsByEventId.get(parentEventId), usedCalls);
+    if (callIndex < 0) callIndex = firstUnusedIndex(callsById.get(normalizedToolId(record.result.id)), usedCalls);
+    if (callIndex < 0) callIndex = firstUnusedIndex(callsByKind.get(normalizeToolToken(record.result.name || record.result.kind || record.result.title || '')), usedCalls);
+    if (callIndex < 0) continue;
+    usedCalls.add(callIndex);
+    const messagePosition = calls[callIndex].messagePosition;
+    if (!byCallMessage.has(messagePosition)) byCallMessage.set(messagePosition, []);
+    byCallMessage.get(messagePosition).push(record.index);
+  }
+  return { byCallMessage, duplicateResultIndexes: resultRecords.duplicateResultIndexes };
+}
+
+function preferredToolResultRecords(messages) {
+  const records = [];
+  const byId = new Map();
+  const duplicateResultIndexes = new Set();
+  for (let index = 0; index < messages.length; index++) {
+    if (!isPairableToolResultMessage(messages[index])) continue;
+    const result = parseToolResult(messages[index]?.content || '', messages[index]);
+    if (!result) continue;
+    const event = canonicalEventsForMessage(messages[index], 'tool.completed')[0] || null;
+    const record = { index, result, event };
+    records.push(record);
+    const id = normalizedToolId(result.id);
+    if (!id) continue;
+    const existing = byId.get(id);
+    if (!existing) {
+      byId.set(id, record);
+      continue;
+    }
+    const preferred = preferredToolResultRecord(existing, record);
+    const discarded = preferred === existing ? record : existing;
+    duplicateResultIndexes.add(discarded.index);
+    byId.set(id, preferred);
+  }
+  return {
+    records: records.filter((record) => !duplicateResultIndexes.has(record.index)),
+    duplicateResultIndexes
+  };
+}
+
+function preferredToolResultRecord(left, right) {
+  return toolResultDisplayScore(right.result) > toolResultDisplayScore(left.result) ? right : left;
+}
+
+function toolResultDisplayScore(result) {
+  const rawCategory = normalizeToolToken(result?.rawCategory || '');
+  const kind = normalizeToolToken(result?.kind || '');
+  const category = normalizeToolToken(result?.category || '');
+  let score = 0;
+  if (['exec_command_end', 'patch_apply_end', 'mcp_tool_call_end', 'web_search_end', 'tool_result', 'tool_output'].includes(rawCategory)) score += 2000;
+  if (rawCategory === 'function_call_output' || rawCategory === 'custom_tool_call_output') score -= 1000;
+  if (category && category !== 'function') score += 250;
+  if (kind && !kind.startsWith('call_')) score += 150;
+  if (/^\$\s/.test(String(result?.detail || result?.output || ''))) score += 250;
+  score += Math.min(200, String(result?.output || '').length / 200);
+  return score;
+}
+
+function firstUnusedIndex(indexes, used) {
+  if (!Array.isArray(indexes)) return -1;
+  for (const index of indexes) {
+    if (!used.has(index)) return index;
+  }
+  return -1;
+}
+
+function isPairableToolResultMessage(message) {
+  return String(message?.role || '').toLowerCase() === 'tool' && Boolean(parseToolResult(message?.content || '', message));
+}
+
 function sessionSummaryText(sessionSummary) {
   if (!sessionSummary || typeof sessionSummary !== 'object') return '';
   return String(
@@ -7179,48 +8656,284 @@ function sessionSummaryText(sessionSummary) {
   ).trim();
 }
 
-function sessionSummaryElement(sessionSummary) {
-  const text = sessionSummaryText(sessionSummary);
-  if (!text) return null;
+function sessionSummaryElement(sessionSummary) {
+  const text = sessionSummaryText(sessionSummary);
+  if (!text) return null;
+  const row = document.createElement('article');
+  row.className = 'message context session-summary-message';
+  const bubble = document.createElement('div');
+  bubble.className = 'bubble';
+  const details = document.createElement('details');
+  details.className = 'context-card session-summary-card';
+  details.open = true;
+  details.innerHTML =
+    '<summary>' +
+    '<span class="context-prefix"><span class="context-caret"></span><span class="context-glyph">' + contextIconSvg('conversation_summary') + '</span></span>' +
+    '<span class="context-copy"><span class="context-title">Conversation summary</span>' +
+    '<span class="context-meta"><span class="context-chip">' + esc(summarySourceLabel(sessionSummary.source)) + '</span></span></span>' +
+    '<span class="context-end"></span>' +
+    '</summary>';
+  const end = details.querySelector('.context-end');
+  if (end) end.appendChild(messageCopyButton(text));
+  const body = document.createElement('div');
+  body.className = 'session-summary-body';
+  body.innerHTML = renderRichText(text);
+  details.appendChild(body);
+  bubble.appendChild(details);
+  row.appendChild(bubble);
+  return row;
+}
+
+function summarySourceLabel(source) {
+  const value = String(source || '').trim();
+  if (value === 'claude-web-export') return 'Claude.ai export';
+  if (value === 'chatgpt-export') return 'ChatGPT export';
+  if (value) return value.replace(/[-_]+/g, ' ');
+  return 'summary';
+}
+
+function sessionSubagents(sessionSummary) {
+  const definitionValue = sessionSummary && sessionSummary.claudeSubagents;
+  const definitions = definitionValue && typeof definitionValue === 'object' && Array.isArray(definitionValue.definitions)
+    ? definitionValue.definitions.filter((item) => item && item.name)
+    : [];
+  if (!definitions.length) return null;
+  return { ...(definitionValue || {}), definitions };
+}
+
+function sessionSubagentRuns(sessionSummary) {
+  const sources = [
+    { key: 'claudeSubagentRuns', provider: 'claude_code', providerLabel: 'Claude' },
+    { key: 'codexSubagentRuns', provider: 'codex', providerLabel: 'Codex' }
+  ];
+  const runs = [];
+  for (const source of sources) {
+    const runValue = sessionSummary && sessionSummary[source.key];
+    const sourceRuns = runValue && typeof runValue === 'object' && Array.isArray(runValue.runs)
+      ? runValue.runs.filter((item) => item && (item.agentId || item.agentNickname || item.title || item.sessionId))
+      : [];
+    for (const run of sourceRuns) {
+      runs.push({ provider: source.provider, providerLabel: source.providerLabel, ...run });
+    }
+  }
+  if (!runs.length) return null;
+  return { runs };
+}
+
+function subagentRunTimelineItems(sessionSummary) {
+  const runSummary = sessionSubagentRuns(sessionSummary);
+  if (!runSummary) return [];
+  return runSummary.runs.map((run, index) => {
+    const timestamp = run.startedAt || run.endedAt || '';
+    return {
+      type: 'subagent-run',
+      run,
+      message: {
+        role: 'system',
+        content: formatSubagentRunPlainText(run),
+        timestamp,
+        metadata: { provider: run.provider || 'unknown', generatedContext: true, contextKind: 'subagent_run' }
+      },
+      lastTimestamp: run.endedAt || timestamp,
+      _subagentIndex: index
+    };
+  });
+}
+
+function sessionSubagentsElement(sessionSummary) {
+  const subagents = sessionSubagents(sessionSummary);
+  if (!subagents) return null;
+  const definitionCount = Number(subagents.count || subagents.definitions.length) || subagents.definitions.length;
+  const chips = [];
+  if (definitionCount) chips.push(definitionCount + ' definition' + (definitionCount === 1 ? '' : 's'));
+  if (subagents.projectCount) chips.push(subagents.projectCount + ' project');
+  if (subagents.userCount) chips.push(subagents.userCount + ' user');
+  if (Array.isArray(subagents.shadowedNames) && subagents.shadowedNames.length) chips.push(subagents.shadowedNames.length + ' shadowed');
+  const row = document.createElement('article');
+  row.className = 'message context session-subagents-message';
+  const bubble = document.createElement('div');
+  bubble.className = 'bubble';
+  const details = document.createElement('details');
+  details.className = 'context-card session-subagents-card';
+  details.open = true;
+  details.innerHTML =
+    '<summary>' +
+    '<span class="context-prefix"><span class="context-caret"></span><span class="context-glyph">' + contextIconSvg('subagents') + '</span></span>' +
+    '<span class="context-copy"><span class="context-title">Claude subagents</span>' +
+    '<span class="context-meta">' + chips.slice(0, 4).map((chip) => '<span class="context-chip">' + esc(chip) + '</span>').join('') + '</span></span>' +
+    '<span class="context-end"></span>' +
+    '</summary>';
+  const end = details.querySelector('.context-end');
+  if (end) end.appendChild(messageCopyButton(formatSubagentsPlainText(subagents)));
+  const body = document.createElement('div');
+  body.className = 'session-subagents-body';
+  body.innerHTML =
+    '<div class="subagent-list">' +
+    subagents.definitions.map(renderSubagentDefinition).join('') +
+    '</div>';
+  details.appendChild(body);
+  bubble.appendChild(details);
+  row.appendChild(bubble);
+  return row;
+}
+
+function renderSubagentDefinition(definition) {
+  const chips = [];
+  if (definition.scope) chips.push(definition.scope);
+  if (definition.model) chips.push(definition.model);
+  if (definition.relativePath) chips.push(definition.relativePath);
+  const tools = Array.isArray(definition.tools) ? definition.tools : [];
+  return '<div class="subagent-row">' +
+    '<div class="subagent-head"><span class="subagent-name" title="' + esc(definition.name || '') + '">' + esc(definition.name || 'subagent') + '</span>' +
+    chips.map((chip) => '<span class="subagent-chip">' + esc(chip) + '</span>').join('') +
+    '</div>' +
+    (definition.description ? '<div class="subagent-description">' + esc(definition.description) + '</div>' : '') +
+    (tools.length ? '<div class="subagent-tools">' + tools.map((tool) => '<span class="subagent-chip">' + esc(tool) + '</span>').join('') + '</div>' : '') +
+    (definition.instructionPreview ? '<pre class="subagent-preview">' + esc(definition.instructionPreview) + '</pre>' : '') +
+    '</div>';
+}
+
+function subagentRunElement(run) {
+  const chips = [];
+  if (run.agentNickname) chips.push(run.agentNickname);
+  if (run.agentRole || run.agentType) chips.push(run.agentRole || run.agentType);
+  if (run.status) chips.push(run.status);
+  if (run.agentId) chips.push(run.agentId);
+  if (Array.isArray(run.models) && run.models.length) chips.push(run.models.join(', '));
+  if (run.messageCount) chips.push(formatFullNumber(run.messageCount) + ' messages');
+  if (run.toolCallCount) chips.push(formatFullNumber(run.toolCallCount) + ' tools');
+  const title = run.title || run.agentNickname || run.agentType || run.agentRole || run.agentId || 'subagent run';
+  const preview = [run.promptPreview ? 'Prompt: ' + run.promptPreview : '', run.resultPreview ? 'Result: ' + run.resultPreview : ''].filter(Boolean).join('\\n\\n');
   const row = document.createElement('article');
-  row.className = 'message context session-summary-message';
+  row.className = 'message context session-subagent-run-message';
   const bubble = document.createElement('div');
   bubble.className = 'bubble';
   const details = document.createElement('details');
-  details.className = 'context-card session-summary-card';
-  details.open = true;
+  details.className = 'context-card session-subagent-run-card';
   details.innerHTML =
     '<summary>' +
-    '<span class="context-prefix"><span class="context-caret"></span><span class="context-glyph">' + contextIconSvg('conversation_summary') + '</span></span>' +
-    '<span class="context-copy"><span class="context-title">Conversation summary</span>' +
-    '<span class="context-meta"><span class="context-chip">' + esc(summarySourceLabel(sessionSummary.source)) + '</span></span></span>' +
-    '<span class="context-end"></span>' +
+    '<span class="context-prefix"><span class="context-caret"></span><span class="context-glyph">' + contextIconSvg('subagents') + '</span></span>' +
+    '<span class="context-copy"><span class="context-title">Subagent: ' + esc(title) + '</span>' +
+    '<span class="context-meta">' + chips.slice(0, 4).map((chip) => '<span class="context-chip">' + esc(chip) + '</span>').join('') + '</span></span>' +
+    '<span class="context-end"><span class="context-time"' + timeAttr(run.startedAt || run.endedAt) + '>' + esc(relativeTime(run.startedAt || run.endedAt)) + '</span></span>' +
     '</summary>';
   const end = details.querySelector('.context-end');
-  if (end) end.appendChild(messageCopyButton(text));
+  if (end) end.appendChild(messageCopyButton(formatSubagentRunPlainText(run)));
   const body = document.createElement('div');
-  body.className = 'session-summary-body';
-  body.innerHTML = renderRichText(text);
+  body.className = 'session-subagents-body';
+  body.innerHTML =
+    '<div class="subagent-list"><div class="subagent-row">' +
+    (run.relativePath ? '<div class="subagent-description">' + esc(run.relativePath) + '</div>' : '') +
+    (preview ? '<pre class="subagent-preview">' + esc(preview) + '</pre>' : '') +
+    (run.sessionId ? '<button class="subagent-open" type="button" data-subagent-session="' + esc(run.sessionId) + '">Open transcript</button>' : '') +
+    '</div></div>';
+  const open = body.querySelector('[data-subagent-session]');
+  if (open) {
+    open.addEventListener('click', (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      openSubagentModal(open.getAttribute('data-subagent-session') || '');
+    });
+  }
   details.appendChild(body);
   bubble.appendChild(details);
   row.appendChild(bubble);
   return row;
 }
 
-function summarySourceLabel(source) {
-  const value = String(source || '').trim();
-  if (value === 'claude-web-export') return 'Claude.ai export';
-  if (value === 'chatgpt-export') return 'ChatGPT export';
-  if (value) return value.replace(/[-_]+/g, ' ');
-  return 'summary';
+function formatSubagentsPlainText(subagents) {
+  const lines = ['Claude subagent definitions'];
+  for (const definition of subagents.definitions || []) {
+    lines.push('');
+    lines.push(definition.name || 'subagent');
+    const meta = [definition.scope, definition.model, definition.relativePath].filter(Boolean).join(' | ');
+    if (meta) lines.push(meta);
+    if (definition.description) lines.push(definition.description);
+    if (Array.isArray(definition.tools) && definition.tools.length) lines.push('Tools: ' + definition.tools.join(', '));
+    if (definition.instructionPreview) lines.push(definition.instructionPreview);
+  }
+  return lines.join('\\n');
+}
+
+function formatSubagentRunPlainText(run) {
+  const lines = [run.title || run.agentNickname || run.agentType || run.agentRole || run.agentId || 'Subagent run'];
+  const meta = [run.providerLabel, run.agentNickname, run.agentRole || run.agentType, run.status, run.agentId, run.agentPath, run.relativePath].filter(Boolean).join(' | ');
+  if (meta) lines.push(meta);
+  if (run.startedAt || run.endedAt) lines.push([run.startedAt, run.endedAt].filter(Boolean).join(' - '));
+  if (run.messageCount) lines.push(formatFullNumber(run.messageCount) + ' messages');
+  if (run.toolCallCount) lines.push(formatFullNumber(run.toolCallCount) + ' tool calls');
+  if (run.sessionId) lines.push('Child session: ' + run.sessionId);
+  if (run.promptPreview) lines.push('Prompt: ' + run.promptPreview);
+  if (run.resultPreview) lines.push('Result: ' + run.resultPreview);
+  return lines.join('\\n');
+}
+
+async function openSubagentModal(sessionId) {
+  if (!sessionId || !sessionModal || !sessionModalBody) return;
+  sessionModal.hidden = false;
+  if (sessionModalTitle) sessionModalTitle.textContent = 'Subagent transcript';
+  if (sessionModalMeta) sessionModalMeta.innerHTML = '<span class="context-chip">' + esc(sessionId) + '</span>';
+  sessionModalBody.className = 'session-modal-body inline-empty';
+  sessionModalBody.textContent = 'Loading subagent transcript...';
+  try {
+    const { payload } = await fetchSessionPayload(sessionId);
+    if (!payload || payload.session_id !== sessionId || sessionModal.hidden) return;
+    renderSubagentModalPayload(payload);
+  } catch (error) {
+    if (sessionModalBody) {
+      sessionModalBody.className = 'session-modal-body inline-empty';
+      sessionModalBody.textContent = error.message || 'Unable to load subagent transcript.';
+    }
+  }
+}
+
+function renderSubagentModalPayload(payload) {
+  if (!sessionModalBody) return;
+  if (sessionModalTitle) sessionModalTitle.textContent = sessionDisplayTitle(payload) || 'Subagent transcript';
+  if (sessionModalMeta) {
+    const parts = [];
+    if (payload.source_type) parts.push(sourceTypeLabel(payload.provider, payload.source_type));
+    if (payload.started_at) parts.push(relativeTime(payload.started_at));
+    if (payload.messages != null) parts.push(formatFullNumber(payload.messages) + ' messages');
+    if (payload.parent_composer_id) parts.push('parent ' + payload.parent_composer_id);
+    sessionModalMeta.innerHTML = parts.map((part) => '<span class="context-chip">' + esc(part) + '</span>').join('');
+  }
+  sessionModalBody.className = 'session-modal-body';
+  sessionModalBody.innerHTML = '';
+  const messages = Array.isArray(payload.transcript_messages) ? payload.transcript_messages : [];
+  if (!messages.length) {
+    sessionModalBody.className = 'session-modal-body inline-empty';
+    sessionModalBody.textContent = 'No transcript messages are available for this subagent.';
+    return;
+  }
+  const previousPayload = currentSessionPayload;
+  currentSessionPayload = payload;
+  try {
+    let previousTimestamp = '';
+    for (const item of pairedToolRenderItems(messages)) {
+      const message = item.message || {};
+      const gap = renderTimeGap(previousTimestamp, message.timestamp);
+      if (gap) sessionModalBody.appendChild(gap);
+      sessionModalBody.appendChild(messageElement(message, item));
+      previousTimestamp = item.lastTimestamp || message.timestamp || previousTimestamp;
+    }
+    collapseLongToolChains(sessionModalBody, 10);
+  } finally {
+    currentSessionPayload = previousPayload;
+  }
+}
+
+function closeSubagentModal() {
+  if (!sessionModal) return;
+  sessionModal.hidden = true;
+  if (sessionModalBody) {
+    sessionModalBody.className = 'session-modal-body';
+    sessionModalBody.innerHTML = '';
+  }
 }
 
 function renderTimeGap(previous, current) {
-  if (!previous || !current) return null;
-  const prev = new Date(previous).getTime();
-  const next = new Date(current).getTime();
-  if (!Number.isFinite(prev) || !Number.isFinite(next)) return null;
-  const diffSec = (next - prev) / 1000;
+  const diffSec = timeGapSeconds(previous, current);
   if (diffSec < 5) return null;
   const label = formatGapLabel(diffSec);
   if (!label) return null;
@@ -7230,6 +8943,14 @@ function renderTimeGap(previous, current) {
   return node;
 }
 
+function timeGapSeconds(previous, current) {
+  if (!previous || !current) return 0;
+  const prev = new Date(previous).getTime();
+  const next = new Date(current).getTime();
+  if (!Number.isFinite(prev) || !Number.isFinite(next)) return 0;
+  return Math.max(0, (next - prev) / 1000);
+}
+
 function formatGapLabel(diffSec) {
   if (diffSec < 60) return Math.round(diffSec) + 's';
   if (diffSec < 3600) return Math.round(diffSec / 60) + 'm';
@@ -7302,19 +9023,22 @@ function highlightSearchMatches(root, term) {
   walk(root);
 }
 
-function messageElement(message) {
+function messageElement(message, options = {}) {
+  if (options.type === 'tool-group') return toolGroupElement(options);
+  if (options.type === 'subagent-run') return subagentRunElement(options.run || {});
   const context = generatedContextForMessage(message);
   if (context) return contextMessageElement(message, context);
   const role = String(message.role || 'unknown').toLowerCase();
   const content = String(message.content || '');
-  const toolCalls = messageToolCalls(message);
+  const toolCalls = messageToolCalls(message, options.pairedToolResults || []);
   const toolResult = role === 'tool' ? parseToolResult(content, message) : null;
-  const contentWithoutTools = toolCalls.length ? stripToolInvocationLines(content) : content;
+  const contentWithoutTools = isViewerStructuredToolCallMessage(message) ? '' : toolCalls.length ? stripToolInvocationLines(content) : content;
   const toolOnly = toolCalls.length && !contentWithoutTools.trim();
   const className = toolOnly ? 'tool' : ['user', 'assistant', 'system', 'tool'].includes(role) ? role : 'assistant';
   const bodyContent = toolResult
     ? renderToolResult(toolResult)
     : renderMessageBodyWithTools(className, contentWithoutTools, toolCalls);
+  const attachmentsHtml = renderMessageAttachments(message);
   const row = document.createElement('article');
   row.className = 'message ' + className;
   if (toolCalls.length) row.classList.add('tool-call-turn');
@@ -7339,14 +9063,29 @@ function messageElement(message) {
     '<div class="message-head"><span class="role">' + esc(roleLabel(role)) + '</span>' +
     '<span class="message-time"' + timeAttr(message.timestamp) + '>' + esc(relativeTime(message.timestamp)) + '</span>' +
     usageChipHtml + '</div>';
-  bubble.innerHTML = headHtml + bodyContent;
+  bubble.innerHTML = headHtml + bodyContent + attachmentsHtml;
   const head = bubble.querySelector('.message-head');
   if (head) head.appendChild(messageCopyButton(content));
   row.appendChild(bubble);
   return row;
 }
 
+function toolGroupElement(group) {
+  const calls = [];
+  for (const item of group.items || []) {
+    calls.push(...toolCardsForRenderItem(item));
+  }
+  const row = document.createElement('article');
+  row.className = 'message tool tool-call-turn tool-group-turn';
+  const bubble = document.createElement('div');
+  bubble.className = 'bubble';
+  bubble.innerHTML = renderToolGroupCard(calls);
+  row.appendChild(bubble);
+  return row;
+}
+
 function contextMessageElement(message, context) {
+  if (context.kind === 'task_notification') return contextLineElement(message, context);
   const row = document.createElement('article');
   row.className = 'message context context-' + escClass(context.kind || 'metadata');
   const bubble = document.createElement('div');
@@ -7371,6 +9110,25 @@ function contextMessageElement(message, context) {
   return row;
 }
 
+function contextLineElement(message, context) {
+  const row = document.createElement('article');
+  row.className = 'message context context-line-turn context-' + escClass(context.kind || 'metadata');
+  const bubble = document.createElement('div');
+  bubble.className = 'bubble';
+  const line = document.createElement('div');
+  line.className = 'context-line';
+  line.innerHTML =
+    '<span class="context-glyph">' + contextIconSvg(context.kind) + '</span>' +
+    '<span class="context-title">' + esc(contextTitle(context.kind)) + '</span>' +
+    '<span class="context-meta">' + context.chips.map((chip) => '<span class="context-chip">' + esc(chip) + '</span>').join('') + '</span>' +
+    '<span class="context-end"><span class="context-time"' + timeAttr(message.timestamp) + '>' + esc(relativeTime(message.timestamp)) + '</span></span>';
+  const end = line.querySelector('.context-end');
+  if (end) end.appendChild(messageCopyButton(message.content || ''));
+  bubble.appendChild(line);
+  row.appendChild(bubble);
+  return row;
+}
+
 function generatedContextForMessage(message) {
   const metadata = message?.metadata || {};
   const content = String(message?.content || '').trim();
@@ -7440,6 +9198,7 @@ function contextTitle(kind) {
     local_command_caveat: 'Local command',
     local_command_stdout: 'Local command',
     system_reminder: 'System reminder',
+    subagents: 'Claude subagents',
     compaction: 'Compaction',
     metadata: 'Context metadata'
   };
@@ -7493,12 +9252,137 @@ function xmlTagText(text, tag) {
   return source.slice(bodyStart, end).trim();
 }
 
+function renderMessageAttachments(message) {
+  const attachments = messageAttachments(message);
+  if (!attachments.length) return '';
+  return '<div class="attachment-list">' + attachments.map(renderAttachmentCard).join('') + '</div>';
+}
+
+function messageAttachments(message) {
+  const metadata = message && message.metadata && typeof message.metadata === 'object' ? message.metadata : {};
+  const attachments = Array.isArray(metadata.attachments) ? metadata.attachments : [];
+  const attachedPointers = new Set(attachments.map((attachment) => attachment && attachment.assetPointer).filter(Boolean));
+  const result = attachments.map((attachment, index) => ({ ...attachment, index, kind: 'attachment' }));
+  const pointers = Array.isArray(metadata.assetPointers) ? metadata.assetPointers : [];
+  for (const pointer of pointers) {
+    if (!pointer || !pointer.assetPointer || attachedPointers.has(pointer.assetPointer)) continue;
+    result.push({
+      index: result.length,
+      kind: 'asset',
+      name: pointer.assetPointer,
+      assetPointer: pointer.assetPointer,
+      mimeType: pointer.mimeType,
+      pointerContentType: pointer.contentType,
+      width: pointer.width,
+      height: pointer.height,
+      size: pointer.size
+    });
+  }
+  return result;
+}
+
+function renderAttachmentCard(attachment) {
+  const name = attachmentDisplayName(attachment);
+  const meta = attachmentMetaLabel(attachment);
+  const title = [name, meta, attachment.assetPointer || ''].filter(Boolean).join('\\n');
+  const isImage = attachmentIsImageForDisplay(attachment);
+  const hasUrl = attachment.available !== false && typeof attachment.url === 'string' && attachment.url;
+  const thumb = isImage && hasUrl
+    ? '<span class="attachment-thumb image"><img loading="lazy" src="' + esc(attachment.url) + '" alt="' + esc(name) + '"></span>'
+    : '<span class="attachment-thumb">' + attachmentIconSvg(isImage ? 'image' : 'file') + '</span>';
+  const body =
+    '<span class="attachment-copy"><span class="attachment-name">' + esc(name) + '</span>' +
+    (meta ? '<span class="attachment-meta">' + esc(meta) + '</span>' : '') +
+    (!hasUrl ? '<span class="attachment-meta">not available in raw export</span>' : '') +
+    '</span>';
+  const html = thumb + body;
+  if (!hasUrl) return '<div class="attachment-card" title="' + esc(title) + '">' + html + '</div>';
+  return '<a class="attachment-card' + (isImage ? ' image' : '') + '" href="' + esc(attachment.url) + '" target="_blank" rel="noopener" title="' + esc(title) + '">' + html + '</a>';
+}
+
+function attachmentDisplayName(attachment) {
+  return String(attachment && (attachment.name || attachment.id || attachment.assetPointer || 'attachment')).split(/[\\\\/]+/).pop() || 'attachment';
+}
+
+function attachmentMetaLabel(attachment) {
+  const bits = [];
+  if (attachment.mimeType) bits.push(attachment.mimeType);
+  else if (attachment.pointerContentType) bits.push(String(attachment.pointerContentType).replace(/_/g, ' '));
+  if (attachment.width && attachment.height) bits.push(String(attachment.width) + 'x' + String(attachment.height));
+  if (attachment.size) bits.push(formatAttachmentBytes(attachment.size));
+  return bits.join(' · ');
+}
+
+function formatAttachmentBytes(value) {
+  const bytes = Number(value || 0);
+  if (!Number.isFinite(bytes) || bytes <= 0) return '';
+  if (bytes < 1024) return Math.round(bytes) + ' B';
+  if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(bytes >= 10 * 1024 ? 0 : 1).replace(/\\.0$/, '') + ' KB';
+  return (bytes / (1024 * 1024)).toFixed(bytes >= 10 * 1024 * 1024 ? 0 : 1).replace(/\\.0$/, '') + ' MB';
+}
+
+function attachmentIsImageForDisplay(attachment) {
+  return /^image\\//i.test(String(attachment && attachment.mimeType || '')) || /\\.(png|jpe?g|gif|webp|bmp|tiff?|heic|heif|avif)$/i.test(attachmentDisplayName(attachment));
+}
+
+function attachmentIconSvg(kind) {
+  if (kind === 'image') {
+    return '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><rect width="18" height="18" x="3" y="3" rx="2"/><circle cx="9" cy="9" r="2"/><path d="m21 15-3.1-3.1a2 2 0 0 0-2.8 0L6 21"/></svg>';
+  }
+  return '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/><path d="M14 2v6h6"/></svg>';
+}
+
 function renderMessageBodyWithTools(className, content, toolCalls) {
   const body = className === 'user' ? renderPlainText(content) : renderRichText(content);
-  const stack = toolCalls.length ? '<div class="tool-stack">' + toolCalls.map(renderToolCallout).join('') + '</div>' : '';
+  const stack = toolCalls.length > 1
+    ? renderToolGroupCard(toolCalls)
+    : toolCalls.length
+      ? '<div class="tool-stack">' + toolCalls.map(renderToolCallout).join('') + '</div>'
+      : '';
   return body ? '<div class="tool-body">' + body + '</div>' + stack : stack;
 }
 
+function renderToolGroupCard(calls) {
+  const tools = Array.isArray(calls) ? calls : [];
+  if (!tools.length) return '';
+  return '<details class="tool-group-card">' +
+    '<summary><span class="tool-group-prefix"><span class="tool-group-caret"></span><span class="tool-glyph">' +
+    renderToolIcon({ category: dominantToolCategory(tools), kind: 'Tool activity' }) +
+    '</span></span><span class="tool-group-title">' +
+    esc(toolStackSummary(tools) || 'Used ' + tools.length + ' tools') +
+    '</span></summary>' +
+    '<div class="tool-stack">' + tools.map(renderToolCallout).join('') + '</div></details>';
+}
+
+function toolCardsForRenderItem(item) {
+  const message = item?.message || {};
+  if (String(message.role || '').toLowerCase() === 'tool') {
+    const result = parseToolResult(message.content || '', message);
+    return result ? [toolCardFromResult(result)] : [];
+  }
+  return messageToolCalls(message, item?.pairedToolResults || []);
+}
+
+function toolCardFromResult(result) {
+  const category = normalizedToolCategory(result.category, result.kind);
+  const detail = result.detail || result.summary || firstLine(result.output || '') || result.kind || 'Tool output';
+  return toolCard({
+    kind: result.name || result.kind || 'Tool output',
+    title: result.kind || result.title || '',
+    category,
+    categoryLabel: result.categoryLabel || toolCategoryLabel(category),
+    icon: result.icon || toolIcon(category, result.kind || ''),
+    status: result.status || 'completed',
+    argument: detail,
+    rawInputSummary: detail,
+    inputPreview: '',
+    target: result.target || '',
+    id: result.id || '',
+    result,
+    resultOnly: true
+  });
+}
+
 function copyIconSvg() {
   return '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.9" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><rect width="14" height="14" x="8" y="8" rx="2" ry="2"/><path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"/></svg>';
 }
@@ -7547,13 +9431,15 @@ function detectToolName(text) {
   return tool ? tool.label : '';
 }
 
-function messageToolCalls(message) {
+function messageToolCalls(message, pairedResultMessages) {
   const eventCalls = canonicalEventsForMessage(message, 'tool.called').map(toolCallFromEvent).filter(Boolean);
-  if (eventCalls.length) return eventCalls;
+  if (eventCalls.length) return attachPairedToolResults(eventCalls, pairedResultMessages);
   const metadataCalls = Array.isArray(message?.metadata?.toolCalls) ? message.metadata.toolCalls : [];
+  const structuredCall = metadataCalls.length ? null : viewerStructuredToolCall(message);
   const textCalls = toolInvocationsFromText(message?.content || '');
+  if (structuredCall) return attachPairedToolResults([structuredCall], pairedResultMessages);
   if (metadataCalls.length) {
-    return metadataCalls.map((meta, index) => {
+    const calls = metadataCalls.map((meta, index) => {
       const text = textCalls[index] || {};
       const kind = meta.displayName || meta.name || text.kind || 'Tool';
       const argument = meta.argument || meta.rawInputSummary || text.argument || '';
@@ -7569,10 +9455,11 @@ function messageToolCalls(message) {
         categoryLabel: meta.categoryLabel || '',
         icon: meta.icon || '',
         rawCategory: meta.rawCategory || '',
-        id: meta.id || '',
+        id: meta.id || meta.callId || meta.call_id || meta.toolCallId || meta.tool_call_id || meta.toolUseId || meta.tool_use_id || '',
         arguments: meta.arguments || null
       });
     }).filter((call) => call.kind || call.title || call.argument);
+    return attachPairedToolResults(calls, pairedResultMessages);
   }
   const total = Math.max(metadataCalls.length, textCalls.length);
   const calls = [];
@@ -7592,11 +9479,123 @@ function messageToolCalls(message) {
       categoryLabel: meta.categoryLabel || '',
       icon: meta.icon || '',
       rawCategory: meta.rawCategory || '',
-      id: meta.id || '',
+      id: meta.id || meta.callId || meta.call_id || meta.toolCallId || meta.tool_call_id || meta.toolUseId || meta.tool_use_id || '',
       arguments: meta.arguments || null
     }));
   }
-  return calls.filter((call) => call.kind || call.title || call.argument);
+  return attachPairedToolResults(calls.filter((call) => call.kind || call.title || call.argument), pairedResultMessages);
+}
+
+function isViewerStructuredToolCallMessage(message) {
+  return Boolean(viewerStructuredToolCall(message));
+}
+
+function viewerStructuredToolCall(message) {
+  const meta = message && message.metadata && typeof message.metadata === 'object' ? message.metadata : {};
+  const recipient = String(meta.recipient || '').trim();
+  if (!recipient || recipient === 'all' || recipient === 'assistant') return null;
+  if (String(meta.source || '') !== 'chatgpt-export' && String(currentSessionPayload?.provider || '') !== 'chatgpt') return null;
+  const content = String(message?.content || '').trim();
+  if (!content) return null;
+  const parsed = parseToolArgumentsForViewer(content);
+  const kind = viewerChatGptToolName(recipient, parsed);
+  const preview = typeof parsed === 'object' && parsed
+    ? JSON.stringify(parsed, null, 2)
+    : content;
+  return toolCard({
+    kind,
+    name: kind,
+    title: roleLabel(kind.replace(/[._-]+/g, ' ')),
+    category: recipient.includes('web.') || kind.includes('web.') ? 'web' : '',
+    rawCategory: 'chatgpt_tool_call',
+    status: 'tool_call',
+    argument: summarizeViewerToolArguments(parsed) || content.slice(0, 240),
+    inputPreview: preview.slice(0, 2000),
+    arguments: parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null
+  });
+}
+
+function parseToolArgumentsForViewer(value) {
+  try { return JSON.parse(String(value || '').trim()); } catch { return String(value || '').trim(); }
+}
+
+function viewerChatGptToolName(recipient, args) {
+  if (recipient === '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 recipient || 'tool';
+}
+
+function summarizeViewerToolArguments(value) {
+  if (!value || typeof value !== 'object') return String(value || '').slice(0, 240);
+  for (const key of ['query', 'pattern', 'command', 'cmd', 'prompt']) {
+    if (value[key]) return String(value[key]).slice(0, 240);
+  }
+  if (Array.isArray(value.search_query) && value.search_query[0]?.q) return String(value.search_query[0].q).slice(0, 240);
+  if (Array.isArray(value.open) && value.open[0]?.ref_id) return String(value.open[0].ref_id).slice(0, 240);
+  return Object.entries(value).slice(0, 3).map(([key, item]) => key + ': ' + (typeof item === 'string' ? item : JSON.stringify(item))).join(', ').slice(0, 240);
+}
+
+function attachPairedToolResults(calls, pairedResultMessages) {
+  if (!Array.isArray(pairedResultMessages) || !pairedResultMessages.length) return calls;
+  const results = pairedResultMessages
+    .map((message) => parseToolResult(message?.content || '', message))
+    .filter(Boolean);
+  if (!results.length) return calls;
+  const remaining = results.slice();
+  return calls.map((call) => {
+    const matchIndex = pairedToolResultIndex(call, remaining);
+    if (matchIndex < 0) return call;
+    const [result] = remaining.splice(matchIndex, 1);
+    return { ...call, result };
+  });
+}
+
+function pairedToolResultIndex(call, results) {
+  const callId = normalizedToolId(call?.id);
+  if (callId) {
+    const idMatch = results.findIndex((result) => normalizedToolId(result?.id) === callId);
+    if (idMatch >= 0) return idMatch;
+  }
+  const callKind = normalizeToolToken(call?.kind || call?.name || call?.title || '');
+  if (callKind) {
+    const kindMatch = results.findIndex((result) => normalizeToolToken(result?.name || result?.kind || result?.title || '') === callKind);
+    if (kindMatch >= 0) return kindMatch;
+  }
+  return results.length ? 0 : -1;
+}
+
+function toolStackSummary(tools) {
+  const counts = {};
+  for (const tool of tools) {
+    const category = normalizedToolCategory(tool.category, tool.kind);
+    counts[category] = (counts[category] || 0) + 1;
+  }
+  const parts = [];
+  if (counts.read) parts.push('explored ' + counts.read + ' ' + (counts.read === 1 ? 'file' : 'files'));
+  if (counts.search) parts.push('searched ' + counts.search + ' ' + (counts.search === 1 ? 'time' : 'times'));
+  if (counts.shell) parts.push('ran ' + counts.shell + ' ' + (counts.shell === 1 ? 'command' : 'commands'));
+  if (counts.edit) parts.push('edited ' + counts.edit + ' ' + (counts.edit === 1 ? 'file' : 'files'));
+  const known = ['read', 'search', 'shell', 'edit'];
+  const other = Object.entries(counts).filter(([key]) => !known.includes(key)).reduce((sum, [, count]) => sum + count, 0);
+  if (other) parts.push('used ' + other + ' ' + (other === 1 ? 'tool' : 'tools'));
+  const text = parts.join(', ');
+  return text ? text.charAt(0).toUpperCase() + text.slice(1) : '';
+}
+
+function dominantToolCategory(tools) {
+  const counts = {};
+  for (const tool of tools || []) {
+    const category = normalizedToolCategory(tool.category, tool.kind);
+    counts[category] = (counts[category] || 0) + 1;
+  }
+  return Object.entries(counts).sort((a, b) => b[1] - a[1])[0]?.[0] || 'tool';
 }
 
 function toolCallFromEvent(event) {
@@ -7615,7 +9614,8 @@ function toolCallFromEvent(event) {
     categoryLabel: meta.categoryLabel || '',
     icon: meta.icon || event.indexed?.toolIcon || '',
     rawCategory: meta.rawCategory || '',
-    id: meta.id || '',
+    id: meta.id || meta.callId || meta.call_id || meta.toolCallId || meta.tool_call_id || meta.toolUseId || meta.tool_use_id || '',
+    eventId: event.eventId || '',
     arguments: meta.arguments || null
   });
 }
@@ -7682,6 +9682,10 @@ function normalizeToolToken(value) {
   return String(value || '').trim().toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '');
 }
 
+function normalizedToolId(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
 function toolCategoryLabel(category) {
   const labels = {
     shell: 'Shell',
@@ -7710,18 +9714,92 @@ function escClass(value) {
 function renderToolCallout(tool) {
   const card = toolCard(tool);
   const isSkill = card.category === 'skill' || card.kind === 'Skill';
-  const title = card.title || (isSkill ? 'Skill loaded' : card.kind);
-  const category = card.category ? '<span class="tool-chip">' + esc(card.categoryLabel || card.category) + '</span>' : '';
-  const statusClass = humanToolStatusClass(card.status);
-  const status = card.status ? '<span class="tool-status' + (statusClass ? ' ' + statusClass : '') + '">' + esc(humanToolStatus(card.status)) + '</span>' : '';
-  const target = card.target ? '<span class="tool-target">' + esc(card.target) + '</span>' : '';
   const diff = renderToolDiff(card);
-  const preview = diff ? '' : '<span class="tool-preview">' + esc(card.inputPreview || card.argument || card.kind) + '</span>';
-  const detail = preview + target + diff;
-  return '<div class="tool-callout ' + escClass(card.category || 'tool') + (isSkill ? ' skill' : '') + '">' +
-    '<span class="tool-glyph">' + renderToolIcon(card) + '</span>' +
-    '<div class="tool-copy"><div class="tool-title">' + esc(title) + category + status + '</div>' +
-    '<div class="tool-detail">' + detail + '</div></div></div>';
+  const category = normalizedToolCategory(card.category, card.kind);
+  return '<details class="tool-callout ' + escClass(category) + (isSkill ? ' skill' : '') + (card.result ? ' has-result' : '') + '" data-category="' + esc(escClass(category)) + '">' +
+    renderToolActivitySummary(card) +
+    renderToolCalloutBody(card, diff) +
+    '</details>';
+}
+
+function renderToolActivitySummary(card) {
+  const label = toolActivityLabel(card);
+  const count = card.result?.count || '';
+  const statusClass = humanToolStatusClass(card.status);
+  const status = !card.result && card.status ? '<span class="tool-status' + (statusClass ? ' ' + statusClass : '') + '">' + esc(humanToolStatus(card.status)) + '</span>' : '';
+  return '<summary><span class="tool-glyph">' + renderToolIcon(card) + '</span>' +
+    '<span class="tool-call-line"><span class="tool-action">' + esc(label.action) + '</span>' +
+    (label.subject ? '<span class="tool-subject">' + esc(label.subject) + '</span>' : '') +
+    '</span>' + status +
+    (count ? '<span class="tool-result-count">' + esc(count) + '</span>' : '') +
+    '</summary>';
+}
+
+function renderToolCalloutBody(card, diff) {
+  const rows = [];
+  const meta = [];
+  if (card.categoryLabel) meta.push(card.categoryLabel);
+  if (card.status) meta.push(humanToolStatus(card.status));
+  if (card.target) meta.push(card.target);
+  if (meta.length) rows.push('<div class="tool-call-meta">' + meta.map((item) => '<span class="tool-chip">' + esc(item) + '</span>').join('') + '</div>');
+  const preview = card.resultOnly ? '' : String(card.inputPreview || card.argument || '').trim();
+  if (preview) rows.push('<pre class="tool-preview">' + esc(preview) + '</pre>');
+  if (diff) rows.push(diff);
+  if (card.result) rows.push(renderPairedToolResult(card.result));
+  return rows.length ? '<div class="tool-callout-body">' + rows.join('') + '</div>' : '';
+}
+
+function renderPairedToolResult(result) {
+  const category = normalizedToolCategory(result.category, result.kind);
+  const meta = [result.kind, result.detail, result.count].filter(Boolean);
+  return '<div class="tool-paired-result" data-category="' + esc(escClass(category)) + '">' +
+    (meta.length ? '<div class="tool-result-meta">' + meta.map((item) => '<span>' + esc(item) + '</span>').join('') + '</div>' : '') +
+    renderToolOutput(result.output || '', { lineStart: result.lineStart }) + '</div>';
+}
+
+function toolActivityLabel(card) {
+  const category = normalizedToolCategory(card.category, card.kind);
+  const fallback = toolSubjectFallback(card);
+  if (category === 'shell') return { action: 'Ran', subject: shellCommandText(card) || fallback };
+  if (category === 'read') return { action: 'Read', subject: compactPathLabel(card.target || fallback) };
+  if (category === 'search') return { action: 'Searched', subject: fallback };
+  if (category === 'edit') return { action: 'Edited', subject: compactPathLabel(card.target || fallback) };
+  if (category === 'web') return { action: webToolVerb(card), subject: fallback };
+  if (category === 'task') return { action: 'Ran', subject: fallback };
+  if (category === 'skill') return { action: 'Loaded', subject: fallback };
+  if (category === 'mcp') return { action: 'Called', subject: fallback };
+  return { action: card.title || card.kind || 'Used', subject: fallback && fallback !== (card.title || card.kind) ? fallback : '' };
+}
+
+function shellCommandText(card) {
+  const args = card.arguments && typeof card.arguments === 'object' && !Array.isArray(card.arguments) ? card.arguments : {};
+  return firstToolString(args.cmd, args.command, args.script, card.inputPreview, card.argument);
+}
+
+function webToolVerb(card) {
+  const key = normalizeToolToken(card.kind || card.title || '');
+  if (key.includes('fetch')) return 'Fetched';
+  if (key.includes('search')) return 'Searched';
+  if (key.includes('open')) return 'Opened';
+  return 'Opened';
+}
+
+function toolSubjectFallback(card) {
+  return firstToolString(card.target, card.inputPreview, card.argument, card.title, card.kind);
+}
+
+function compactPathLabel(value) {
+  const text = String(value || '').trim();
+  if (!text || /\s/.test(text) || !text.includes('/')) return text;
+  return text.split('/').filter(Boolean).pop() || text;
+}
+
+function firstToolString() {
+  for (const value of arguments) {
+    if (typeof value === 'string' && value.trim()) return value.trim();
+    if (Array.isArray(value) && value.length) return value.map((item) => String(item || '').trim()).filter(Boolean).join(' ');
+  }
+  return '';
 }
 
 function hasPatchMarker(value) {
@@ -7818,7 +9896,7 @@ function renderToolDiff(card) {
   if (adds) summaryParts.push('<span class="add-count">+' + adds + '</span>');
   if (dels) summaryParts.push('<span class="del-count">-' + dels + '</span>');
   const summaryLabel = editCount > 1 ? editCount + ' edits' : label;
-  return '<details class="tool-diff" open>' +
+  return '<details class="tool-diff">' +
     '<summary class="tool-diff-summary">' + esc(summaryLabel) + summaryParts.join('') + '</summary>' +
     '<div class="tool-diff-body">' + blocks.join('') + '</div>' +
     '</details>';
@@ -7910,6 +9988,7 @@ function contextIconSvg(kind) {
     command_message: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><polyline points="4 17 10 11 4 5"/><line x1="12" x2="20" y1="19" y2="19"/></svg>',
     local_command: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><polyline points="4 17 10 11 4 5"/><line x1="12" x2="20" y1="19" y2="19"/></svg>',
     system_reminder: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="12" r="10"/><line x1="12" x2="12" y1="8" y2="12"/><line x1="12" x2="12.01" y1="16" y2="16"/></svg>',
+    subagents: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M16 18a4 4 0 0 0-8 0"/><circle cx="12" cy="10" r="3"/><path d="M4 20a3 3 0 0 1 3-3"/><path d="M20 20a3 3 0 0 0-3-3"/><path d="M6 9a2 2 0 1 0 0 4"/><path d="M18 9a2 2 0 1 1 0 4"/></svg>',
     conversation_summary: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M21 15a4 4 0 0 1-4 4H8l-5 3V7a4 4 0 0 1 4-4h10a4 4 0 0 1 4 4z"/><path d="M8 8h8"/><path d="M8 12h6"/></svg>',
     metadata: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="12" r="10"/><line x1="12" x2="12" y1="16" y2="12"/><line x1="12" x2="12.01" y1="8" y2="8"/></svg>'
   };
@@ -7948,36 +10027,89 @@ function parseToolResult(content, message) {
   const event = canonicalEventsForMessage(message, 'tool.completed')[0];
   if (event) {
     const result = toolResultFromMetadata(event.body?.toolResult || {}, event.indexed || {}, event.body?.text || content);
-    if (result) return result;
+    if (result) return refineViewerToolResult(result, event.body?.text || content);
   }
   if (message?.metadata?.toolResult) {
     const result = toolResultFromMetadata(message.metadata.toolResult, {}, content);
-    if (result) return result;
+    if (result) return refineViewerToolResult(result, content);
   }
   const text = String(content || '').trim();
   if (!text) return null;
-  const structured = parseFileViewResult(text) || parseCommandResult(text) || parseSkillResult(text) || parseSearchResult(text);
+  const structured = parseChatGptFileToolResult(text) || parseFileViewResult(text) || parseCommandResult(text) || parseSkillResult(text) || parseSearchResult(text);
   if (structured) return structured;
   return genericToolResult(text);
 }
 
 function toolResultFromMetadata(result, indexed, fallbackText) {
-  const output = String(result.output || result.text || result.content || fallbackText || '').trimEnd();
-  if (!output && !result.summary && !indexed.summary) return null;
+  const output = formatChatGptCitationMarkersForPlainText(String(result.output || result.text || result.content || fallbackText || '').trimEnd());
+  const summary = formatChatGptCitationMarkersForPlainText(result.summary || indexed.summary || '');
+  if (!output && !summary) return null;
   const category = normalizedToolCategory(result.category || indexed.toolCategory || result.rawCategory || '', result.kind || indexed.title || '');
   return {
+    id: result.id || result.callId || result.call_id || result.toolCallId || result.tool_call_id || result.toolUseId || result.tool_use_id || '',
+    name: result.name || result.toolName || indexed.toolName || '',
+    rawCategory: result.rawCategory || '',
     header: 'Tool result' + (result.title || indexed.title ? ' · ' + (result.title || indexed.title) : ''),
     kind: result.kind || indexed.title || 'Tool output',
     category,
     categoryLabel: result.categoryLabel || toolCategoryLabel(category),
     icon: result.icon || indexed.toolIcon || toolIcon(category, result.kind || indexed.title || ''),
-    detail: result.summary || indexed.summary || firstLine(output),
-    count: result.lineCount ? result.lineCount + ' line' + (Number(result.lineCount) === 1 ? '' : 's') : lineCountLabel(output || result.summary || indexed.summary || ''),
-    output: output || result.summary || indexed.summary || '',
+    detail: summary || firstLine(output),
+    count: result.lineCount ? result.lineCount + ' line' + (Number(result.lineCount) === 1 ? '' : 's') : lineCountLabel(output || summary || ''),
+    output: output || summary || '',
+    lineStart: Number(result.startLine || result.start_line || result.lineStart || result.line_start || 0) || 0,
     collapsed: Boolean(result.collapsed) || String(output).split('\\n').length > 18
   };
 }
 
+function refineViewerToolResult(result, fallbackText) {
+  const chatgpt = parseChatGptFileToolResult(result?.output || fallbackText || '');
+  if (!chatgpt) return result;
+  return {
+    ...result,
+    ...chatgpt,
+    id: result.id || chatgpt.id || '',
+    header: chatgpt.header || result.header || 'Tool result',
+    output: chatgpt.output || result.output || '',
+    count: chatgpt.count || result.count || ''
+  };
+}
+
+function parseChatGptFileToolResult(text) {
+  const value = String(text || '').trim();
+  if (!value) return null;
+  if (/^All the files uploaded by the user have been fully loaded\\./i.test(value)) {
+    return {
+      header: 'Tool result · Files',
+      kind: 'Uploaded files loaded',
+      category: 'read',
+      categoryLabel: 'Files',
+      icon: 'R',
+      detail: firstLine(formatChatGptCitationMarkersForPlainText(value)),
+      count: lineCountLabel(value),
+      output: formatChatGptCitationMarkersForPlainText(value),
+      collapsed: false
+    };
+  }
+  if (!/<PARSED TEXT FOR PAGE:\\s*\\d+\\s*\\/\\s*\\d+>/i.test(value)) return null;
+  const pages = Array.from(value.matchAll(/<PARSED TEXT FOR PAGE:\\s*(\\d+)\\s*\\/\\s*(\\d+)>/gi));
+  const pageCount = pages.reduce((max, match) => Math.max(max, Number(match[2]) || 0), 0);
+  const citation = chatGptCitationMarkerDetail(value.match(/\uE200filecite\uE202([^\uE201]+)\uE201/i)?.[1] || '');
+  const detail = [citation, pageCount ? pageCount + ' page' + (pageCount === 1 ? '' : 's') : ''].filter(Boolean).join(' · ');
+  const output = formatChatGptCitationMarkersForPlainText(value);
+  return {
+    header: 'Tool result · Files',
+    kind: 'Parsed uploaded file',
+    category: 'read',
+    categoryLabel: 'Files',
+    icon: 'R',
+    detail: detail || 'Uploaded file parsed text',
+    count: lineCountLabel(output),
+    output,
+    collapsed: true
+  };
+}
+
 function parseFileViewResult(text) {
   const match = text.match(/^<file-view\\b([^>]*)>\\n?([\\s\\S]*?)(?:\\n?<\\/file-view>\\s*)?$/);
   if (!match) return null;
@@ -7993,6 +10125,7 @@ function parseFileViewResult(text) {
     detail: [attrs.path || basename, lineLabel].filter(Boolean).join(' · '),
     count: lineCountLabel(code),
     output: code,
+    lineStart: Number(attrs.start_line || 0) || 0,
     collapsed: code.split('\\n').length > 24
   };
 }
@@ -8050,14 +10183,25 @@ function genericToolResult(text) {
   };
 }
 
-function renderToolResult(result) {
-  const open = result.collapsed ? '' : ' open';
+function renderToolResult(result, options) {
+  const inline = Boolean(options && options.inline);
   const category = normalizedToolCategory(result.category, result.kind);
-  return '<details class="tool-result" data-category="' + esc(escClass(category)) + '"' + open + '>' +
+  return '<details class="tool-result' + (inline ? ' inline' : '') + '" data-category="' + esc(escClass(category)) + '">' +
     '<summary><span class="tool-result-kind"><span class="tool-glyph">' + renderToolIcon({ icon: result.icon, category, kind: result.kind }) + '</span>' + esc(result.kind) + '</span>' +
     (result.detail ? '<span class="tool-result-detail">' + esc(result.detail) + '</span>' : '') +
     (result.count ? '<span class="tool-result-count">' + esc(result.count) + '</span>' : '') +
-    '</summary><pre class="tool-output">' + esc(result.output || '') + '</pre></details>';
+    '</summary>' + renderToolOutput(result.output || '', { lineStart: result.lineStart }) + '</details>';
+}
+
+function renderToolOutput(output, options = {}) {
+  const text = formatChatGptCitationMarkersForPlainText(String(output || ''));
+  const lines = text.split('\\n');
+  if (lines.length <= 1) return '<pre class="tool-output">' + esc(text) + '</pre>';
+  const start = Number(options.lineStart || 0) || 1;
+  return '<div class="tool-output tool-output-lines">' + lines.map((line, index) =>
+    '<div class="tool-output-line"><span class="tool-line-number">' + esc(start + index) + '</span><span class="tool-line-text">' +
+    (line ? esc(line) : '&nbsp;') + '</span></div>'
+  ).join('') + '</div>';
 }
 
 function parseXmlishAttrs(value) {
@@ -8243,6 +10387,13 @@ function renderInline(value) {
 function renderInlinePlain(value) {
   let html = esc(value);
   const redactions = [];
+  const citations = [];
+  html = html.replace(/\uE200([A-Za-z_]*cite)\uE202([^\uE201]+)\uE201/g, function (_, kind, ref) {
+    const index = citations.length;
+    const title = chatGptCitationMarkerTitle(kind, ref);
+    citations.push('<span class="citation-chip" title="' + esc(title) + '">' + esc(citationLabel(kind, ref)) + '</span>');
+    return '\\u0000CITATION_' + index + '\\u0000';
+  });
   html = html.replace(/\\[REDACTED(?::|\\s+)([^\\]\\n]+)\\]/g, function (_, kind) {
     const index = redactions.length;
     const label = redactionLabel(kind);
@@ -8256,9 +10407,49 @@ function renderInlinePlain(value) {
   html = html.replace(/\\u0000REDACTION_(\\d+)\\u0000/g, function (_, index) {
     return redactions[Number(index)] || '';
   });
+  html = html.replace(/\\u0000CITATION_(\\d+)\\u0000/g, function (_, index) {
+    return citations[Number(index)] || '';
+  });
   return html;
 }
 
+function citationLabel(kind, ref) {
+  const type = String(kind || '').toLowerCase();
+  const parts = chatGptCitationMarkerParts(ref);
+  if (type.includes('file')) {
+    const line = parts.find((part) => /^L\\d+/i.test(part));
+    if (line) return line.length <= 14 ? line : 'file';
+    const file = parts.find((part) => /file/i.test(part)) || '';
+    const shortFile = file.replace(/^turn\\d+/, '').replace(/^[-_:]+/, '');
+    return shortFile && shortFile.length <= 12 ? shortFile : 'file';
+  }
+  const text = parts[parts.length - 1] || String(ref || '').trim();
+  const short = text.replace(/^turn\\d+/, '').replace(/^[-_:]+/, '');
+  return short && short.length <= 12 ? short : 'cite';
+}
+
+function chatGptCitationMarkerTitle(kind, ref) {
+  const label = /file/i.test(String(kind || '')) ? 'ChatGPT file citation' : 'ChatGPT citation';
+  const detail = chatGptCitationMarkerDetail(ref);
+  return detail ? label + ': ' + detail : label;
+}
+
+function chatGptCitationMarkerDetail(ref) {
+  return chatGptCitationMarkerParts(ref).join(' ');
+}
+
+function chatGptCitationMarkerParts(ref) {
+  return String(ref || '').split('\uE202').map((part) => part.trim()).filter(Boolean);
+}
+
+function formatChatGptCitationMarkersForPlainText(value) {
+  return String(value || '').replace(/\uE200([A-Za-z_]*cite)\uE202([^\uE201]+)\uE201/g, function (_, kind, ref) {
+    const label = /file/i.test(String(kind || '')) ? 'file citation' : 'citation';
+    const detail = chatGptCitationMarkerDetail(ref);
+    return detail ? '[' + label + ': ' + detail + ']' : '[' + label + ']';
+  });
+}
+
 function renderMarkdownLink(label, href) {
   const value = String(href || '').trim();
   if (!/^(https?:|mailto:|file:|\\/|#)/i.test(value)) {
@@ -8283,7 +10474,47 @@ function compactSkillPath(value) {
   return '.../' + parts.slice(-2).join('/');
 }
 
-function setView(mode) {
+function clampScrollRatio(value) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return 0;
+  return Math.max(0, Math.min(1, number));
+}
+
+function captureRelativeScrollPosition() {
+  const scroller = document.querySelector('.detail-scroll');
+  if (!scroller) return null;
+  const maxScroll = Math.max(0, scroller.scrollHeight - scroller.clientHeight);
+  return {
+    scroller,
+    ratio: maxScroll > 0 ? clampScrollRatio(scroller.scrollTop / maxScroll) : 0
+  };
+}
+
+function restoreRelativeScrollPosition(position, serial) {
+  if (!position || !position.scroller) return;
+  if (serial !== viewScrollRestoreSerial) return;
+  const scroller = position.scroller;
+  const maxScroll = Math.max(0, scroller.scrollHeight - scroller.clientHeight);
+  scroller.scrollTop = Math.round(maxScroll * clampScrollRatio(position.ratio));
+  if (typeof updateJumpEndVisibility === 'function') updateJumpEndVisibility();
+}
+
+function scheduleRelativeScrollRestore(position, serial) {
+  if (!position) return;
+  const schedule = window.requestAnimationFrame
+    ? (fn) => window.requestAnimationFrame(fn)
+    : (fn) => window.setTimeout(fn, 0);
+  schedule(() => {
+    restoreRelativeScrollPosition(position, serial);
+    schedule(() => restoreRelativeScrollPosition(position, serial));
+  });
+}
+
+function setView(mode, options) {
+  const opts = options || {};
+  const preserveScroll = opts.preserveScroll !== false && mode !== viewMode;
+  const scrollPosition = preserveScroll ? captureRelativeScrollPosition() : null;
+  const restoreSerial = ++viewScrollRestoreSerial;
   viewMode = mode;
   const markdown = mode === 'markdown';
   readableButton.classList.toggle('active', !markdown);
@@ -8292,9 +10523,15 @@ function setView(mode) {
   markdownButton.setAttribute('aria-pressed', markdown ? 'true' : 'false');
   readableView.style.display = markdown ? 'none' : 'block';
   markdownView.style.display = markdown ? 'block' : 'none';
-  if (markdown) ensureMarkdownLoaded().catch((error) => {
-    markdownView.textContent = error.message || 'Markdown could not be loaded.';
-  });
+  const markdownLoad = markdown
+    ? ensureMarkdownLoaded().catch((error) => {
+      markdownView.textContent = error.message || 'Markdown could not be loaded.';
+    })
+    : null;
+  if (preserveScroll) {
+    scheduleRelativeScrollRestore(scrollPosition, restoreSerial);
+    if (markdownLoad) markdownLoad.finally(() => scheduleRelativeScrollRestore(scrollPosition, restoreSerial));
+  }
 }
 
 async function ensureMarkdownLoaded() {
@@ -8443,7 +10680,8 @@ function treeSignature(payload) {
     const sessions = (group.sessions || []).map((session) => session.session_id + '=' + (session.updated_at || session.ended_at || session.started_at || '')).join('|');
     return (group.repo_key || '') + '#' + (group.count || 0) + ':' + sessions;
   }).join('||');
-  return groupSig + '::' + (payload.count || 0);
+  const sourceSig = (payload.available_source_options || []).map((option) => option.value || '').join(',');
+  return groupSig + '::' + (payload.count || 0) + '::sources=' + sourceSig;
 }
 
 function startLiveRefresh() {
@@ -8641,14 +10879,27 @@ recentButton.onclick = () => {
   setSelectValue('scope', 'all');
   loadTree().catch((error) => { setEmptySession(error.message); });
 };
-readableButton.onclick = () => setView('readable');
-markdownButton.onclick = () => setView('markdown');
+readableButton.onclick = () => setView('readable', { preserveScroll: true });
+markdownButton.onclick = () => setView('markdown', { preserveScroll: true });
 copyDetailsButton.onclick = () => {
   copySessionDetails();
 };
 copyResumeButton.onclick = () => {
   copyResumeCommand();
 };
+if (sessionModalClose) sessionModalClose.onclick = closeSubagentModal;
+if (sessionModal) {
+  sessionModal.addEventListener('click', (event) => {
+    if (event.target === sessionModal) closeSubagentModal();
+  });
+}
+window.addEventListener('keydown', (event) => {
+  if (event.key === 'Escape' && sessionModal && !sessionModal.hidden) {
+    closeSubagentModal();
+    event.preventDefault();
+    event.stopPropagation();
+  }
+});
 jumpEnd.onclick = () => {
   const scroller = document.querySelector('.detail-scroll');
   scroller.scrollTo({ top: scroller.scrollHeight, behavior: 'smooth' });
@@ -8710,7 +10961,7 @@ setupStatsActivityControls();
 setupStatsBreakdownControls();
 
 async function loadStats() {
-  const elements = ['chartTokensPerDay', 'chartSessionsPerDay', 'chartTokensPerRepo', 'chartSessionsPerRepo', 'statsAgentHeatmap', 'statsChatHeatmap'].map((id) => document.getElementById(id));
+  const elements = ['chartTokensPerDay', 'chartSessionsPerDay', 'chartTokensPerRepo', 'chartSessionsPerRepo', 'statsAgentHeatmap', 'statsChatHeatmap', 'statsSdkHeatmap'].map((id) => document.getElementById(id));
   for (const el of elements) {
     if (el) {
       el.classList.add('stats-empty');
@@ -8879,7 +11130,7 @@ function statsBreakdownGroupId(entry) {
 }
 
 function emptyStatsTotals() {
-  return { tokens: 0, tokens_input: 0, tokens_output: 0, tokens_cache: 0, tokens_estimated: 0, conversations: 0, user_messages: 0 };
+  return { tokens: 0, tokens_input: 0, tokens_output: 0, tokens_cache: 0, tokens_reasoning: 0, tokens_estimated: 0, conversations: 0, user_messages: 0 };
 }
 
 function addStatsTotals(target, entry) {
@@ -8888,6 +11139,7 @@ function addStatsTotals(target, entry) {
   target.tokens_input += Number(entry.tokens_input || 0);
   target.tokens_output += Number(entry.tokens_output || 0);
   target.tokens_cache += Number(entry.tokens_cache || 0);
+  target.tokens_reasoning += Number(entry.tokens_reasoning || 0);
   target.tokens_estimated += Number(entry.tokens_estimated || 0);
   target.conversations += Number(entry.conversations ?? entry.sessions ?? 0);
   target.user_messages += Number(entry.user_messages || 0);
@@ -8972,7 +11224,7 @@ function statsRepoRowsForRange(payload) {
     for (const row of Array.isArray(day.repos) ? day.repos : []) {
       const key = row.repo_key || row.repo_display || 'unknown';
       if (!repos.has(key)) {
-        repos.set(key, { repo_key: row.repo_key || key, repo_display: row.repo_display || key, providers: {}, companies: {}, models: {}, tokens: 0, tokens_input: 0, tokens_output: 0, tokens_cache: 0, tokens_estimated: 0, conversations: 0, user_messages: 0 });
+        repos.set(key, { repo_key: row.repo_key || key, repo_display: row.repo_display || key, providers: {}, companies: {}, models: {}, tokens: 0, tokens_input: 0, tokens_output: 0, tokens_cache: 0, tokens_reasoning: 0, tokens_estimated: 0, conversations: 0, user_messages: 0 });
       }
       const target = repos.get(key);
       target.repo_display = row.repo_display || target.repo_display;
@@ -9003,8 +11255,9 @@ function renderStatsDailyCharts() {
     if (empty2) { empty2.classList.add('stats-empty'); empty2.textContent = 'No days in this range.'; }
     return;
   }
-  renderDailyChart('chartTokensPerDay', densified, groups, usageMetric, 336);
-  renderDailyChart('chartSessionsPerDay', densified, groups, activityMetric, 336);
+  const canonicalGroups = statsCanonicalOrderedGroups(groups);
+  renderDailyChart('chartTokensPerDay', densified, canonicalGroups, usageMetric, 336);
+  renderDailyChart('chartSessionsPerDay', densified, canonicalGroups, activityMetric, 336);
 }
 
 function renderStats(payload) {
@@ -9019,12 +11272,13 @@ function renderStats(payload) {
   renderStatsLegend(groups, breakdownTotals);
   renderStatsDailyCharts();
   const repoRows = statsRepoRowsForRange(payload);
-  renderRepoChart('chartTokensPerRepo', repoRows, groups, statsTokenMetric());
-  renderRepoChart('chartSessionsPerRepo', repoRows, groups, statsActivityMetric());
+  const canonicalGroupsForRepo = statsCanonicalOrderedGroups(groups);
+  renderRepoChart('chartTokensPerRepo', repoRows, canonicalGroupsForRepo, statsTokenMetric());
+  renderRepoChart('chartSessionsPerRepo', repoRows, canonicalGroupsForRepo, statsActivityMetric());
 }
 
 function statsTokenMetric() {
-  if (statsShowInputTokens && statsShowOutputTokens && !statsShowCacheTokens) return 'tokens';
+  if (statsShowInputTokens && statsShowOutputTokens && statsShowCacheTokens) return 'tokens';
   if (statsShowInputTokens && !statsShowOutputTokens && !statsShowCacheTokens) return 'tokens_input';
   if (!statsShowInputTokens && statsShowOutputTokens && !statsShowCacheTokens) return 'tokens_output';
   if (!statsShowInputTokens && !statsShowOutputTokens && statsShowCacheTokens) return 'tokens_cache';
@@ -9053,7 +11307,7 @@ function statsMetricValue(entry, metric) {
 }
 
 function isTokenMetric(metric) {
-  return metric === 'tokens' || metric === 'tokens_input' || metric === 'tokens_output' || metric === 'tokens_cache' || metric === 'tokens_selected';
+  return metric === 'tokens' || metric === 'tokens_input' || metric === 'tokens_output' || metric === 'tokens_cache' || metric === 'tokens_reasoning' || metric === 'tokens_selected';
 }
 
 function statsActivityMetric() {
@@ -9391,7 +11645,12 @@ function renderStatsMetrics(payload) {
   const totalInTok = Number(payload.total_input_tokens || 0);
   const totalOutTok = Number(payload.total_output_tokens || 0);
   const totalCacheTok = Number(payload.total_cache_tokens || 0);
+  const totalReasonTok = Number(payload.total_reasoning_tokens || 0);
   const totalEstimatedTok = Number(payload.total_estimated_tokens || 0);
+  const sdkSessions = Number(payload.sdk_session_count || 0);
+  const sdkTokens = Number(payload.sdk_total_tokens || 0);
+  const sdkInputTokens = Number(payload.sdk_total_input_tokens || 0);
+  const sdkOutputTokens = Number(payload.sdk_total_output_tokens || 0);
   const um = Number(payload.user_message_count || 0);
   const tm = Number(payload.message_count || 0);
   const avgMsgs = Number(payload.avg_messages_per_conversation);
@@ -9401,6 +11660,7 @@ function renderStatsMetrics(payload) {
     const usageParts = [];
     if (totalInTok || totalOutTok) usageParts.push(formatCompactNumber(totalInTok) + ' in / ' + formatCompactNumber(totalOutTok) + ' out');
     if (totalCacheTok) usageParts.push(formatCompactNumber(totalCacheTok) + ' cache');
+    if (totalReasonTok) usageParts.push(formatCompactNumber(totalReasonTok) + ' reasoning');
     if (totalEstimatedTok) usageParts.push('~' + formatCompactNumber(totalEstimatedTok) + ' estimated');
     tokenSub = usageParts.join(' · ');
   } else {
@@ -9416,6 +11676,13 @@ function renderStatsMetrics(payload) {
       value: formatFullNumber(payload.session_count || 0),
       sub: formatFullNumber(payload.agent_session_count || 0) + ' agent · ' + formatFullNumber(payload.chat_session_count || 0) + ' chat'
     },
+    sdkSessions || sdkTokens ? {
+      label: 'SDK jobs',
+      value: formatFullNumber(sdkSessions),
+      sub: (sdkTokens ? formatCompactNumber(sdkTokens) + ' tokens' : '0 tokens') +
+        (sdkInputTokens || sdkOutputTokens ? ' · ' + formatCompactNumber(sdkInputTokens) + ' in / ' + formatCompactNumber(sdkOutputTokens) + ' out' : '') +
+        ' · kept separate'
+    } : null,
     {
       label: 'Messages',
       value: formatFullNumber(tm),
@@ -9472,6 +11739,7 @@ function renderStatsMetrics(payload) {
     }
   ];
   container.innerHTML = metrics
+    .filter(Boolean)
     .map(function (metric) {
       const vt =
         metric.valueHtml == null &&
@@ -9545,7 +11813,11 @@ function renderHeatmapSection(payload) {
   renderSecondaryHeatmap(payload.split_stats && payload.split_stats.agent, 'statsAgentActivitySub', 'statsAgentHeatmap', range, metric);
   renderSecondaryHeatmap(payload.split_stats && payload.split_stats.chat, 'statsChatActivitySub', 'statsChatHeatmap', range, metric, {
     emptySubText: '',
-    emptyText: 'No chat activity yet. Import ChatGPT or Claude.ai exports with agentlog import chatgpt <path> --scope local or agentlog import claude-web <path> --scope local.'
+    emptyText: 'No chat activity yet. Run agentlog import chatgpt or agentlog import claude-web for official export instructions.'
+  });
+  renderSecondaryHeatmap(payload.split_stats && payload.split_stats.sdk, 'statsSdkActivitySub', 'statsSdkHeatmap', range, metric, {
+    emptySubText: '',
+    emptyText: 'No SDK jobs imported. Import once with agentlog import --sources codex-sdk,claude-sdk --since all. Keep them updated with agentlog config sources add codex-sdk,claude-sdk.'
   });
 }
 
@@ -9780,15 +12052,11 @@ function renderDailyChart(elementId, daily, providers, metric, height) {
     return '<line class="stats-axis-line" x1="' + padding.left + '" x2="' + (padding.left + innerW) + '" y1="' + y.toFixed(2) + '" y2="' + y.toFixed(2) + '"/>'
       + '<text class="stats-axis-label" x="' + (padding.left - 6) + '" y="' + (y + 3).toFixed(2) + '" text-anchor="end">' + esc(formatCompactNumber(value)) + '</text>';
   }).join('');
-  let prevYm = '';
-  const xLabels = visibleDaily.map((day, idx) => {
-    const ym = day.date.slice(0, 7);
-    if (ym === prevYm) return '';
-    prevYm = ym;
-    const cx = padding.left + idx * xStep + xStep / 2;
-    const tick = formatChartMonthTick(day.date);
-    return '<text class="stats-axis-label" x="' + cx.toFixed(2) + '" y="' + (padding.top + innerH + 18) + '" text-anchor="middle">' + esc(tick) + '</text>';
-  }).join('');
+  const xLabels = dailyChartMonthTicks(visibleDaily, xStep, padding.left, innerW)
+    .map((tickEntry) =>
+      '<text class="stats-axis-label" x="' + tickEntry.x.toFixed(2) + '" y="' + (padding.top + innerH + 18) + '" text-anchor="middle">' + esc(tickEntry.label) + '</text>'
+    )
+    .join('');
   const hits = visibleDaily.map((day, dayIdx) => {
     const xHit = padding.left + dayIdx * xStep;
     return '<rect class="stats-chart-hit" pointer-events="all" x="' + xHit.toFixed(2) + '" y="' + padding.top + '" width="' + xStep.toFixed(2) + '" height="' + innerH.toFixed(2) + '" fill="transparent" data-day-index="' + dayIdx + '"/>';
@@ -9800,6 +12068,33 @@ function renderDailyChart(elementId, daily, providers, metric, height) {
   bindDailyChartHover(el);
 }
 
+function dailyChartMonthTicks(daily, xStep, left, innerW) {
+  const monthStarts = [];
+  let prevYm = '';
+  for (let idx = 0; idx < daily.length; idx += 1) {
+    const day = daily[idx];
+    const ym = String(day?.date || '').slice(0, 7);
+    if (!/^\\d{4}-\\d{2}$/.test(ym) || ym === prevYm) continue;
+    prevYm = ym;
+    monthStarts.push({ idx, date: day.date, ym });
+  }
+  const maxLabels = Math.max(2, Math.floor(innerW / 58));
+  const step = Math.max(1, Math.ceil(monthStarts.length / maxLabels));
+  const selected = [];
+  for (let idx = 0; idx < monthStarts.length; idx += step) selected.push(monthStarts[idx]);
+  const last = monthStarts[monthStarts.length - 1];
+  if (last && selected[selected.length - 1] !== last) {
+    const previous = selected[selected.length - 1];
+    if (previous && monthStarts.indexOf(previous) >= monthStarts.length - step) selected[selected.length - 1] = last;
+    else selected.push(last);
+  }
+  return selected
+    .map((entry) => ({
+      x: left + entry.idx * xStep + xStep / 2,
+      label: formatChartMonthTick(entry.date)
+    }));
+}
+
 function trimEmptyDailyChartEdges(daily, providers, metric) {
   const rows = Array.isArray(daily) ? daily : [];
   const hasValue = (day) => providers.some((provider) => statsMetricValue(day?.providers?.[provider], metric) > 0);
@@ -9909,7 +12204,7 @@ function setupCustomSelects() {
     const input = field.querySelector('input');
     const trigger = field.querySelector('.select-trigger');
     if (field.dataset.select === 'provider') hydrateProviderSelectOptions(field);
-    const options = Array.from(field.querySelectorAll('.select-option'));
+    const options = bindSelectFieldOptions(field);
     const selectedOption = options.find((item) => (item.dataset.value || '') === input.value) || options.find((item) => item.classList.contains('active')) || options[0];
     if (selectedOption) setSelectTriggerLabel(field, selectedOption);
     updateSelectFieldState(field);
@@ -9920,23 +12215,65 @@ function setupCustomSelects() {
       }
       field.classList.toggle('open');
     };
-    for (const option of options) {
-      option.onclick = (event) => {
-        event.stopPropagation();
-        input.value = option.dataset.value || '';
-        setSelectTriggerLabel(field, option);
-        options.forEach((item) => item.classList.toggle('active', item === option));
-        updateSelectFieldState(field);
-        field.classList.remove('open');
-        refreshForFilterChange();
-      };
-    }
   }
   document.addEventListener('click', () => {
     for (const field of document.querySelectorAll('.select-field.open')) field.classList.remove('open');
   });
 }
 
+function bindSelectFieldOptions(field) {
+  const input = field.querySelector('input');
+  const options = Array.from(field.querySelectorAll('.select-option'));
+  for (const option of options) {
+    option.onclick = (event) => {
+      event.stopPropagation();
+      input.value = option.dataset.value || '';
+      setSelectTriggerLabel(field, option);
+      options.forEach((item) => item.classList.toggle('active', item === option));
+      updateSelectFieldState(field);
+      field.classList.remove('open');
+      refreshForFilterChange();
+    };
+  }
+  return options;
+}
+
+function updateSourceFilterOptions(sourceOptions) {
+  const field = document.querySelector('.select-field[data-select="provider"]');
+  if (!field) return false;
+  const input = field.querySelector('input');
+  const menu = field.querySelector('.select-menu');
+  if (!input || !menu) return false;
+  const options = normalizeSourceFilterOptions(sourceOptions);
+  const current = input.value || '';
+  const values = new Set(options.map((option) => option.value));
+  const reset = Boolean(current && !values.has(current));
+  menu.innerHTML =
+    '<button class="select-option" type="button" data-value="" data-label="All sources">All sources</button>' +
+    options.map((option) =>
+      '<button class="select-option" type="button" data-value="' + esc(option.value) + '" data-label="' + esc(option.label) + '">' +
+      esc(option.label) +
+      '</button>'
+    ).join('');
+  hydrateProviderSelectOptions(field);
+  bindSelectFieldOptions(field);
+  setSelectValue('provider', reset ? '' : current);
+  return reset;
+}
+
+function normalizeSourceFilterOptions(sourceOptions) {
+  const seen = new Set();
+  const out = [];
+  for (const option of Array.isArray(sourceOptions) ? sourceOptions : []) {
+    const value = String(option?.value || option?.source || '').trim();
+    const label = String(option?.label || value).trim();
+    if (!value || seen.has(value)) continue;
+    seen.add(value);
+    out.push({ value, label: label || value });
+  }
+  return out;
+}
+
 function hydrateProviderSelectOptions(field) {
   for (const option of field.querySelectorAll('.select-option')) {
     if (!option.dataset.label) option.dataset.label = option.textContent.trim();
@@ -10017,6 +12354,12 @@ function setupKeyboardShortcuts() {
     const isInput = target && (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable);
 
     if (event.key === 'Escape') {
+      if (sessionModal && !sessionModal.hidden) {
+        closeSubagentModal();
+        event.preventDefault();
+        event.stopPropagation();
+        return;
+      }
       const searchInput = document.getElementById('q');
       if (searchInput && (searchInput.value || activeSearchTerm)) {
         searchInput.value = '';
@@ -10246,8 +12589,8 @@ Start here:
 Archive and import:
   init                                  interactive setup and optional first import
   import                                import local Codex, Claude, Gemini, Devin, Cursor, Cline, OpenCode, Aider, and Antigravity history
-  import chatgpt <path>                 import a ChatGPT export JSON/ZIP/folder
-  import claude-web <path>              import a Claude.ai export JSON/ZIP/folder
+  import chatgpt [path]                 guided ChatGPT export import; with path, import ZIP/folder
+  import claude-web [path]              guided Claude.ai export import; with path, import ZIP/folder
   import windsurf <path>                import downloaded Windsurf trajectory Markdown file/folder
   import accounts                       list or rename ChatGPT/Claude.ai export accounts
   sync                                  choose a remote, preview, confirm, then upload archive objects
@@ -10303,8 +12646,8 @@ agentlog import
 Usage:
   agentlog import --source <source> [--since 30d|all]
   agentlog import --sources <a,b,c> [--since 30d|all]
-  agentlog import chatgpt <path> [--username <name>] [--scope local|team]
-  agentlog import claude-web <path> [--username <name>] [--scope local|team]
+  agentlog import chatgpt [path] [--username <name>] [--scope local|team]
+  agentlog import claude-web [path] [--username <name>] [--scope local|team]
   agentlog import windsurf <file-or-folder>
   agentlog import accounts list
   agentlog import accounts rename <provider> <account-id-or-username> --display-name <name>
@@ -10312,6 +12655,7 @@ Usage:
 Import sources:
   codex-cli             terminal Codex sessions from Codex state and rollout files
   codex-desktop         Codex desktop app sessions from Codex state and rollout files
+  codex-sdk             high-volume Codex exec/SDK batch jobs; opt-in
   claude                interactive Claude Code CLI JSONL transcripts
   claude-code-desktop   Claude Code sessions launched from the Claude desktop app
   claude-workspace      Claude app workspace/local-agent sessions
@@ -10329,13 +12673,14 @@ Import sources:
   all                   configured default local sources
 
 Web export sources:
-  chatgpt               official ChatGPT export JSON/ZIP
-  claude-web            official Claude.ai export JSON/ZIP
+  chatgpt               guided import for ChatGPT/OpenAI export ZIPs or folders
+  claude-web            guided import for Claude.ai export ZIPs or folders
   windsurf              downloaded Cascade trajectory Markdown file/folder
 
 Examples:
   agentlog import --source codex-cli --since 30d
   agentlog import --source codex-desktop --since all
+  agentlog import --source codex-sdk --since all
   agentlog import --source claude --since 30d
   agentlog import --source claude-code-desktop --since all
   agentlog import --source claude-workspace --since all
@@ -10351,11 +12696,14 @@ Examples:
   agentlog import --source cursor --since all --explain-skips
   agentlog import --source cursor --since all --explain-skips --json
   agentlog import status --json
+  agentlog import chatgpt
+  agentlog import claude-web
   agentlog import chatgpt ~/Downloads/chatgpt-export.zip --username you@example.com
-  agentlog import claude-web ~/Downloads/claude-export --username brian --display-name Brian --scope local
+  agentlog import chatgpt "~/Downloads/OpenAI-export/User Online Activity" --username you@example.com
+  agentlog import claude-web ~/Downloads/claude-export --username you --display-name "Personal Claude" --scope local
   agentlog import windsurf ~/Downloads/cascade-chat-conversation.md
   agentlog import windsurf ~/windsurf-cascade-export
-  agentlog import accounts rename claude-web brian --display-name "Personal Claude"
+  agentlog import accounts rename claude-web you --display-name "Personal Claude"
 
 Details:
   --since accepts 30d, 12h, 60m, ISO dates, or all.
@@ -10363,7 +12711,9 @@ Details:
   --dry-run shows what would be imported without writing archive files.
   --explain-skips includes per-session skip reasons for supported sources.
   --json prints machine-readable import results.
-  In a terminal, web and Windsurf imports prompt for the export path when omitted.
+  ChatGPT and Claude.ai imports prompt for export paths and account labels when omitted in a terminal.
+  Use --instructions to print export instructions without starting the walkthrough.
+  Windsurf imports prompt for the export path when omitted in a terminal.
   Windsurf local cache scanning is disabled because current Cascade transcripts are encrypted binary stores. Use the Windsurf "Download trajectory" Markdown export with \`agentlog import windsurf <file-or-folder>\`.
   See docs/history-source-handling.md for source-specific storage paths.
 `;
@@ -10489,7 +12839,7 @@ Usage:
 Examples:
   agentlog accounts list
   agentlog accounts rename
-  agentlog accounts rename claude-web brian --display-name "Personal Claude"
+  agentlog accounts rename claude-web you --display-name "Personal Claude"
 `,
   config: `
 agentlog config
@@ -10723,7 +13073,7 @@ Usage:
   agentlog update [--yes] [--dry-run] [--since 30d|all] [--sources a,b,c] [--sync] [--no-index] [--no-restart]
 
 What it removes:
-  archive/index data                  local archive objects and search indexes
+  archive/index data                  local agent archive objects and search indexes
   import state                        file/session fingerprints so sources are read again
   cache/spool                         reveal cache and pending local spool files
   sync state                          local upload bookkeeping; remote objects are not deleted
@@ -10732,13 +13082,14 @@ What it keeps:
   config.json                         storage, source, sync, privacy, and watcher preferences
   redaction.yaml                      redaction rules
   web account labels                  ChatGPT/Claude.ai account display names
+  web chat archives                   manually imported ChatGPT/Claude.ai archive objects
   source histories                    Codex, Claude, Gemini, Devin, Cursor, etc. source data
   recall integrations                 agent command/skill files
 
 Options:
   --dry-run                           show targets and preferences without deleting or importing
   --yes                               skip confirmation
-  --since 30d|90d|all                 import window; defaults to imports.defaultSinceDays
+  --since 30d|90d|all                 import window; defaults to the saved rebuild window, then all
   --sources a,b,c                     override configured sources for this run
   --sync                              upload changed objects after reimport; use sync replace to remove stale remote objects
   --no-index                          skip rebuilding the search index
@@ -10897,13 +13248,19 @@ module.exports = {
   _historyWebInternals: {
     HISTORY_AUTH_COOKIE,
     constantTimeEqual,
+    filterShapeKey,
     historyHtml,
     isHistoryApiPath,
+    listSnapshotEtag,
+    memoizedStatsPayload,
     parseCookies,
     readSessionMarkdown,
     readSessionView,
+    resolveSessionAttachmentFile,
     resumeCommandForSession,
+    repoSessionsFilterKey,
     securityHeaders,
+    sessionTreePayload,
     sessionViewPayload,
     sessionCookie,
     statsPayload,