create-walle 0.9.21 → 0.9.23

package/template/claude-task-manager/lib/session-history.js

@@ -4,11 +4,28 @@ const fs = require('fs');
 const path = require('path');
 const { StringDecoder } = require('string_decoder');
 const { getResumeSpec: getAgentResumeSpec, normalizeAgentType } = require('./agent-capabilities');
+const structuredCapture = require('./structured-capture');
+const codexZst = require('./codex-zst');
 
 const DEFAULT_CODEX_LOOKBACK_SEC = 10;
 const DEFAULT_CODEX_MAX_DELAY_SEC = 180;
 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 CODEX_ROLLOUT_BASENAME_RE = /^rollout-(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2})-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl(?:\.bak)?$/i;
+const CODEX_ROLLOUT_BASENAME_RE = /^rollout-(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2})-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl(?:\.bak)?(?:\.zst)?$/i;
+
+// Rollout candidates on disk: live `.jsonl` plus zstd-compressed cold
+// archives (`.jsonl.zst`) that newer Codex versions write.
+function isCodexRolloutCandidateName(name) {
+  const n = String(name || '');
+  return n.endsWith('.jsonl') || codexZst.isZstRolloutFileName(n);
+}
+
+// Compressed archives are materialized to a disk cache before any read; a
+// failure (no zstd, too large) makes the file invisible to the reader.
+function _codexReadablePath(filePath) {
+  if (!codexZst.isZstRolloutFileName(filePath)) return filePath;
+  const mat = codexZst.materializeCodexRollout(filePath);
+  return mat.ok ? mat.path : null;
+}
 
 function getResumeSpec(agentType, resumeId) {
   return getAgentResumeSpec(agentType || 'claude', resumeId);
@@ -151,7 +168,7 @@ function findCodexSessionFiles(threadId, sessionsRoot, homeDir = process.env.HOM
       if (entry.isFile() && codexRolloutIdFromPath(fullPath) === wanted) {
         if (!codexRolloutFileMatchesThread(fullPath, wanted)) continue;
         matches.push(fullPath);
-      } else if (entry.isFile() && entry.name.endsWith('.jsonl')) {
+      } else if (entry.isFile() && isCodexRolloutCandidateName(entry.name)) {
         metadataFallbackCandidates.push(fullPath);
       }
     }
@@ -161,7 +178,7 @@ function findCodexSessionFiles(threadId, sessionsRoot, homeDir = process.env.HOM
       if (codexRolloutFileMatchesThread(fullPath, wanted)) matches.push(fullPath);
     }
   }
-  const sorted = sortCodexRolloutFiles(matches);
+  const sorted = sortCodexRolloutFiles(codexZst.dropZstWithLiveSibling(matches));
   return indexedPathMatchesWanted
     ? [indexedPath, ...sorted.filter((filePath) => filePath !== indexedPath)]
     : sorted;
@@ -188,7 +205,7 @@ function findCodexSessionFilesByFilename(threadId, sessionsRoot, homeDir = proce
       }
     }
   }
-  return sortCodexRolloutFiles(matches);
+  return sortCodexRolloutFiles(codexZst.dropZstWithLiveSibling(matches));
 }
 
 function parseSessionStartMs(value) {
@@ -454,10 +471,10 @@ function repairCodexStateThreadRollout(threadId, expectedRolloutPath, opts = {})
   const wanted = String(threadId || '').trim().toLowerCase();
   const rolloutPath = String(expectedRolloutPath || '').trim();
   const homeDir = opts.homeDir || process.env.HOME;
-  if (!UUID_RE.test(wanted)) return { ok: false, repaired: false, mismatch: false, reason: 'invalid_thread_id' };
-  if (!rolloutPath || !fs.existsSync(rolloutPath)) return { ok: false, repaired: false, mismatch: false, reason: 'expected_rollout_missing' };
-  if (codexRolloutIdFromPath(rolloutPath) !== wanted) return { ok: false, repaired: false, mismatch: false, reason: 'expected_rollout_filename_mismatch' };
-  if (!codexRolloutFileMatchesThread(rolloutPath, wanted)) return { ok: false, repaired: false, mismatch: false, reason: 'expected_rollout_metadata_mismatch' };
+  if (!UUID_RE.test(wanted)) return { ok: false, repaired: false, mismatch: false, blocked: false, reason: 'invalid_thread_id' };
+  if (!rolloutPath || !fs.existsSync(rolloutPath)) return { ok: false, repaired: false, mismatch: false, blocked: false, reason: 'expected_rollout_missing' };
+  if (codexRolloutIdFromPath(rolloutPath) !== wanted) return { ok: false, repaired: false, mismatch: false, blocked: false, reason: 'expected_rollout_filename_mismatch' };
+  if (!codexRolloutFileMatchesThread(rolloutPath, wanted)) return { ok: false, repaired: false, mismatch: false, blocked: false, reason: 'expected_rollout_metadata_mismatch' };
 
   const before = inspectCodexStateThreadRollout(wanted, rolloutPath, { homeDir });
   if (before.ok) return { ...before, repaired: false, blocked: false };
@@ -656,9 +673,31 @@ function codexThreadPreciseCreatedMs(row, homeDir = process.env.HOME) {
   return fallback;
 }
 
+function codexSessionLineageFromPayload(payload = {}) {
+  const sourcePayload = payload.source && typeof payload.source === 'object' ? payload.source : null;
+  const subagent = sourcePayload?.subagent || {};
+  const threadSpawn = subagent.thread_spawn || {};
+  const parentThreadId = payload.parent_thread_id
+    || payload.parent_agent_session_id
+    || threadSpawn.parent_thread_id
+    || '';
+  const threadSource = payload.thread_source
+    || (parentThreadId ? 'subagent' : '');
+  return {
+    source: typeof payload.source === 'string' ? payload.source : (threadSource || ''),
+    thread_source: threadSource,
+    parent_agent_session_id: parentThreadId,
+    parent_thread_id: parentThreadId,
+    agent_nickname: payload.agent_nickname || subagent.agent_nickname || threadSpawn.agent_nickname || '',
+    agent_role: payload.agent_role || subagent.agent_role || threadSpawn.agent_role || '',
+  };
+}
+
 function _readCodexRolloutMetadata(filePath) {
+  const readPath = _codexReadablePath(filePath);
+  if (!readPath) return null;
   // 512KB covers the large turn_context blob that Codex injects before the user_message event
-  const prefix = readFilePrefix(filePath, 512 * 1024);
+  const prefix = readFilePrefix(readPath, 512 * 1024);
   if (!prefix) return null;
   let meta = null;
   let firstUser = '';
@@ -669,12 +708,17 @@ function _readCodexRolloutMetadata(filePath) {
     if (!meta && entry?.type === 'session_meta') {
       const payload = entry.payload || {};
       if (!payload.id) return null;
+      const lineage = codexSessionLineageFromPayload(payload);
       meta = {
         id: payload.id,
         cwd: payload.cwd || '',
         model: payload.model || payload.model_id || '',
         model_provider: payload.model_provider || '',
-        source: payload.source || '',
+        source: lineage.source,
+        thread_source: lineage.thread_source,
+        parent_agent_session_id: lineage.parent_agent_session_id,
+        agent_nickname: lineage.agent_nickname,
+        agent_role: lineage.agent_role,
         cli_version: payload.cli_version || '',
         git_branch: payload.git_branch || '',
         createdMs: parseSessionStartMs(payload.timestamp || entry.timestamp),
@@ -694,6 +738,11 @@ function _readCodexRolloutMetadata(filePath) {
     model: meta.model,
     model_provider: meta.model_provider,
     source: meta.source,
+    thread_source: meta.thread_source,
+    parent_agent_session_id: meta.parent_agent_session_id,
+    parent_thread_id: meta.parent_agent_session_id,
+    agent_nickname: meta.agent_nickname,
+    agent_role: meta.agent_role,
     cli_version: meta.cli_version,
     cwd: meta.cwd,
     git_branch: meta.git_branch,
@@ -792,7 +841,7 @@ function findCodexThreadFromRolloutsForSession({
         stack.push(fullPath);
         continue;
       }
-      if (!entry.isFile() || !entry.name.endsWith('.jsonl')) continue;
+      if (!entry.isFile() || !isCodexRolloutCandidateName(entry.name)) continue;
       const row = _readCodexRolloutMetadata(fullPath);
       if (!row || !codexCwdMatches(row.cwd, cwd)) continue;
       const ms = row._preciseCreatedMs;
@@ -922,6 +971,71 @@ function codexUserKey(text) {
   return String(text || '').replace(/\s+/g, ' ').trim().slice(0, 500);
 }
 
+const CODEX_USER_ECHO_DEDUP_WINDOW_MS = 5000;
+
+function _codexTimestampMs(timestamp) {
+  const value = String(timestamp || '').trim();
+  if (!value) return null;
+  const ms = Date.parse(value);
+  return Number.isFinite(ms) ? ms : null;
+}
+
+function createCodexUserDeduper(seedMessages = [], options = {}) {
+  const windowMs = Math.max(0, Number(options.windowMs ?? CODEX_USER_ECHO_DEDUP_WINDOW_MS));
+  const byText = new Map();
+
+  const rememberKey = (key, timestamp) => {
+    if (!key) return false;
+    const tsMs = _codexTimestampMs(timestamp);
+    let seen = byText.get(key);
+    if (!seen) {
+      seen = [];
+      byText.set(key, seen);
+    }
+    for (const prior of seen) {
+      if (tsMs == null || prior == null) return false;
+      if (Math.abs(tsMs - prior) <= windowMs) return false;
+    }
+    seen.push(tsMs);
+    if (seen.length > 256) seen.splice(0, seen.length - 256);
+    return true;
+  };
+
+  const deduper = {
+    remember(text, timestamp) {
+      return rememberKey(codexUserKey(text), timestamp);
+    },
+    has(text, timestamp) {
+      const key = codexUserKey(text);
+      if (!key) return false;
+      const tsMs = _codexTimestampMs(timestamp);
+      const seen = byText.get(key) || [];
+      return seen.some((prior) => {
+        if (tsMs == null || prior == null) return true;
+        return Math.abs(tsMs - prior) <= windowMs;
+      });
+    },
+    seed(message) {
+      if (!message) return false;
+      const text = message.text || message.content || message.message || '';
+      const timestamp = message.timestamp || message.created_at || message.createdAt || '';
+      return this.remember(text, timestamp);
+    },
+  };
+
+  if (seedMessages instanceof Set) {
+    for (const key of seedMessages) rememberKey(key, null);
+  } else {
+    for (const message of Array.isArray(seedMessages) ? seedMessages : []) deduper.seed(message);
+  }
+  return deduper;
+}
+
+function normalizeCodexUserDeduper(value) {
+  if (value && typeof value.remember === 'function') return value;
+  return createCodexUserDeduper(value instanceof Set ? value : []);
+}
+
 function codexInputText(content) {
   if (typeof content === 'string') return content;
   if (!Array.isArray(content)) return '';
@@ -940,6 +1054,113 @@ function codexAssistantText(content) {
     .trim();
 }
 
+// Structured capture for Codex rollout items the legacy text parser drops:
+// reasoning, function/tool/shell calls + outputs, apply_patch, web search,
+// and compaction markers. Returns ONE message, an ARRAY of messages, or null.
+// Kept separate from codexMessageFromEntry on purpose — session-stream,
+// transcript-store, and relink-audit consume that function directly and must
+// keep their user/assistant-only behavior. Only appendCodexEntryMessage (the
+// conversation parse path) consults this.
+function codexStructuredMessageFromEntry(entry) {
+  if (!entry || typeof entry !== 'object') return null;
+  const timestamp = entry.timestamp || '';
+
+  if (entry.type === 'compacted') {
+    const out = [structuredCapture.compactBoundaryMessage({ provider: 'codex', timestamp })];
+    const summaryText = typeof entry.payload?.message === 'string' ? entry.payload.message.trim() : '';
+    if (summaryText) {
+      out.push(structuredCapture.compactSummaryMessage({ provider: 'codex', text: summaryText, timestamp }));
+    }
+    return out;
+  }
+
+  if (entry.type !== 'response_item' || !entry.payload || typeof entry.payload !== 'object') return null;
+  const p = entry.payload;
+
+  switch (p.type) {
+    case 'reasoning': {
+      const blockText = (blocks) => Array.isArray(blocks)
+        ? blocks.filter((b) => b && typeof b.text === 'string' && b.text).map((b) => b.text).join('\n')
+        : '';
+      const text = (blockText(p.summary) || blockText(p.content) || '').trim();
+      if (text) return structuredCapture.reasoningMessage({ provider: 'codex', text, timestamp });
+      if (p.encrypted_content) return structuredCapture.reasoningMessage({ provider: 'codex', encrypted: true, timestamp });
+      return null;
+    }
+    case 'function_call': {
+      const name = String(p.name || '').trim();
+      let parsedArgs = null;
+      if (typeof p.arguments === 'string') { try { parsedArgs = JSON.parse(p.arguments); } catch {} }
+      else if (p.arguments && typeof p.arguments === 'object') parsedArgs = p.arguments;
+      const patch = structuredCapture.detectApplyPatch({
+        name,
+        argumentsJson: p.arguments,
+        command: parsedArgs && parsedArgs.command,
+      });
+      if (patch) {
+        return structuredCapture.patchMessage({
+          provider: 'codex', patchText: patch.patchText, files: patch.files, callId: p.call_id, timestamp,
+        });
+      }
+      if ((name === 'shell' || name === 'container.exec' || name === 'exec_command')
+          && parsedArgs && parsedArgs.command) {
+        return structuredCapture.shellMessage({ provider: 'codex', command: parsedArgs.command, callId: p.call_id, timestamp });
+      }
+      return structuredCapture.toolCallMessage({ provider: 'codex', tool: name || 'tool', callId: p.call_id, args: p.arguments, timestamp });
+    }
+    case 'function_call_output':
+    case 'custom_tool_call_output': {
+      let outputText = typeof p.output === 'string' ? p.output
+        : (p.output != null ? JSON.stringify(p.output) : '');
+      let exitCode;
+      let durationMs;
+      if (outputText.startsWith('{')) {
+        // Shell outputs arrive as a JSON envelope: {"output", "metadata": {"exit_code", "duration_seconds"}}
+        try {
+          const parsed = JSON.parse(outputText);
+          if (parsed && typeof parsed === 'object') {
+            if (typeof parsed.output === 'string') outputText = parsed.output;
+            const md = parsed.metadata || {};
+            if (Number.isFinite(Number(md.exit_code))) exitCode = Number(md.exit_code);
+            if (Number.isFinite(Number(md.duration_seconds))) durationMs = Math.round(Number(md.duration_seconds) * 1000);
+          }
+        } catch {}
+      }
+      return structuredCapture.toolResultMessage({
+        provider: 'codex', callId: p.call_id, output: outputText, exitCode, durationMs, timestamp,
+      });
+    }
+    case 'local_shell_call': {
+      const action = p.action || {};
+      const command = Array.isArray(action.command) ? action.command : [];
+      const patch = structuredCapture.detectApplyPatch({ command });
+      if (patch) {
+        return structuredCapture.patchMessage({
+          provider: 'codex', patchText: patch.patchText, files: patch.files, callId: p.call_id, timestamp,
+        });
+      }
+      return structuredCapture.shellMessage({ provider: 'codex', command, callId: p.call_id, timestamp });
+    }
+    case 'custom_tool_call': {
+      const name = String(p.name || '').trim();
+      const patch = structuredCapture.detectApplyPatch({ name, input: p.input });
+      if (patch) {
+        return structuredCapture.patchMessage({
+          provider: 'codex', patchText: patch.patchText, files: patch.files, callId: p.call_id, timestamp,
+        });
+      }
+      return structuredCapture.toolCallMessage({ provider: 'codex', tool: name || 'tool', callId: p.call_id, args: p.input, timestamp });
+    }
+    case 'web_search_call': {
+      const action = p.action || {};
+      const query = String(action.query || p.query || '').trim();
+      return structuredCapture.webSearchMessage({ provider: 'codex', query: query || 'web search', timestamp });
+    }
+    default:
+      return null;
+  }
+}
+
 function codexMessageFromEntry(entry) {
   if (!entry || typeof entry !== 'object') return null;
 
@@ -964,64 +1185,93 @@ function codexMessageFromEntry(entry) {
 function codexSessionMetaFromEntry(entry) {
   if (!entry || entry.type !== 'session_meta') return null;
   const payload = entry.payload || {};
+  const lineage = codexSessionLineageFromPayload(payload);
   return {
     id: payload.id || '',
     cwd: payload.cwd || '',
     model: payload.model || payload.model_id || '',
     git_branch: payload.git_branch || '',
     timestamp: payload.timestamp || entry.timestamp || '',
+    source: lineage.source,
+    thread_source: lineage.thread_source,
+    parent_agent_session_id: lineage.parent_agent_session_id,
+    parent_thread_id: lineage.parent_thread_id,
+    agent_nickname: lineage.agent_nickname,
+    agent_role: lineage.agent_role,
   };
 }
 
 function appendCodexEntryMessage(entry, messages, seenUsers) {
   if (!entry || typeof entry !== 'object') return false;
   const msg = codexMessageFromEntry(entry);
-  if (!msg) return false;
+  if (!msg) {
+    // Structured capture: items the text parser drops (reasoning, tool/shell
+    // calls + outputs, patches, web search, compaction). role:'system' rows —
+    // the user echo deduper does not apply.
+    if (!structuredCapture.structuredCaptureEnabled()) return false;
+    const structured = codexStructuredMessageFromEntry(entry);
+    if (!structured) return false;
+    for (const m of Array.isArray(structured) ? structured : [structured]) messages.push(m);
+    return true;
+  }
   if (msg.role === 'user') {
-    const key = codexUserKey(msg.text);
-    if (!key || seenUsers.has(key)) return false;
-    seenUsers.add(key);
+    const deduper = normalizeCodexUserDeduper(seenUsers);
+    if (!deduper.remember(msg.text, msg.timestamp)) return false;
   }
   messages.push(msg);
   return true;
 }
 
-function parseCodexJsonlLine(line, messages, state) {
-  if (!line || !line.trim()) return false;
+function parseCodexJsonlRecord(line, messages, state) {
+  if (!line || !line.trim()) return { valid: true, messageAdded: false };
   let entry;
-  try { entry = JSON.parse(line); } catch { return false; }
-  if (!entry || typeof entry !== 'object') return false;
+  try { entry = JSON.parse(line); } catch { return { valid: false, messageAdded: false }; }
+  if (!entry || typeof entry !== 'object') return { valid: false, messageAdded: false };
   if (!state.sessionMeta) {
     const meta = codexSessionMetaFromEntry(entry);
     if (meta?.id) state.sessionMeta = meta;
   }
-  return appendCodexEntryMessage(entry, messages, state.seenUsers);
+  return { valid: true, messageAdded: appendCodexEntryMessage(entry, messages, state.seenUsers) };
+}
+
+function parseCodexJsonlLine(line, messages, state) {
+  return parseCodexJsonlRecord(line, messages, state).messageAdded;
 }
 
 function parseCodexJsonlIntoMessages(content, messages, options = {}) {
   const raw = String(content || '');
   const state = {
-    seenUsers: options.seenUsers || new Set(),
+    seenUsers: normalizeCodexUserDeduper(options.codexUserDeduper || options.seenUsers),
     sessionMeta: null,
   };
   const before = messages.length;
   let linesRead = 0;
+  let completeBytesRead = 0;
 
   let start = 0;
-  while (start <= raw.length) {
-    let end = raw.indexOf('\n', start);
-    if (end === -1) end = raw.length;
+  while (start < raw.length) {
+    const end = raw.indexOf('\n', start);
+    if (end === -1) {
+      const line = raw.slice(start);
+      if (line) {
+        linesRead++;
+        const parsed = parseCodexJsonlRecord(line, messages, state);
+        if (parsed.valid) completeBytesRead += Buffer.byteLength(line);
+      }
+      break;
+    }
     const line = raw.slice(start, end);
+    completeBytesRead += Buffer.byteLength(line) + 1;
     if (line) {
       linesRead++;
-      parseCodexJsonlLine(line, messages, state);
+      parseCodexJsonlRecord(line, messages, state);
     }
-    if (end === raw.length) break;
     start = end + 1;
   }
 
   return {
     bytesRead: Buffer.byteLength(raw),
+    completeBytesRead,
     linesRead,
     messagesAdded: messages.length - before,
     sessionMeta: state.sessionMeta,
@@ -1029,8 +1279,12 @@ function parseCodexJsonlIntoMessages(content, messages, options = {}) {
 }
 
 function parseCodexJsonlFileIntoMessages(filePath, messages, options = {}) {
+  const readPath = _codexReadablePath(filePath);
+  if (!readPath) {
+    return { bytesRead: 0, completeBytesRead: 0, linesRead: 0, messagesAdded: 0, sessionMeta: null, failed: 1, compressed: true };
+  }
   const state = {
-    seenUsers: options.seenUsers || new Set(),
+    seenUsers: normalizeCodexUserDeduper(options.codexUserDeduper || options.seenUsers),
     sessionMeta: null,
   };
   const before = messages.length;
@@ -1038,12 +1292,13 @@ function parseCodexJsonlFileIntoMessages(filePath, messages, options = {}) {
   const buf = Buffer.alloc(chunkSize);
   const decoder = new StringDecoder('utf8');
   let bytesReadTotal = 0;
+  let completeBytesRead = 0;
   let linesRead = 0;
   let partial = '';
   let fd = null;
 
   try {
-    fd = fs.openSync(filePath, 'r');
+    fd = fs.openSync(readPath, 'r');
     while (true) {
       const bytesRead = fs.readSync(fd, buf, 0, buf.length, null);
       if (bytesRead <= 0) break;
@@ -1054,9 +1309,10 @@ function parseCodexJsonlFileIntoMessages(filePath, messages, options = {}) {
         const end = text.indexOf('\n', start);
         if (end === -1) break;
         const line = text.slice(start, end);
+        completeBytesRead += Buffer.byteLength(line) + 1;
         if (line) {
           linesRead++;
-          parseCodexJsonlLine(line, messages, state);
+          parseCodexJsonlRecord(line, messages, state);
         }
         start = end + 1;
       }
@@ -1066,7 +1322,8 @@ function parseCodexJsonlFileIntoMessages(filePath, messages, options = {}) {
     if (tail) partial += tail;
     if (partial && partial.trim()) {
       linesRead++;
-      parseCodexJsonlLine(partial, messages, state);
+      const parsed = parseCodexJsonlRecord(partial, messages, state);
+      if (parsed.valid) completeBytesRead += Buffer.byteLength(partial);
     }
   } finally {
     try { if (fd != null) fs.closeSync(fd); } catch {}
@@ -1074,6 +1331,78 @@ function parseCodexJsonlFileIntoMessages(filePath, messages, options = {}) {
 
   return {
     bytesRead: bytesReadTotal,
+    completeBytesRead,
+    linesRead,
+    messagesAdded: messages.length - before,
+    sessionMeta: state.sessionMeta,
+  };
+}
+
+async function parseCodexJsonlFileIntoMessagesAsync(filePath, messages, options = {}) {
+  const state = {
+    seenUsers: normalizeCodexUserDeduper(options.codexUserDeduper || options.seenUsers),
+    sessionMeta: null,
+  };
+  const before = messages.length;
+  const chunkSize = options.chunkSize || 1024 * 1024;
+  const yieldAfterMs = Math.max(5, Number(options.yieldAfterMs || 25));
+  const buf = Buffer.alloc(chunkSize);
+  const decoder = new StringDecoder('utf8');
+  let bytesReadTotal = 0;
+  let completeBytesRead = 0;
+  let linesRead = 0;
+  let partial = '';
+  let lastYieldAt = Date.now();
+  let fh = null;
+
+  async function maybeYield() {
+    if (Date.now() - lastYieldAt < yieldAfterMs) return;
+    await new Promise((resolve) => setImmediate(resolve));
+    lastYieldAt = Date.now();
+  }
+
+  const readPath = _codexReadablePath(filePath);
+  if (!readPath) {
+    return { bytesRead: 0, completeBytesRead: 0, linesRead: 0, messagesAdded: 0, sessionMeta: null, failed: 1, compressed: true };
+  }
+  try {
+    fh = await fs.promises.open(readPath, 'r');
+    let position = 0;
+    while (true) {
+      const { bytesRead } = await fh.read(buf, 0, buf.length, position);
+      if (bytesRead <= 0) break;
+      position += bytesRead;
+      bytesReadTotal += bytesRead;
+      const text = partial + decoder.write(buf.subarray(0, bytesRead));
+      let start = 0;
+      while (true) {
+        const end = text.indexOf('\n', start);
+        if (end === -1) break;
+        const line = text.slice(start, end);
+        completeBytesRead += Buffer.byteLength(line) + 1;
+        if (line) {
+          linesRead++;
+          parseCodexJsonlRecord(line, messages, state);
+        }
+        start = end + 1;
+      }
+      partial = text.slice(start);
+      await maybeYield();
+    }
+    const tail = decoder.end();
+    if (tail) partial += tail;
+    if (partial && partial.trim()) {
+      linesRead++;
+      const parsed = parseCodexJsonlRecord(partial, messages, state);
+      if (parsed.valid) completeBytesRead += Buffer.byteLength(partial);
+    }
+  } finally {
+    try { if (fh) await fh.close(); } catch {}
+  }
+
+  return {
+    bytesRead: bytesReadTotal,
+    completeBytesRead,
     linesRead,
     messagesAdded: messages.length - before,
     sessionMeta: state.sessionMeta,
@@ -1082,8 +1411,13 @@ function parseCodexJsonlFileIntoMessages(filePath, messages, options = {}) {
 
 function parseCodexJsonlTailFileIntoMessages(filePath, messages, options = {}) {
   const maxBytes = Math.max(1, Number(options.maxBytes || 10 * 1024 * 1024));
+  // A compressed archive can't be range-read — tail the materialized copy.
+  const readPath = _codexReadablePath(filePath);
+  if (!readPath) {
+    return { bytesRead: 0, linesRead: 0, messagesAdded: 0, fileSize: 0, partial: false, failed: 1, compressed: true };
+  }
   let stat;
-  try { stat = fs.statSync(filePath); } catch {
+  try { stat = fs.statSync(readPath); } catch {
     return { bytesRead: 0, linesRead: 0, messagesAdded: 0, fileSize: 0, partial: false, failed: 1 };
   }
   const size = Number(stat.size || 0);
@@ -1095,7 +1429,7 @@ function parseCodexJsonlTailFileIntoMessages(filePath, messages, options = {}) {
   const startOffset = Math.max(0, size - readSize);
   let fd = null;
   try {
-    fd = fs.openSync(filePath, 'r');
+    fd = fs.openSync(readPath, 'r');
     const buf = Buffer.alloc(readSize);
     const bytesRead = fs.readSync(fd, buf, 0, readSize, startOffset);
     let content = buf.toString('utf8', 0, bytesRead);
@@ -1104,7 +1438,7 @@ function parseCodexJsonlTailFileIntoMessages(filePath, messages, options = {}) {
       content = nlIdx >= 0 ? content.slice(nlIdx + 1) : '';
     }
     const before = messages.length;
-    const parsed = parseCodexJsonlIntoMessages(content, messages, { seenUsers: options.seenUsers });
+    const parsed = parseCodexJsonlIntoMessages(content, messages, { codexUserDeduper: options.codexUserDeduper || options.seenUsers });
     return {
       ...parsed,
       bytesRead,
@@ -1164,8 +1498,10 @@ function codexSearchMatchForMessage(msg, terms, order) {
 }
 
 function searchCodexRolloutFileMessages(filePath, terms, row) {
-  const state = { seenUsers: new Set(), sessionMeta: null };
+  const state = { codexUserDeduper: createCodexUserDeduper(), sessionMeta: null };
   const matches = [];
+  const readPath = _codexReadablePath(filePath);
+  if (!readPath) return matches;
   const chunkSize = 1024 * 1024;
   const buf = Buffer.alloc(chunkSize);
   const decoder = new StringDecoder('utf8');
@@ -1174,7 +1510,7 @@ function searchCodexRolloutFileMessages(filePath, terms, row) {
   let order = 0;
 
   try {
-    fd = fs.openSync(filePath, 'r');
+    fd = fs.openSync(readPath, 'r');
     while (true) {
       const bytesRead = fs.readSync(fd, buf, 0, buf.length, null);
       if (bytesRead <= 0) break;
@@ -1195,12 +1531,10 @@ function searchCodexRolloutFileMessages(filePath, terms, row) {
             const msg = codexMessageFromEntry(entry);
             if (msg) {
               if (msg.role === 'user') {
-                const key = codexUserKey(msg.text);
-                if (!key || state.seenUsers.has(key)) {
+                if (!state.codexUserDeduper.remember(msg.text, msg.timestamp)) {
                   start = end + 1;
                   continue;
                 }
-                state.seenUsers.add(key);
               }
               const match = codexSearchMatchForMessage(msg, terms, order++);
               if (match) matches.push(match);
@@ -1225,11 +1559,8 @@ function searchCodexRolloutFileMessages(filePath, terms, row) {
         if (msg) {
           let shouldConsider = true;
           if (msg.role === 'user') {
-            const key = codexUserKey(msg.text);
-            if (!key || state.seenUsers.has(key)) {
+            if (!state.codexUserDeduper.remember(msg.text, msg.timestamp)) {
               shouldConsider = false;
-            } else {
-              state.seenUsers.add(key);
             }
           }
           const match = shouldConsider ? codexSearchMatchForMessage(msg, terms, order++) : null;
@@ -1305,6 +1636,11 @@ function mergeCodexRecentThreadRow(existing, incoming) {
     updated_at: Math.max(base.updated_at || 0, other.updated_at || 0),
     providerResumeId: base.providerResumeId || other.providerResumeId || '',
     providerResumeIds: [...providerResumeIds],
+    thread_source: base.thread_source || other.thread_source || '',
+    parent_agent_session_id: base.parent_agent_session_id || base.parent_thread_id || other.parent_agent_session_id || other.parent_thread_id || '',
+    parent_thread_id: base.parent_thread_id || base.parent_agent_session_id || other.parent_thread_id || other.parent_agent_session_id || '',
+    agent_nickname: base.agent_nickname || other.agent_nickname || '',
+    agent_role: base.agent_role || other.agent_role || '',
     _jsonlPath: base._jsonlPath || other._jsonlPath || '',
     _fileSize: base._fileSize || other._fileSize || 0,
     _modifiedAt: base._modifiedAt || other._modifiedAt || '',
@@ -1331,6 +1667,11 @@ function normalizeCodexRecentThreadRows(rows, getRolloutInfo = () => ({})) {
       id: canonicalId,
       providerResumeId,
       providerResumeIds,
+      thread_source: row.thread_source || '',
+      parent_agent_session_id: row.parent_agent_session_id || row.parent_thread_id || '',
+      parent_thread_id: row.parent_thread_id || row.parent_agent_session_id || '',
+      agent_nickname: row.agent_nickname || '',
+      agent_role: row.agent_role || '',
       _originalThreadId: originalThreadId,
       _jsonlPath: rolloutPath,
       _fileSize: rolloutInfo.fileSize || row._fileSize || 0,
@@ -1437,7 +1778,7 @@ function listCodexSessionsFromRollouts(homeDir = process.env.HOME, limit = 50, o
     for (const entry of entries) {
       const fullPath = path.join(dir, entry.name);
       if (entry.isDirectory()) { stack.push(fullPath); continue; }
-      if (!entry.isFile() || !entry.name.endsWith('.jsonl')) continue;
+      if (!entry.isFile() || !isCodexRolloutCandidateName(entry.name)) continue;
       let row = _readCodexRolloutMetadata(fullPath);
       if (!row) continue;
       row = _codexRolloutRowWithFileInfo(row, fullPath);
@@ -1474,10 +1815,13 @@ module.exports = {
   cleanCodexUserText,
   codexInputText,
   codexMessageFromEntry,
+  codexStructuredMessageFromEntry,
+  isCodexRolloutCandidateName,
   codexRolloutFileInfo,
   codexRolloutFileMatchesThread,
   codexRolloutIdFromPath,
   codexUserKey,
+  createCodexUserDeduper,
   checkCodexStateIntegrity,
   extractResumeTarget,
   findCodexSessionFiles,
@@ -1504,5 +1848,6 @@ module.exports = {
   parseSessionStartMs,
   parseCodexJsonlIntoMessages,
   parseCodexJsonlFileIntoMessages,
+  parseCodexJsonlFileIntoMessagesAsync,
   parseCodexJsonlTailFileIntoMessages,
 };