agentel 0.2.6 → 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,7 +18,7 @@ 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");
@@ -27,7 +27,19 @@ 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);
@@ -153,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();
@@ -170,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);
@@ -1445,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) {
@@ -1796,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();
@@ -1852,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) {
@@ -1907,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) {
@@ -2191,27 +2374,34 @@ async function importCommand(args, flags, env) {
     if (flags.instructions || flags.instruction || flags.docs) {
       return printWebExportInstructions(instructions, flags);
     }
-    let importFile = flags.file || args[1] || "";
-    if (!importFile) 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);
+    }
     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(instructions.source, 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 || "";
@@ -2850,6 +3239,7 @@ 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;
@@ -2873,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;
@@ -2900,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;
@@ -2912,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();
@@ -2934,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();
@@ -3015,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,
@@ -3037,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,
@@ -3083,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;
@@ -3135,6 +3528,7 @@ function statsPayloadForSessions(sessions, options = {}) {
     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,
@@ -3142,6 +3536,7 @@ function statsPayloadForSessions(sessions, options = {}) {
     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,
@@ -3261,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) {
@@ -3275,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;
 }
 
@@ -3282,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
   };
 }
 
@@ -3470,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"),
@@ -3478,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);
@@ -4852,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) {
@@ -5319,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)}`);
@@ -5584,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}
@@ -5670,8 +6643,22 @@ 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}
@@ -5687,6 +6674,35 @@ mark.search-match.search-match-current{background:#fde047;color:#422006;box-shad
 .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}
@@ -5959,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">
@@ -6054,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');
 
@@ -6071,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 = '';
@@ -6710,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,
@@ -6749,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() {
@@ -6964,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.');
@@ -7268,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>');
@@ -7283,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);
@@ -7312,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);
   }
@@ -7330,17 +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 || []);
-  const renderItems = pairedToolRenderItems(visibleMessages);
-  if (!renderItems.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);
@@ -7374,6 +8447,25 @@ 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);
@@ -7600,6 +8692,246 @@ function summarySourceLabel(source) {
   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-subagent-run-message';
+  const bubble = document.createElement('div');
+  bubble.className = 'bubble';
+  const details = document.createElement('details');
+  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('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(formatSubagentRunPlainText(run)));
+  const body = document.createElement('div');
+  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 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) {
   const diffSec = timeGapSeconds(previous, current);
   if (diffSec < 5) return null;
@@ -7693,18 +9025,20 @@ function highlightSearchMatches(root, term) {
 
 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, 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');
@@ -7729,7 +9063,7 @@ function messageElement(message, options = {}) {
     '<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);
@@ -7864,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'
   };
@@ -7917,6 +9252,86 @@ 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 > 1
@@ -8020,7 +9435,9 @@ function messageToolCalls(message, pairedResultMessages) {
   const eventCalls = canonicalEventsForMessage(message, 'tool.called').map(toolCallFromEvent).filter(Boolean);
   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) {
     const calls = metadataCalls.map((meta, index) => {
       const text = textCalls[index] || {};
@@ -8069,6 +9486,62 @@ function messageToolCalls(message, pairedResultMessages) {
   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
@@ -8515,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>'
   };
@@ -8553,22 +10027,23 @@ 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 || '',
@@ -8579,14 +10054,62 @@ function toolResultFromMetadata(result, indexed, fallbackText) {
     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;
@@ -8671,7 +10194,7 @@ function renderToolResult(result, options) {
 }
 
 function renderToolOutput(output, options = {}) {
-  const text = String(output || '');
+  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;
@@ -8864,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);
@@ -8877,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)) {
@@ -8904,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);
@@ -8913,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() {
@@ -9064,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() {
@@ -9262,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' });
@@ -9500,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) {
@@ -9509,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);
@@ -9593,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;
@@ -9647,7 +11278,7 @@ function renderStats(payload) {
 }
 
 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';
@@ -9676,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() {
@@ -10014,6 +11645,7 @@ 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);
@@ -10028,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 {
@@ -10184,7 +11817,7 @@ function renderHeatmapSection(payload) {
   });
   renderSecondaryHeatmap(payload.split_stats && payload.split_stats.sdk, 'statsSdkActivitySub', 'statsSdkHeatmap', range, metric, {
     emptySubText: '',
-    emptyText: 'No SDK jobs imported.'
+    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.'
   });
 }
 
@@ -10571,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);
@@ -10582,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();
@@ -10679,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 = '';
@@ -10908,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]                 show ChatGPT export instructions; with path, import a ZIP/folder
-  import claude-web [path]              show Claude.ai export instructions; with path, import a 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
@@ -10992,8 +12673,8 @@ Import sources:
   all                   configured default local sources
 
 Web export sources:
-  chatgpt               instructions for requesting a ChatGPT export; imports downloaded ZIP/folder
-  claude-web            instructions for requesting a Claude.ai export; imports downloaded ZIP/folder
+  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:
@@ -11018,10 +12699,11 @@ Examples:
   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.
@@ -11029,7 +12711,8 @@ 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.
-  ChatGPT and Claude.ai imports print export instructions when the path is 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.
@@ -11156,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
@@ -11390,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
@@ -11399,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
@@ -11564,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,