mixdog 1.3.5 → 1.4.1

package/src/session-runtime/conversation-import/codex-titles.mjs

@@ -0,0 +1,88 @@
+/**
+ * The thread titles Codex itself stores, by thread id (read-only):
+ *
+ *   state_<N>.sqlite   `threads.title`, overridden by `threads.name` (a rename)
+ *   session_index.jsonl  append-only `{ id, thread_name }`; the latest
+ *                        non-empty name of an id wins and overrides the DB
+ *
+ * Anything unreadable is skipped: a missing or locked store simply leaves the
+ * conversation to the title derived from its messages.
+ */
+import { DatabaseSync } from 'node:sqlite';
+import { readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { titleFromText } from '../../runtime/agent/orchestrator/session/conversation-import/turns.mjs';
+
+const STATE_DB_RE = /^state_(\d+)\.sqlite$/i;
+
+async function newestStateDb(home) {
+  let newest = null;
+  for (const name of await readdir(home).catch(() => [])) {
+    const version = STATE_DB_RE.exec(name)?.[1];
+    if (version !== undefined && (!newest || Number(version) > newest.version)) {
+      newest = { name, version: Number(version) };
+    }
+  }
+  return newest ? join(home, newest.name) : null;
+}
+
+function readStateRows(path) {
+  const db = new DatabaseSync(path, { readOnly: true });
+  try {
+    const columns = new Set(
+      db
+        .prepare('PRAGMA table_info(threads)')
+        .all()
+        .map((column) => column.name)
+    );
+    const wanted = ['title', 'name'].filter((column) => columns.has(column));
+    if (!wanted.length) return [];
+    return db.prepare(`SELECT id, ${wanted.join(', ')} FROM threads`).all();
+  } finally {
+    db.close();
+  }
+}
+
+async function readStateTitles(home, titles) {
+  try {
+    const path = await newestStateDb(home);
+    if (!path) return;
+    const rows = readStateRows(path);
+    for (const column of ['title', 'name']) {
+      for (const row of rows) {
+        const title = titleFromText(row[column]);
+        if (title && typeof row.id === 'string') titles.set(row.id, title);
+      }
+    }
+  } catch {
+    /* unreadable store: fall back to the session index and derived titles */
+  }
+}
+
+async function readIndexTitles(home, titles) {
+  let text;
+  try {
+    text = await readFile(join(home, 'session_index.jsonl'), 'utf8');
+  } catch {
+    return;
+  }
+  for (const line of text.split('\n')) {
+    if (!line.trim()) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const title = titleFromText(entry?.thread_name);
+    if (title && typeof entry.id === 'string') titles.set(entry.id, title);
+  }
+}
+
+/** Map of Codex thread id → its stored title (whitespace-normalized, ≤100 chars). */
+export async function loadCodexThreadTitles(home) {
+  const titles = new Map();
+  await readStateTitles(home, titles);
+  await readIndexTitles(home, titles);
+  return titles;
+}

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

@@ -13,7 +13,7 @@
 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, extname, isAbsolute, join, relative, resolve } from 'node:path';
 import {
   IMPORT_MAX_FILE_BYTES,
   IMPORT_MAX_LINE_BYTES,
@@ -26,6 +26,7 @@ import {
 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 { 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 +50,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 +77,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) {
@@ -227,6 +240,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,
@@ -324,42 +342,190 @@ 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');
+}
+
 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 = (meta) =>
+    conversion.historyBase
+      ? { ...meta, title: null, messageCount: null, errorCode: meta.errorCode === 'empty' ? null : meta.errorCode }
+      : meta;
+  if (read.eof) return listing(metaFromConversion(conversion, true));
+  const meta = 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$/i;
+
+/** Rollout id a rollout file name ends with (`…-<thread>.jsonl` or `…-<thread>_<rollout>.jsonl`). */
+const rolloutIdOf = (path) => basename(path).match(ROLLOUT_ID_RE)?.[1].toLowerCase() ?? 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 falls on a record boundary: the end of the file or just after a line feed.
+async function endsOnRecord(candidate, end) {
+  if (end === candidate.size) return true;
+  const handle = await openCandidate(candidate);
+  try {
+    const byte = Buffer.alloc(1);
+    const { bytesRead } = await handle.read(byte, 0, 1, end - 1);
+    return bytesRead === 1 && byte[0] === 10;
+  } finally {
+    await handle.close();
+  }
+}
+
+/** The plain rollout file with this rollout id under the live, then the archived, sessions folder. */
+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;
+}
+
+/**
+ * Rollouts a `history_base` leads to, nearest first, each with the byte offset
+ * its contribution ends at, and `metaBytes`, what reading their metadata took.
+ * Stops (`partial`) at a base that is missing, unreadable (compressed rollouts
+ * are not read), 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, or that would take the total read (the file, the
+ * `spent` metadata reads so far, every cutoff and every metadata read) beyond
+ * `maxFileBytes`.
+ */
+async function resolveHistoryChain(candidate, firstBase, { maxFileBytes, maxLineBytes, spent }) {
+  const home = dirname(candidate.root ?? sourceRoot('codex'));
+  const seen = new Set([rolloutIdOf(candidate.path)]);
+  const segments = [];
+  let used = candidate.size + spent;
+  let metaBytes = 0;
+  const partial = () => ({ segments, partial: true, 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 || end > found.size || used + end > maxFileBytes) return partial();
+    let head;
+    try {
+      if (!(await endsOnRecord(found, end))) return partial();
+      head = await firstRecord(found, { maxBytes: Math.min(end, maxFileBytes - used - end), maxLineBytes });
+    } catch {
+      return partial();
+    }
+    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: false, 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`; a base that cannot be followed leaves the
+ * `historyPartial` warning. `bytesRead` is how far the read got.
  */
 export async function convertCandidateFile(
   candidate,
@@ -377,15 +543,45 @@ 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: true, metaBytes: 0 };
+      inheritedBytes += chain.metaBytes;
+      const { segments, partial } = chain;
+      if (partial) converter.markHistoryPartial();
+      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();
   }
@@ -400,6 +596,8 @@ function pumpMetaQueue() {
         foreignSessionId: null,
         cwd: null,
         title: null,
+        internalKind: null,
+        historyBaseId: null,
         messageCount: null,
         warnings: [],
         errorCode: 'unreadable',
@@ -470,14 +668,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 +684,10 @@ function rowFor(candidate, meta, cwdInfo, imported) {
   };
 }
 
-export async function buildRow(candidate, imported, cwdCache = new Map()) {
+export 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 +751,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 +766,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 +867,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 +877,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,14 +897,14 @@ 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 } = {}) {
+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();
@@ -694,5 +940,5 @@ export async function registerFile({ source, path } = {}, { imported, limits } =
   }
   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)) };
 }

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

@@ -14,6 +14,7 @@
  */
 import { randomUUID } from 'node:crypto';
 import { access, stat } from 'node:fs/promises';
+import { basename } from 'node:path';
 import {
   buildImportOrigin,
   createImportedSession,
@@ -24,10 +25,12 @@ import { sessionPath } from '../../runtime/agent/orchestrator/session/store/sess
 import {
   cachedMeta,
   convertCandidateFile,
+  displayTitle,
   getCandidate,
   importError,
   importedKeyMap,
   listConversations,
+  loadStoredTitles,
   recordConversion,
   registerFile,
   resolveSourceCwd,
@@ -131,6 +134,17 @@ function touch(job, patch = {}) {
 
 const COUNTER = { imported: 'imported', alreadyImported: 'skippedAlreadyImported', failed: 'failed' };
 
+const titlesFor = (candidate, context) => (candidate.source === 'codex' ? context.titles : null);
+
+/** Which record a result is about: its title and source file name, for the failure report. */
+function describeCandidate(candidateId, context) {
+  const candidate = getCandidate(candidateId);
+  return {
+    title: candidate ? displayTitle(cachedMeta(candidate), titlesFor(candidate, context)) : null,
+    sourceName: candidate ? basename(candidate.path) : null,
+  };
+}
+
 function record(job, { projectPath = null, ...result }) {
   const counter = COUNTER[result.status];
   job[counter] += 1;
@@ -162,6 +176,7 @@ async function importOne(candidateId, context) {
   if (!candidate) return failed(candidateId, 'unknownCandidate');
   // The chat keeps the title the user picked it by: a long file's listing
   // title comes from its prefix and can differ from the converted branch.
+  // Codex's own stored title, when it has one, names the chat first.
   const listedTitle = cachedMeta(candidate)?.title ?? null;
   let conversion;
   try {
@@ -173,7 +188,11 @@ async function importOne(candidateId, context) {
   } catch {
     return failed(candidateId, 'unreadable');
   }
-  if (listedTitle) conversion = { ...conversion, title: listedTitle };
+  const title = displayTitle(
+    { foreignSessionId: conversion.foreignSessionId, title: listedTitle || conversion.title },
+    titlesFor(candidate, context)
+  );
+  if (title) conversion = { ...conversion, title };
   recordConversion(candidate, conversion);
   const cwdInfo = await resolveSourceCwd(conversion.cwd);
   const projectPath = cwdInfo.exists ? cwdInfo.path : null;
@@ -221,6 +240,7 @@ async function runJob(job, candidateIds, context) {
   try {
     // One catalog read per batch; later commits are seen through committedKeys.
     context.imported = await context.importedLookup();
+    context.titles = await context.loadTitles();
     for (const candidateId of candidateIds) {
       if (job.cancelRequested) break;
       let result;
@@ -228,8 +248,7 @@ async function runJob(job, candidateIds, context) {
         result = await admit(async () => {
           // A cancel that arrived while queued behind other jobs wins here.
           if (job.cancelRequested) return null;
-          const candidate = getCandidate(candidateId);
-          touch(job, { current: { candidateId, title: (candidate && cachedMeta(candidate)?.title) ?? null } });
+          touch(job, { current: { candidateId, title: describeCandidate(candidateId, context).title } });
           try {
             return await importOne(candidateId, context);
           } finally {
@@ -241,7 +260,7 @@ async function runJob(job, candidateIds, context) {
         result = failed(candidateId, 'importFailed');
       }
       if (result === null) break;
-      record(job, result);
+      record(job, { ...result, ...describeCandidate(candidateId, context) });
     }
     touch(job, { state: job.cancelRequested ? 'stopped' : 'completed' });
   } catch (error) {
@@ -296,7 +315,7 @@ export function createConversationImportApi({
       return listConversations(requireParams(params), { imported: await imported(), env });
     },
     async registerConversationImportFile(params) {
-      return registerFile(requireParams(params), { imported: await imported(), limits });
+      return registerFile(requireParams(params), { imported: await imported(), limits, env });
     },
     getConversationImportJobs(params = {}) {
       const { jobId } = requireParams(params ?? {});
@@ -334,6 +353,8 @@ export function createConversationImportApi({
           void runJob(job, candidateIds, {
             importedLookup: imported,
             imported: null,
+            titles: null,
+            loadTitles: () => loadStoredTitles('codex', env),
             sessionExists,
             limits,
             prepareLeadOptions,