mixdog 1.4.0 → 1.4.2

package/src/session-runtime/conversation-import/discovery.mjs

@@ -1,7 +1,7 @@
 /**
  * Discovery of importable foreign conversations on disk (read-only).
  *
- *   codex   $CODEX_HOME/sessions/**\/rollout-*.jsonl   (default ~/.codex)
+ *   codex   $CODEX_HOME/sessions/**\/rollout-*.jsonl[.zst]   (default ~/.codex)
  *   claude  $CLAUDE_CONFIG_DIR/projects/*\/*.jsonl      (default ~/.claude)
  *
  * Enumeration is stat-only; per-file metadata (foreign id, cwd, title, and
@@ -13,7 +13,9 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { open, readdir, realpath, stat } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { basename, extname, isAbsolute, join, relative, resolve } from 'node:path';
+import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { pipeline } from 'node:stream';
+import zlib from 'node:zlib';
 import {
   IMPORT_MAX_FILE_BYTES,
   IMPORT_MAX_LINE_BYTES,
@@ -24,8 +26,15 @@ import {
   isImportSource,
 } from '../../runtime/agent/orchestrator/session/conversation-import/convert.mjs';
 import { codexMetaFromTruncatedLine } from '../../runtime/agent/orchestrator/session/conversation-import/codex.mjs';
-import { IMPORT_WARNING_CWD_MISSING } from '../../runtime/agent/orchestrator/session/conversation-import/turns.mjs';
+import {
+  IMPORT_ERROR_NEEDS_NEWER_NODE,
+  IMPORT_WARNING_CWD_MISSING,
+  IMPORT_WARNING_HISTORY_PARTIAL,
+  IMPORT_WARNING_HISTORY_SIZE_LIMIT,
+  IMPORT_WARNING_HISTORY_UNAVAILABLE,
+} from '../../runtime/agent/orchestrator/session/conversation-import/turns.mjs';
 import { importOriginKey } from '../../runtime/agent/orchestrator/session/conversation-import/imported-session.mjs';
+import { loadCodexThreadTitles } from './codex-titles.mjs';
 
 export const PREFIX_CHUNK_BYTES = 64 * 1024;
 export const PREFIX_MAX_BYTES = 512 * 1024;
@@ -49,10 +58,12 @@ const state = {
   queue: [],
   active: 0,
   views: new Map(), // viewId → view
+  scanMaxBytes: IMPORT_MAX_FILE_BYTES, // per-file budget of a sidechain-only scan
 };
 
-/** Test seam: forget every cached candidate, metadata entry and view. */
-export function resetConversationDiscovery() {
+/** Test seam: forget every cached candidate, metadata entry and view; `scanMaxBytes` overrides the scan budget. */
+export function resetConversationDiscovery({ scanMaxBytes = IMPORT_MAX_FILE_BYTES } = {}) {
+  state.scanMaxBytes = scanMaxBytes;
   state.candidates.clear();
   state.meta.clear();
   state.pendingMeta.clear();
@@ -74,6 +85,16 @@ export function requireSource(source) {
   return source;
 }
 
+/** Titles the source app stores per foreign session id (Codex only), read fresh; else null. */
+export function loadStoredTitles(source, env = process.env) {
+  return source === 'codex' ? loadCodexThreadTitles(dirname(sourceRoot(source, env))) : null;
+}
+
+/** The app's stored title of a conversation, else the one derived from its messages. */
+export function displayTitle(meta, titles) {
+  return (meta?.foreignSessionId && titles?.get(meta.foreignSessionId)) || meta?.title || null;
+}
+
 const caseFold = (value) => (process.platform === 'win32' ? value.toLowerCase() : value);
 
 function isInside(root, path) {
@@ -93,6 +114,51 @@ export function isNetworkOrDevicePath(path) {
 
 const fileIdentity = (info) => `${info.dev}:${info.ino}`;
 
+// Rollout file-name rules, as the source app applies them: a compressed rollout is a
+// name ending `.jsonl.zst`; a rollout name is, after dropping a `.zst` suffix,
+// `rollout-` … `.jsonl`. Both are case-sensitive.
+const COMPRESSED_ROLLOUT_SUFFIX = '.jsonl.zst';
+const isCompressed = (path) => basename(path).endsWith(COMPRESSED_ROLLOUT_SUFFIX);
+const isRolloutName = (name) => {
+  const plain = name.endsWith(COMPRESSED_ROLLOUT_SUFFIX) ? name.slice(0, -'.zst'.length) : name;
+  return plain.startsWith('rollout-') && plain.endsWith('.jsonl');
+};
+const zstdSupported = () => typeof zlib.createZstdDecompress === 'function';
+
+/**
+ * Sequential `read(buffer, offset, length, position)` / `close()` over the
+ * decompressed bytes of an open compressed file, shaped like a file handle so
+ * the line reader needs no other change. Positions must run on from the last
+ * read; closing stops the decompression.
+ */
+function zstdReader(handle) {
+  if (!zstdSupported()) throw importError(IMPORT_ERROR_NEEDS_NEWER_NODE);
+  const decoder = zlib.createZstdDecompress();
+  pipeline(handle.createReadStream({ autoClose: false }), decoder, () => {});
+  const chunks = decoder[Symbol.asyncIterator]();
+  let rest = Buffer.alloc(0);
+  let position = 0;
+  return {
+    async read(buffer, offset, length, from) {
+      if (from !== position) throw importError('unreadable');
+      if (!rest.length) {
+        const next = await chunks.next();
+        if (next.done) return { bytesRead: 0, buffer };
+        rest = next.value;
+      }
+      const bytesRead = Math.min(length, rest.length);
+      rest.copy(buffer, offset, 0, bytesRead);
+      rest = rest.subarray(bytesRead);
+      position += bytesRead;
+      return { bytesRead, buffer };
+    },
+    async close() {
+      decoder.destroy();
+      await handle.close();
+    },
+  };
+}
+
 export function candidateId(source, canonicalPath) {
   return createHash('sha256')
     .update(`${source}\0${caseFold(canonicalPath)}`)
@@ -131,7 +197,10 @@ async function walkCodex(rootReal, dir, files, seenDirs) {
         continue;
       }
     }
-    if (/^rollout-.*\.jsonl$/i.test(entry.name)) files.push(path);
+    if (!isRolloutName(entry.name)) continue;
+    // A compressed rollout is skipped while its plain sibling exists.
+    if (isCompressed(entry.name) && (await stat(path.slice(0, -'.zst'.length)).catch(() => null))) continue;
+    files.push(path);
   }
 }
 
@@ -227,6 +296,11 @@ function metaFromConversion(conversion, whole) {
     foreignSessionId: conversion.foreignSessionId,
     cwd: conversion.cwd,
     title: conversion.title,
+    // A Codex marker sits in the first line; a Claude transcript is sidechain-only only once read to the end.
+    internalKind: whole || conversion.source === 'codex' ? (conversion.internalKind ?? null) : null,
+    // Rollout id of the history base this file continues, else null.
+    historyBaseId:
+      typeof conversion.historyBase?.thread_id === 'string' ? conversion.historyBase.thread_id.toLowerCase() : null,
     messageCount: whole && !conversion.errorCode ? conversion.messageCount : null,
     warnings: whole ? conversion.warnings : conversion.warnings.filter((code) => code !== 'malformed'),
     errorCode: whole ? conversion.errorCode : null,
@@ -257,7 +331,7 @@ async function openCandidate(candidate) {
     ) {
       throw importError('unreadable');
     }
-    return handle;
+    return isCompressed(candidate.path) ? zstdReader(handle) : handle;
   } catch (error) {
     await handle.close();
     throw error;
@@ -324,42 +398,242 @@ async function streamJsonlLines(
   return outcome({ eof: true });
 }
 
+// Complete lines of the last prefix-chunk of a file (the cut-off first line dropped).
+async function readTailLines(handle, size) {
+  const length = Math.min(size, PREFIX_CHUNK_BYTES);
+  const buffer = Buffer.allocUnsafe(length);
+  const { bytesRead } = await handle.read(buffer, 0, length, size - length);
+  const text = buffer.subarray(0, bytesRead).toString('utf8');
+  return (size > length ? text.slice(text.indexOf('\n') + 1) : text).split('\n');
+}
+
+// Whether the rollout a listed file continues is absent (a stat-only search): its own records are then all there is to name and count.
+const baseIsMissing = async (candidate, meta) =>
+  !!meta.historyBaseId && !(await findRolloutById(dirname(candidate.root ?? sourceRoot('codex')), meta.historyBaseId));
+
 async function readPrefixMeta(candidate) {
   const converter = createConversationConverter(candidate.source);
   const handle = await openCandidate(candidate);
+  // Only the end of a Claude transcript proves it is sidechain-only, so while
+  // nothing but sidechain messages has been seen the scan streams on, line by
+  // line, to EOF or to the import file-size limit. A file over that limit stays
+  // unclassified (listed); importing it fails as tooLarge.
+  const claude = candidate.source === 'claude';
   let read;
   try {
     read = await streamJsonlLines(handle, (line) => converter.pushLine(line), {
-      maxLineBytes: PREFIX_MAX_BYTES,
+      maxLineBytes: claude ? IMPORT_MAX_LINE_BYTES : PREFIX_MAX_BYTES,
       chunkBytes: PREFIX_CHUNK_BYTES,
-      maxBytes: PREFIX_MAX_BYTES,
+      maxBytes: claude ? state.scanMaxBytes : PREFIX_MAX_BYTES,
       onChunk: (position) => {
         // A file read to its known size keeps going to EOF (whole-file metadata).
         if (position >= candidate.size) return true;
+        if (claude) {
+          if (converter.sidechainOnly) return true;
+          if (position >= PREFIX_MAX_BYTES) return false;
+        }
         const partial = converter.result();
         return !(partial.foreignSessionId && partial.cwd && partial.title);
       },
     });
+    // The stored title records sit near the end of a transcript.
+    if (claude && !read.eof) {
+      for (const line of await readTailLines(handle, candidate.size)) converter.pushTitleLine(line);
+    }
   } finally {
     await handle.close();
   }
   const conversion = converter.result();
-  if (read.eof) return metaFromConversion(conversion, true);
-  const meta = metaFromConversion(conversion, false);
+  // A thread continuing a history base is only counted, named and judged empty once the base is followed (on import).
+  const listing = async (meta) =>
+    conversion.historyBase && !(await baseIsMissing(candidate, meta))
+      ? { ...meta, title: null, messageCount: null, errorCode: meta.errorCode === 'empty' ? null : meta.errorCode }
+      : conversion.historyBase
+        ? { ...meta, warnings: [...meta.warnings, IMPORT_WARNING_HISTORY_UNAVAILABLE] }
+        : meta;
+  if (read.eof) return listing(metaFromConversion(conversion, true));
+  const meta = await listing(metaFromConversion(conversion, false));
   if (candidate.source === 'codex' && (!meta.foreignSessionId || !meta.cwd) && read.firstPartial) {
     // A session_meta line longer than the prefix still names its id/cwd.
     const fromLine = codexMetaFromTruncatedLine(read.firstPartial.replace(/^\uFEFF/, ''));
     meta.foreignSessionId ||= fromLine?.foreignSessionId || null;
     meta.cwd ||= fromLine?.cwd || null;
+    meta.internalKind ||= fromLine?.internalKind || null;
   }
   return meta;
 }
 
+// ── Codex history base chain ─────────────────────────────────────────────────
+const HISTORY_CHAIN_MAX_DEPTH = 32;
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const ROLLOUT_ID_RE = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl(?:\.zst)?$/i;
+
+/** Rollout id a rollout file name ends with (`…-<thread>.jsonl[.zst]` or `…-<thread>_<rollout>.jsonl[.zst]`). */
+const rolloutIdOf = (path) => {
+  const name = basename(path);
+  return isRolloutName(name) ? (name.match(ROLLOUT_ID_RE)?.[1].toLowerCase() ?? null) : null;
+};
+
+const META_CHUNK_BYTES = 8 * 1024;
+
+/**
+ * First JSON record of a candidate file (null when none completes within
+ * `maxBytes`, blank lines included, or it is not JSON) and the bytes read for it.
+ */
+async function firstRecord(candidate, { maxBytes, maxLineBytes }) {
+  const handle = await openCandidate(candidate);
+  try {
+    let first = null;
+    const read = await streamJsonlLines(
+      handle,
+      (line) => {
+        first = line.replace(/^\uFEFF/, '').trim();
+        return !first;
+      },
+      { maxLineBytes, chunkBytes: META_CHUNK_BYTES, maxBytes }
+    );
+    let record = null;
+    try {
+      record = first ? JSON.parse(first) : null;
+    } catch {
+      /* not a record */
+    }
+    return { record, bytes: read.bytesRead };
+  } finally {
+    await handle.close();
+  }
+}
+
+// Whether a cutoff, in (decompressed) file bytes, falls on a record boundary: the end of the file or just after a line feed.
+async function endsOnRecord(candidate, end) {
+  const compressed = isCompressed(candidate.path);
+  if (!compressed && end === candidate.size) return true;
+  const handle = await openCandidate(candidate);
+  try {
+    const byte = Buffer.alloc(1);
+    if (!compressed) {
+      const { bytesRead } = await handle.read(byte, 0, 1, end - 1);
+      return bytesRead === 1 && byte[0] === 10;
+    }
+    // The decompressed size is unknown: read up to the cutoff, then see whether the file ends there.
+    const chunk = Buffer.allocUnsafe(IMPORT_CHUNK_BYTES);
+    let position = 0;
+    let last = 0;
+    while (position < end) {
+      const { bytesRead } = await handle.read(chunk, 0, Math.min(chunk.length, end - position), position);
+      if (!bytesRead) return false;
+      position += bytesRead;
+      last = chunk[bytesRead - 1];
+    }
+    return last === 10 || (await handle.read(byte, 0, 1, position)).bytesRead === 0;
+  } finally {
+    await handle.close();
+  }
+}
+
+/** The rollout file with this rollout id under the live, then the archived, sessions folder (walking lists a plain file instead of its compressed sibling). */
+async function findRolloutById(home, rolloutId) {
+  for (const folder of ['sessions', 'archived_sessions']) {
+    let rootReal;
+    try {
+      rootReal = await realpath(join(home, folder));
+    } catch {
+      continue;
+    }
+    const paths = [];
+    await walkCodex(rootReal, rootReal, paths, new Set([caseFold(rootReal)]));
+    for (const path of paths) {
+      if (rolloutIdOf(path) !== rolloutId) continue;
+      const real = await containedRealpath(rootReal, path);
+      const info = real ? await stat(real).catch(() => null) : null;
+      if (info?.isFile()) {
+        return { source: 'codex', root: rootReal, path: real, size: info.size, fileId: fileIdentity(info) };
+      }
+    }
+  }
+  return null;
+}
+
+// Size of a compressed file once decompressed, counting no further than `cap`.
+async function decompressedLength(candidate, cap) {
+  const handle = await openCandidate(candidate);
+  try {
+    const chunk = Buffer.allocUnsafe(IMPORT_CHUNK_BYTES);
+    let length = 0;
+    while (length < cap) {
+      const { bytesRead } = await handle.read(chunk, 0, Math.min(chunk.length, cap - length), length);
+      if (!bytesRead) break;
+      length += bytesRead;
+    }
+    return length;
+  } finally {
+    await handle.close();
+  }
+}
+
+/**
+ * Rollouts a `history_base` leads to, nearest first, each with the byte offset
+ * its contribution ends at, and `metaBytes`, what reading their metadata took.
+ * Cutoffs and byte counts are of the decompressed rollout. Stops (`partial`,
+ * the warning code saying why) at a base that is missing or unreadable
+ * (`historyUnavailable`), that would take the total read (the file, the
+ * `spent` metadata reads so far, every cutoff and every metadata read) beyond
+ * `maxFileBytes` (`historySizeLimit`), or is not paginated, already visited,
+ * past the depth cap, with a cutoff that excludes the session metadata,
+ * passes the end of the file or does not end a record (`historyPartial`).
+ */
+async function resolveHistoryChain(candidate, firstBase, { maxFileBytes, maxLineBytes, spent }) {
+  const home = dirname(candidate.root ?? sourceRoot('codex'));
+  const seen = new Set([rolloutIdOf(candidate.path)]);
+  const segments = [];
+  // The file itself is reserved at its decompressed size, which only reading it tells.
+  let used =
+    (isCompressed(candidate.path) ? await decompressedLength(candidate, maxFileBytes) : candidate.size) + spent;
+  let metaBytes = 0;
+  const partial = (warning = IMPORT_WARNING_HISTORY_PARTIAL) => ({ segments, partial: warning, metaBytes });
+  for (let base = firstBase; base; ) {
+    const id = typeof base.thread_id === 'string' ? base.thread_id.toLowerCase() : '';
+    const end = base.end_byte_offset;
+    const ordinal = base.end_ordinal_exclusive;
+    if (!UUID_RE.test(id) || seen.has(id) || segments.length >= HISTORY_CHAIN_MAX_DEPTH) return partial();
+    seen.add(id);
+    if (!Number.isSafeInteger(ordinal) || ordinal <= 0 || !Number.isSafeInteger(end) || end <= 0) return partial();
+    const found = await findRolloutById(home, id);
+    if (!found) return partial(IMPORT_WARNING_HISTORY_UNAVAILABLE);
+    if (!isCompressed(found.path) && end > found.size) return partial();
+    if (used + end > maxFileBytes) return partial(IMPORT_WARNING_HISTORY_SIZE_LIMIT);
+    let head;
+    try {
+      if (!(await endsOnRecord(found, end))) return partial();
+      head = await firstRecord(found, { maxBytes: Math.min(end, maxFileBytes - used - end), maxLineBytes });
+    } catch (error) {
+      // A runtime without zstd names its own fix; any other failure to open or read the base is "unavailable".
+      return partial(
+        error?.code === IMPORT_ERROR_NEEDS_NEWER_NODE
+          ? IMPORT_ERROR_NEEDS_NEWER_NODE
+          : IMPORT_WARNING_HISTORY_UNAVAILABLE
+      );
+    }
+    used += end + head.bytes;
+    metaBytes += head.bytes;
+    if (head.record?.type !== 'session_meta' || head.record.payload?.history_mode !== 'paginated') return partial();
+    segments.push({ candidate: found, end });
+    const next = head.record.payload.history_base;
+    base = next && typeof next === 'object' ? next : null;
+  }
+  return { segments, partial: null, metaBytes };
+}
+
 /**
  * Stream-convert a whole candidate file under the import limits. A file over
  * `maxFileBytes`, a line over `maxLineBytes` or a conversion over the
  * converter's limits fails the file with `tooLarge` without reading the rest.
- * `bytesRead` is how far the read got.
+ * A Codex rollout continuing a `history_base` is preceded by the records of
+ * each base up to its cutoff, oldest first (their session metadata dropped),
+ * all within the one `maxFileBytes` (counted in decompressed bytes for a
+ * compressed rollout); a base that cannot be followed leaves a `historyPartial`,
+ * `historySizeLimit` or `historyUnavailable` warning. `bytesRead` is how far
+ * the read got.
  */
 export async function convertCandidateFile(
   candidate,
@@ -377,32 +651,74 @@ export async function convertCandidateFile(
     maxRetainedEntries,
     maxMetadataBytes,
   });
+  // Bytes read beyond the file itself: metadata pre-reads and the bases' cutoffs. All count against `maxFileBytes`.
+  let inheritedBytes = 0;
+  if (candidate.source === 'codex') {
+    const head = await firstRecord(candidate, { maxBytes: maxFileBytes, maxLineBytes });
+    const base = head.record?.payload?.history_base;
+    if (base && typeof base === 'object') {
+      inheritedBytes += head.bytes;
+      const chain =
+        head.record.payload.history_mode === 'paginated'
+          ? await resolveHistoryChain(candidate, base, { maxFileBytes, maxLineBytes, spent: inheritedBytes })
+          : { segments: [], partial: IMPORT_WARNING_HISTORY_PARTIAL, metaBytes: 0 };
+      inheritedBytes += chain.metaBytes;
+      const { segments, partial } = chain;
+      if (partial) converter.markHistoryPartial(partial);
+      for (const { candidate: baseFile, end } of segments.reverse()) {
+        const baseHandle = await openCandidate(baseFile);
+        try {
+          const read = await streamJsonlLines(baseHandle, (line) => converter.pushLine(line, { inherited: true }), {
+            maxLineBytes,
+            chunkBytes,
+            maxBytes: end,
+          });
+          if (read.overflow) converter.markTooLarge();
+          inheritedBytes += read.bytesRead;
+        } finally {
+          await baseHandle.close();
+        }
+      }
+    }
+  }
   const handle = await openCandidate(candidate);
   try {
     const read = await streamJsonlLines(handle, (line) => converter.pushLine(line), {
       maxLineBytes,
       chunkBytes,
-      maxBytes: maxFileBytes,
+      maxBytes: maxFileBytes - inheritedBytes,
     });
     if (read.overflow || read.truncated) converter.markTooLarge();
-    return { ...converter.result(), bytesRead: read.bytesRead };
+    return { ...converter.result(), bytesRead: read.bytesRead + inheritedBytes };
   } finally {
     await handle.close();
   }
 }
 
+// On a runtime without zstd, a listed conversation whose history base is compressed says so on its row.
+async function withCompressedBaseNotice(candidate, meta) {
+  if (!meta.historyBaseId || zstdSupported()) return meta;
+  const found = await findRolloutById(dirname(candidate.root ?? sourceRoot('codex')), meta.historyBaseId);
+  return found && isCompressed(found.path)
+    ? { ...meta, warnings: [...meta.warnings, IMPORT_ERROR_NEEDS_NEWER_NODE] }
+    : meta;
+}
+
 function pumpMetaQueue() {
   while (state.active < META_CONCURRENCY && state.queue.length) {
     const job = state.queue.shift();
     state.active += 1;
     readPrefixMeta(job.candidate)
-      .catch(() => ({
+      .then((meta) => withCompressedBaseNotice(job.candidate, meta))
+      .catch((error) => ({
         foreignSessionId: null,
         cwd: null,
         title: null,
+        internalKind: null,
+        historyBaseId: null,
         messageCount: null,
         warnings: [],
-        errorCode: 'unreadable',
+        errorCode: error?.code === IMPORT_ERROR_NEEDS_NEWER_NODE ? IMPORT_ERROR_NEEDS_NEWER_NODE : 'unreadable',
       }))
       .then((value) => {
         state.meta.set(job.candidate.path, { stampKey: stampKey(job.candidate), value });
@@ -470,14 +786,14 @@ export function importedKeyMap(summaries) {
   return map;
 }
 
-function rowFor(candidate, meta, cwdInfo, imported) {
+function rowFor(candidate, meta, cwdInfo, imported, titles) {
   const warnings = new Set(meta?.warnings || []);
   if (meta && !meta.errorCode && !cwdInfo?.exists) warnings.add(IMPORT_WARNING_CWD_MISSING);
   if (meta?.errorCode) warnings.add(meta.errorCode);
   return {
     id: candidate.id,
     source: candidate.source,
-    title: meta?.title ?? null,
+    title: displayTitle(meta, titles),
     cwd: cwdInfo?.path ?? null,
     modifiedAt: candidate.mtimeMs,
     messageCount: meta?.messageCount ?? null,
@@ -486,10 +802,10 @@ function rowFor(candidate, meta, cwdInfo, imported) {
   };
 }
 
-export async function buildRow(candidate, imported, cwdCache = new Map()) {
+async function buildRow(candidate, imported, cwdCache = new Map(), titles = null) {
   const meta = cachedMeta(candidate);
   const cwdInfo = meta?.cwd ? await resolveSourceCwd(meta.cwd, cwdCache) : null;
-  return rowFor(candidate, meta, cwdInfo, imported);
+  return rowFor(candidate, meta, cwdInfo, imported, titles);
 }
 
 // ── views & paging ───────────────────────────────────────────────────────────
@@ -553,7 +869,7 @@ async function pageResult(view, offset, limit, imported) {
   const rows = [];
   for (const id of ids) {
     const candidate = state.candidates.get(id);
-    if (candidate) rows.push(await buildRow(candidate, imported, cwdCache));
+    if (candidate) rows.push(await buildRow(candidate, imported, cwdCache, view.titles));
   }
   const nextOffset = offset + ids.length;
   return {
@@ -568,31 +884,76 @@ async function pageResult(view, offset, limit, imported) {
   };
 }
 
+/**
+ * Ids of Codex rollouts that an earlier revision of the same thread (same
+ * session id) names as its history base. Codex lists one rollout per thread,
+ * the current one, so these stay out of the list; a fork's parent is another
+ * thread and stays listed.
+ */
+function supersededBaseIds(candidates) {
+  const byRollout = new Map();
+  for (const candidate of candidates) {
+    const meta = cachedMeta(candidate);
+    const rolloutId = candidate.source === 'codex' ? rolloutIdOf(candidate.path) : null;
+    if (meta?.foreignSessionId && rolloutId) byRollout.set(`${meta.foreignSessionId}\0${rolloutId}`, candidate.id);
+  }
+  const hidden = new Set();
+  for (const candidate of candidates) {
+    const meta = cachedMeta(candidate);
+    const base = meta?.historyBaseId && byRollout.get(`${meta.foreignSessionId}\0${meta.historyBaseId}`);
+    if (base && base !== candidate.id) hidden.add(base);
+  }
+  // A cycle of revisions must not hide a thread entirely: its newest one (first in order) stays.
+  const newest = new Map();
+  const visible = new Set();
+  const indexed = new Set(byRollout.values());
+  for (const candidate of candidates) {
+    const sessionId = cachedMeta(candidate)?.foreignSessionId;
+    if (!sessionId || !indexed.has(candidate.id)) continue;
+    if (!newest.has(sessionId)) newest.set(sessionId, candidate.id);
+    if (!hidden.has(candidate.id)) visible.add(sessionId);
+  }
+  for (const [sessionId, id] of newest) if (!visible.has(sessionId)) hidden.delete(id);
+  return hidden;
+}
+
 /**
  * Apply a view's filters (time range, query on title/cwd, project) to
  * candidates using their cached metadata; a candidate whose metadata is still
- * pending cannot match a query or project and leaves the result incomplete.
+ * pending is neither a member nor counted and leaves the result incomplete.
+ * The source app's internal and empty records are never members.
  */
-async function filterCandidates(candidates, filters, imported) {
+async function filterCandidates(candidates, filters, imported, titles) {
   const { needle, projectFilter, modifiedAfter, modifiedBefore } = filters;
   const cwdCache = new Map();
   const memberIds = [];
   const selectableIds = [];
   const projectCounts = new Map();
   let complete = true;
+  const superseded = supersededBaseIds(candidates);
   for (const candidate of candidates) {
+    if (superseded.has(candidate.id)) continue;
     if (modifiedAfter !== null && candidate.mtimeMs < modifiedAfter) continue;
     if (modifiedBefore !== null && candidate.mtimeMs > modifiedBefore) continue;
     const meta = cachedMeta(candidate);
-    if (!meta) complete = false;
-    const cwdInfo = meta?.cwd ? await resolveSourceCwd(meta.cwd, cwdCache) : null;
-    if (needle && (!meta || !(foldText(meta.title).includes(needle) || foldText(cwdInfo?.path).includes(needle)))) {
+    // Unclassified yet: neither a member nor counted until its metadata is read.
+    if (!meta) {
+      complete = false;
+      continue;
+    }
+    // The source app's own records and files read to the end without a message are not conversations.
+    if (meta.internalKind || meta.errorCode === 'empty') continue;
+    const cwdInfo = meta.cwd ? await resolveSourceCwd(meta.cwd, cwdCache) : null;
+    if (
+      needle &&
+      !(foldText(displayTitle(meta, titles)).includes(needle) || foldText(cwdInfo?.path).includes(needle))
+    ) {
       continue;
     }
     if (cwdInfo?.path) projectCounts.set(cwdInfo.path, (projectCounts.get(cwdInfo.path) || 0) + 1);
     if (projectFilter && !samePath(cwdInfo?.path, projectFilter)) continue;
     // Already-imported conversations are left out of the list entirely.
-    if (meta && imported.has(candidateKey(candidate, meta))) continue;
+    if (imported.has(candidateKey(candidate, meta))) continue;
     memberIds.push(candidate.id);
     selectableIds.push(candidate.id);
   }
@@ -624,7 +985,9 @@ export async function listConversations(params, { imported, env = process.env }
     projectFilter: typeof project === 'string' && project.trim() ? project.trim() : null,
   };
   const { root, candidates } = await enumerateCandidates(source, env);
+  const titles = await loadStoredTitles(source, env);
   // Background metadata for everything, newest first; the first page is awaited.
+  // Candidates still unclassified stay out of the view (it is incomplete) and join it on a later listing.
   for (const candidate of candidates) void resolveMeta(candidate);
   if (!filters.needle && !filters.projectFilter) await Promise.all(candidates.slice(0, limit).map(resolveMeta));
   const view = {
@@ -632,8 +995,9 @@ export async function listConversations(params, { imported, env = process.env }
     source,
     root,
     filters,
+    titles,
     candidateIds: candidates.map((candidate) => candidate.id),
-    ...(await filterCandidates(candidates, filters, imported)),
+    ...(await filterCandidates(candidates, filters, imported, titles)),
     touchedAt: Date.now(),
   };
   state.views.set(view.id, view);
@@ -651,21 +1015,22 @@ export async function resolveViewSelection(viewId, excludeIds, imported) {
   const view = requireView(viewId);
   const candidates = view.candidateIds.map((id) => state.candidates.get(id)).filter(Boolean);
   await Promise.all(candidates.map(resolveMeta));
-  const { selectableIds } = await filterCandidates(candidates, view.filters, imported);
+  const { selectableIds } = await filterCandidates(candidates, view.filters, imported, view.titles);
   const excluded = new Set(Array.isArray(excludeIds) ? excludeIds : []);
   return selectableIds.filter((id) => !excluded.has(id));
 }
 
 // ── picked files ─────────────────────────────────────────────────────────────
-/** Validate and register a file chosen in a native picker (a local regular .jsonl). */
-export async function registerFile({ source, path } = {}, { imported, limits } = {}) {
+/** Validate and register a file chosen in a native picker (a local regular .jsonl, or a Codex .jsonl.zst). */
+export async function registerFile({ source, path } = {}, { imported, limits, env = process.env } = {}) {
   requireSource(source);
   if (typeof path !== 'string' || !path.trim() || path.includes('\0')) throw importError('invalidPath');
   const requested = path.trim();
   // Network/device forms are refused before any filesystem call.
   if (isNetworkOrDevicePath(requested)) throw importError('unsupported');
   if (!isAbsolute(requested)) throw importError('invalidPath');
-  if (extname(basename(requested)).toLowerCase() !== '.jsonl') throw importError('unsupported');
+  const pickable = (path) => /\.jsonl$/i.test(path) || (source === 'codex' && isCompressed(path));
+  if (!pickable(basename(requested))) throw importError('unsupported');
   let real;
   let info;
   try {
@@ -674,7 +1039,7 @@ export async function registerFile({ source, path } = {}, { imported, limits } =
   } catch {
     throw importError('unreadable');
   }
-  if (isNetworkOrDevicePath(real) || !info.isFile() || extname(real).toLowerCase() !== '.jsonl') {
+  if (isNetworkOrDevicePath(real) || !info.isFile() || !pickable(basename(real))) {
     throw importError('unsupported');
   }
   const candidate = registerCandidate({
@@ -689,10 +1054,10 @@ export async function registerFile({ source, path } = {}, { imported, limits } =
   let conversion;
   try {
     conversion = await convertCandidateFile(candidate, limits);
-  } catch {
-    throw importError('unreadable');
+  } catch (error) {
+    throw importError(error?.code === IMPORT_ERROR_NEEDS_NEWER_NODE ? IMPORT_ERROR_NEEDS_NEWER_NODE : 'unreadable');
   }
   if (conversion.errorCode) throw importError(conversion.errorCode);
   recordConversion(candidate, conversion);
-  return { row: await buildRow(candidate, imported) };
+  return { row: await buildRow(candidate, imported, new Map(), await loadStoredTitles(source, env)) };
 }