@volter/supercode-interchange 0.1.17 → 0.1.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-interchange",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "type": "module",
   "description": "Read-only harness metadata, transcript codecs and session projections for Supercode",
   "license": "MIT OR Apache-2.0",

package/session-append-scan.mjs

@@ -0,0 +1,44 @@
+import { createHash } from 'node:crypto';
+
+export const EDGE_BYTES = 64 * 1024, VERIFY_MS = 10 * 60_000;
+export const shortHash = (bytes) => createHash('sha256').update(bytes).digest('hex').slice(0, 24);
+
+/** What a pass over a file that is only added to keeps of where it read: the file, the bytes it read through (from
+ * `from` to `bytes`, each given to `hashed` as it was read) and how the file stood when it stopped. The next read of
+ * the same file takes only what was written since. */
+export class AppendScan {
+  bytes = 0; from = 0; hashed = createHash('sha256'); stamp = null; edge = null; size = 0; verified = Date.now();
+
+  constructor(reader) { this.device = reader.fingerprint.device; this.inode = reader.fingerprint.inode; }
+
+  /** Whether this is the scan of `reader`'s file: the same file, no shorter, its scanned bytes as they were. A file
+   * whose size and modification time are those last read is as it was. One that grew is an append while the last
+   * EDGE_BYTES the scan read are as they were (a bounded read), and is taken as one for at most VERIFY_MS after its
+   * bytes were last read through. Any other (written without growing, an edge that moved, or a growing file not read
+   * through for that long) is read through to where the scan stopped and compared by the hash of those bytes, no
+   * line decoded: a record rewritten in place, whatever its length, ends the scan and every mark made from it, at
+   * once when the file did not also grow, and within VERIFY_MS when it did. */
+  async holds(reader) {
+    if (reader.fingerprint.device !== this.device || reader.fingerprint.inode !== this.inode || reader.size < this.bytes) return false;
+    if (this.unchanged(reader)) return true;
+    if (reader.size > this.size && Date.now() - this.verified < VERIFY_MS) return this.edge === await this.edgeOf(reader);
+    const hash = createHash('sha256');
+    for (let at = this.from; at < this.bytes;) { const block = await reader.read(at, Math.min(1024 * 1024, this.bytes - at)); hash.update(block); at += block.length; }
+    this.verified = Date.now();
+    return hash.digest('hex') === this.hashed.copy().digest('hex');
+  }
+
+  /** Whether the file's size and modification time are those this scan last read it at. */
+  unchanged(reader) { return this.stamp === `${reader.fingerprint.size}:${reader.fingerprint.mtime_ns}`; }
+
+  async edgeOf(reader) {
+    const from = Math.max(this.from, this.bytes - EDGE_BYTES);
+    return shortHash(await reader.read(from, this.bytes - from));
+  }
+
+  /** The file as a pass that read on from `from` leaves it. */
+  async settle(reader, from) {
+    if (this.bytes !== from || this.edge == null) this.edge = await this.edgeOf(reader);
+    this.size = reader.size; this.stamp = `${reader.fingerprint.size}:${reader.fingerprint.mtime_ns}`;
+  }
+}

package/session-claude-content.mjs

@@ -150,12 +150,15 @@ export function pushClaudeAttachment(value, out) {
   }
   if (text == null || nativeTrim(text) === '') return;
   const message = createMessage('user', text); message.metadata.attachmentType = kind;
+  Object.assign(message.metadata, claudeUserProvenance(attachment));
+  if (field(attachment, 'humanTurn') === true) message.metadata.origin = 'human';
   const mode = stringField(attachment, 'commandMode'); if (mode != null) message.metadata.commandMode = mode;
+  const messageId = stringField(attachment, 'msg_id'); if (messageId != null) message.metadata.native_msg_id = messageId;
   out.push(message);
 }
 
 export function captureClaudeProvenance(value, messages, from = 0) {
-  const facts = [['timestamp', stringField(value, 'timestamp')], ['claude_uuid', stringField(value, 'uuid')], ['model', stringField(field(value, 'message'), 'model')]];
+  const facts = [['timestamp', stringField(value, 'timestamp')], ['claude_uuid', stringField(value, 'uuid')], ['native_msg_id', stringField(value, 'msg_id')], ['model', stringField(field(value, 'message'), 'model')]];
   for (let index = from; index < messages.length; index++) for (const [key, fact] of facts) {
     if (fact != null && !Object.hasOwn(messages[index].metadata, key)) messages[index].metadata[key] = fact;
   }

package/session-claude-index.mjs

@@ -1,4 +1,3 @@
-import { createHash } from 'node:crypto';
 import { basename, dirname, extname, join } from 'node:path';
 import { withSessionFile } from './file-io.mjs';
 import { sessionFileLines, decodeSessionUtf8 } from './session-file.mjs';
@@ -15,6 +14,7 @@ import { captureClaudeProvenance, pushClaudeUser, pushClaudeAttachment, pushClau
 import { sourceStat } from './store-registry.mjs';
 import { isCompressedSessionPath, looksLikeSessionSqlite, sessionTextError } from './session-path.mjs';
 import { detectSessionSource } from './session-source.mjs';
+import { AppendScan, shortHash } from './session-append-scan.mjs';
 
 const REFERENCE = 'supercode.internal.read_index';
 
@@ -196,8 +196,6 @@ export async function withClaudeReadIndex(path, work, { fidelity = 'byte_lossles
 }
 
 const REPLAYED = new Set(['user', 'assistant', 'attachment', 'system']);
-const EDGE_BYTES = 64 * 1024, VERIFY_MS = 10 * 60_000;
-const shortHash = (bytes) => createHash('sha256').update(bytes).digest('hex').slice(0, 24);
 
 /** One line taken into a scan's state: its place among the file's lines, its header facts, its node in the graph,
  * what it changes of the recorded profile and, for a record the replay can select, where it stands and the hash of
@@ -217,34 +215,10 @@ function observeClaudeLine(state, line) {
 /** A transcript's complete lines as one pass over them leaves them, kept between reads of the same file: the next
  * read takes only the lines written since (`extend`). Nothing a record says is kept, only where it is and what it is
  * to the replay. */
-class ClaudeRecordScan {
-  records = new Map(); lines = 0; parseErrors = 0; version = null; bytes = 0;
+class ClaudeRecordScan extends AppendScan {
+  records = new Map(); lines = 0; parseErrors = 0; version = null;
   graph = new ClaudeReplayIndex(); meta = createSession('claude_code').meta; profile = recordedProfileFold('claude_code');
-  skeletons = new Map(); view = null; hashed = createHash('sha256'); stamp = null; edge = null; size = 0; verified = Date.now();
-
-  constructor(reader) { this.device = reader.fingerprint.device; this.inode = reader.fingerprint.inode; }
-
-  /** Whether this is the scan of `reader`'s file: the same file, no shorter, its scanned bytes as they were. A file
-   * whose size and modification time are those last read is as it was. One that grew is an append while the last
-   * EDGE_BYTES the scan read are as they were (a bounded read), and is taken as one for at most VERIFY_MS after its
-   * bytes were last read through. Any other (written without growing, an edge that moved, or a growing file not read
-   * through for that long) is read through to where the scan stopped and compared by the hash of those bytes, no
-   * line decoded: a record rewritten in place, whatever its length, ends the scan and every mark made from it, at
-   * once when the file did not also grow, and within VERIFY_MS when it did. */
-  async holds(reader) {
-    if (reader.fingerprint.device !== this.device || reader.fingerprint.inode !== this.inode || reader.size < this.bytes) return false;
-    if (this.stamp === `${reader.fingerprint.size}:${reader.fingerprint.mtime_ns}`) return true;
-    if (reader.size > this.size && Date.now() - this.verified < VERIFY_MS) return this.edge === await this.#edge(reader);
-    const hash = createHash('sha256');
-    for (let at = 0; at < this.bytes;) { const block = await reader.read(at, Math.min(1024 * 1024, this.bytes - at)); hash.update(block); at += block.length; }
-    this.verified = Date.now();
-    return hash.digest('hex') === this.hashed.copy().digest('hex');
-  }
-
-  async #edge(reader) {
-    const from = Math.max(0, this.bytes - EDGE_BYTES);
-    return shortHash(await reader.read(from, this.bytes - from));
-  }
+  skeletons = new Map(); view = null;
 
   /** The lines completed since the last pass. A last line with no LF yet stays outside the scan: `view` reads it. */
   async extend(reader) {
@@ -253,8 +227,7 @@ class ClaudeRecordScan {
       if (!line.terminated) break;
       observeClaudeLine(this, line); this.hashed.update(line.bytes); this.bytes = line.offset + line.length;
     }
-    if (this.bytes !== from || this.edge == null) this.edge = await this.#edge(reader);
-    this.size = reader.size; this.stamp = `${reader.fingerprint.size}:${reader.fingerprint.mtime_ns}`;
+    await this.settle(reader, from);
   }
 
   /** The replay of the file as `reader` holds it: its messages in order, each as its skeleton with the mark of the

package/session-codex-display.mjs

@@ -9,68 +9,89 @@ import { codexUserContext } from './session-codex-context.mjs';
 import { pushCodexDisplayItem } from './session-codex-display-items.mjs';
 import { nativeTrim } from './text.mjs';
 
+/** The display fold of a Codex rollout, one record at a time over the messages made so far (`session.messages`).
+ * Of a message made by an earlier record it reads only its display item, whether it is an event message of a text
+ * (`eventKey`), and, of the last one, all of it (a call joins its open turn): a reader that keeps the earlier ones
+ * without what they say (session-codex-window.mjs) folds the same way. `textKey` names a text the fold remembers
+ * (itself, or a digest for a reader that keeps none). `observe` answers where a display item's messages were placed
+ * when they were not appended. */
+export function codexDisplayFold(session, textKey = (text) => text, held = null) {
+  const { meta, messages } = session, canonicalTexts = new Set(held?.canonicalTexts);
+  // The item ids and event texts the kept messages may hold: a record that names neither replaces nothing and looks
+  // through no message, so a read with no bound on its messages (a display anchor's) is linear in what it reads.
+  const displayItems = new Set(held?.displayItems), eventTexts = new Set(held?.eventTexts), events = held?.events ?? new WeakMap();
+  const eventKey = (message) => events.has(message) ? events.get(message) : typeof message.content === 'string' ? textKey(message.content) : undefined;
+  const fold = {
+    paginated: held?.paginated ?? false, recordCount: held?.recordCount ?? 0, total: held?.total ?? 0, events, eventKey,
+    clone: (other) => codexDisplayFold(other, textKey, { canonicalTexts, displayItems, eventTexts, events, paginated: fold.paginated, recordCount: fold.recordCount, total: fold.total }),
+    observe(line) {
+      fold.recordCount++;
+      let value; try { value = parseNativeJson(line); } catch { session.parse_error_lines++; return null; }
+      const kind = stringField(value, 'type'), payload = field(value, 'payload'), type = stringField(payload, 'type'), timestamp = stringField(value, 'timestamp');
+      if (kind === 'session_meta') { fold.paginated = stringField(payload, 'history_mode') === 'paginated'; captureCodexMeta(payload, meta); }
+      else if (kind === 'event_msg' && fold.paginated && type === 'item_completed') {
+        const item = field(payload, 'item'), id = stringField(item, 'id');
+        if (id != null) {
+          const held = displayItems.has(id), position = held ? messages.findIndex((message) => message.metadata.codex_display_item === id) : -1, projected = [];
+          pushCodexDisplayItem(item, projected);
+          for (const message of projected) message.metadata.codex_display_item = id;
+          if (projected.length) displayItems.add(id);
+          stampCodexMessages(projected, 0, timestamp);
+          let removed = 0;
+          if (held) for (let index = messages.length - 1; index >= 0; index--) if (messages[index].metadata.codex_display_item === id) { messages.splice(index, 1); removed++; }
+          fold.total = Math.max(0, fold.total - removed) + projected.length;
+          const at = Math.min(position === -1 ? messages.length : position, messages.length);
+          for (let index = 0; index < projected.length; index++) messages.splice(at + index, 0, projected[index]);
+          return { at, count: projected.length };
+        }
+      } else if (['response_item', 'event_msg'].includes(kind) && fold.paginated) { /* Model stream is separate from display history. */ }
+      else if (kind === 'turn_context' && meta.model == null) meta.model = stringField(payload, 'model');
+      else if (kind === 'event_msg' && type === 'user_message') {
+        const urls = [];
+        for (const key of ['images', 'local_images']) {
+          const images = field(payload, key); if (Array.isArray(images)) for (const image of images) if (typeof image === 'string') urls.push(image);
+        }
+        const text = stringField(payload, 'message') ?? '';
+        messages.push(urls.length ? codexUserWithImages(text, urls) : createMessage('user', text)); fold.total++;
+      } else if (kind === 'response_item' && type !== 'reasoning') {
+        const isAssistant = type === 'message' && stringField(payload, 'role') === 'assistant';
+        const assistantText = isAssistant ? extractTextContent(payload, 'content') : null;
+        if (assistantText != null && nativeTrim(assistantText) !== '') {
+          const key = textKey(assistantText);
+          const duplicate = eventTexts.has(key) ? messages.findLastIndex((message) => Object.hasOwn(message.metadata, 'codex_event_message') && eventKey(message) === key) : -1;
+          if (duplicate !== -1) { messages.splice(duplicate, 1); fold.total = Math.max(0, fold.total - 1); }
+          canonicalTexts.add(textKey(nativeTrim(assistantText)));
+        }
+        const before = messages.length;
+        if (type === 'message' && stringField(payload, 'role') === 'user') {
+          const context = codexUserContext(payload);
+          if (context.kind === 'hook_prompt') pushCodexDisplayItem(context.item, messages);
+        } else pushCodexItem(payload, messages);
+        fold.total += Math.max(0, messages.length - before); stampCodexMessages(messages, before, timestamp);
+        if (messages.length === before + 1) restoreGrokMessageExtension(payload, messages[before]);
+      } else if (kind === 'event_msg' && type === 'agent_message') {
+        const text = extractTextContent(payload, 'message');
+        if (nativeTrim(text) !== '' && !canonicalTexts.has(textKey(nativeTrim(text)))) {
+          const before = messages.length; pushCodexAssistant(messages, text); fold.total++;
+          messages.at(-1).metadata.codex_event_message = 'true'; eventTexts.add(textKey(messages.at(-1).content));
+          const phase = stringField(payload, 'phase'); if (phase != null) messages.at(-1).metadata.phase = phase;
+          stampCodexMessages(messages, before, timestamp);
+        }
+      }
+      return null;
+    },
+  };
+  return fold;
+}
+
 /** Bounded human-visible history, never a continuation or export artifact.
  * Durable TurnItems and legacy typed-user events retain their distinct paths. */
 export function fromCodexDisplayStr(text, messageLimit) {
   if (!Number.isSafeInteger(messageLimit) || messageLimit < 0) throw new RangeError('invalid Codex display message limit');
-  const session = createSession('codex'), { meta, messages } = session, precedingUsers = [], canonicalTexts = new Set();
+  const session = createSession('codex'), { messages } = session, precedingUsers = [], fold = codexDisplayFold(session);
   const retain = Math.min(Number.MAX_SAFE_INTEGER, Math.max(messageLimit, 1) + 64);
-  // The item ids and event texts the kept messages may hold: a record that names neither replaces nothing and looks
-  // through no message, so a read with no bound on its messages (a display anchor's) is linear in what it reads.
-  const displayItems = new Set(), eventTexts = new Set();
-  let paginated = false, recordCount = 0, total = 0;
   for (const line of nonEmptyLines(text)) {
-    recordCount++;
-    let value; try { value = parseNativeJson(line); } catch { session.parse_error_lines++; continue; }
-    const kind = stringField(value, 'type'), payload = field(value, 'payload'), type = stringField(payload, 'type'), timestamp = stringField(value, 'timestamp');
-    if (kind === 'session_meta') { paginated = stringField(payload, 'history_mode') === 'paginated'; captureCodexMeta(payload, meta); }
-    else if (kind === 'event_msg' && paginated && type === 'item_completed') {
-      const item = field(payload, 'item'), id = stringField(item, 'id');
-      if (id != null) {
-        const held = displayItems.has(id), position = held ? messages.findIndex((message) => message.metadata.codex_display_item === id) : -1, projected = [];
-        pushCodexDisplayItem(item, projected);
-        for (const message of projected) message.metadata.codex_display_item = id;
-        if (projected.length) displayItems.add(id);
-        stampCodexMessages(projected, 0, timestamp);
-        let removed = 0;
-        if (held) for (let index = messages.length - 1; index >= 0; index--) if (messages[index].metadata.codex_display_item === id) { messages.splice(index, 1); removed++; }
-        total = Math.max(0, total - removed) + projected.length;
-        const at = Math.min(position === -1 ? messages.length : position, messages.length);
-        for (let index = 0; index < projected.length; index++) messages.splice(at + index, 0, projected[index]);
-      }
-    } else if (['response_item', 'event_msg'].includes(kind) && paginated) { /* Model stream is separate from display history. */ }
-    else if (kind === 'turn_context' && meta.model == null) meta.model = stringField(payload, 'model');
-    else if (kind === 'event_msg' && type === 'user_message') {
-      const urls = [];
-      for (const key of ['images', 'local_images']) {
-        const images = field(payload, key); if (Array.isArray(images)) for (const image of images) if (typeof image === 'string') urls.push(image);
-      }
-      const text = stringField(payload, 'message') ?? '';
-      messages.push(urls.length ? codexUserWithImages(text, urls) : createMessage('user', text)); total++;
-    } else if (kind === 'response_item' && type !== 'reasoning') {
-      const isAssistant = type === 'message' && stringField(payload, 'role') === 'assistant';
-      const assistantText = isAssistant ? extractTextContent(payload, 'content') : null;
-      if (assistantText != null && nativeTrim(assistantText) !== '') {
-        const duplicate = eventTexts.has(assistantText) ? messages.findLastIndex((message) => Object.hasOwn(message.metadata, 'codex_event_message') && message.content === assistantText) : -1;
-        if (duplicate !== -1) { messages.splice(duplicate, 1); total = Math.max(0, total - 1); }
-        canonicalTexts.add(nativeTrim(assistantText));
-      }
-      const before = messages.length;
-      if (type === 'message' && stringField(payload, 'role') === 'user') {
-        const context = codexUserContext(payload);
-        if (context.kind === 'hook_prompt') pushCodexDisplayItem(context.item, messages);
-      } else pushCodexItem(payload, messages);
-      total += Math.max(0, messages.length - before); stampCodexMessages(messages, before, timestamp);
-      if (messages.length === before + 1) restoreGrokMessageExtension(payload, messages[before]);
-    } else if (kind === 'event_msg' && type === 'agent_message') {
-      const text = extractTextContent(payload, 'message');
-      if (nativeTrim(text) !== '' && !canonicalTexts.has(nativeTrim(text))) {
-        const before = messages.length; pushCodexAssistant(messages, text); total++;
-        messages.at(-1).metadata.codex_event_message = 'true'; eventTexts.add(messages.at(-1).content);
-        const phase = stringField(payload, 'phase'); if (phase != null) messages.at(-1).metadata.phase = phase;
-        stampCodexMessages(messages, before, timestamp);
-      }
-    }
+    fold.observe(line);
     if (messages.length > retain) {
       for (const message of messages.splice(0, messages.length - retain)) {
         if (message.role !== 'user') continue;
@@ -79,7 +100,7 @@ export function fromCodexDisplayStr(text, messageLimit) {
     }
   }
   clearCodexBookkeeping(messages, { display: true }); truncateMessagesWithAnchor(messages, messageLimit, precedingUsers);
-  session.raw = Array(recordCount).fill(''); session.raw_trailing_newline = text.endsWith('\n'); session.imported_message_count = total;
+  session.raw = Array(fold.recordCount).fill(''); session.raw_trailing_newline = text.endsWith('\n'); session.imported_message_count = fold.total;
   session.load_residue = ['display history is a bounded native-record projection, not resumable model context'];
   return session;
 }

package/session-codex-window.mjs

@@ -0,0 +1,212 @@
+import { withSessionFile } from './file-io.mjs';
+import { sessionFileLines, decodeSessionUtf8 } from './session-file.mjs';
+import { cloneNativeJson } from './native-json.mjs';
+import { createSession, normalizedSessionJson } from './session-model.mjs';
+import { messageJson } from './message.mjs';
+import { recordedSessionProfile, recordedSessionProfileHistory } from './session-views.mjs';
+import { nativeTrim } from './text.mjs';
+import { sourceStat } from './store-registry.mjs';
+import { isCompressedSessionPath, looksLikeSessionSqlite } from './session-path.mjs';
+import { detectSessionSource } from './session-source.mjs';
+import { codexDisplayFold } from './session-codex-display.mjs';
+import { clearCodexBookkeeping } from './session-codex-items.mjs';
+import { AppendScan, shortHash } from './session-append-scan.mjs';
+
+// What a message of the fold is made of, for a message held whole and for one kept without what it says: the records
+// that made it (where each stands: the one that made it, then each whose call joined its open turn), its place among
+// the messages its first record made, whether the rollout was paginated there, and, once kept, its mark: the digest
+// of the message as a read answers it.
+const made = new WeakMap();
+// All the fold reads of a message an earlier record made (codexDisplayFold), and the model a profile reads.
+const FOLDED = ['codex_display_item', 'codex_event_message', '__codex_open_turn', 'turn_id', 'model'];
+
+/** A message as a read answers it: the fold's own notes on it cleared, as they are when a whole read ends. */
+function answered(message) {
+  const sent = { ...message, metadata: cloneNativeJson(message.metadata) };
+  clearCodexBookkeeping([sent], { display: true });
+  return sent;
+}
+const markOf = (message) => shortHash(JSON.stringify(messageJson(answered(message))));
+
+/** The messages an entry's records make, as the fold made them: read again from where the records stand. */
+async function replay(entry, reader) {
+  const session = createSession('codex'), fold = codexDisplayFold(session, shortHash);
+  fold.paginated = entry.paginated;
+  for (const record of entry.records) fold.observe(nativeTrim(decodeSessionUtf8(await reader.read(record.offset, record.length))));
+  return session.messages;
+}
+
+/** The display fold over records taken one at a time, its messages kept without what they say: every message but
+ * the last (a call may still join its open turn) is replaced, once a later one follows it, by its role, the notes the
+ * fold reads and its mark. What a kept message says is read again from its records (`replay`). */
+class CodexDisplayState {
+  constructor(session = createSession('codex'), fold = codexDisplayFold(session, shortHash), modelled = false) {
+    this.session = session; this.fold = fold; this.modelled = modelled;
+  }
+
+  /** A state a record can be taken into without this one changing: for a last line that is still being written. */
+  fork() {
+    const messages = this.session.messages.slice(), last = messages.at(-1), entry = last && made.get(last);
+    if (entry && entry.mark == null) {
+      const copy = cloneNativeJson(last); made.set(copy, { ...entry, records: entry.records.slice() }); messages[messages.length - 1] = copy;
+    }
+    const session = { ...this.session, meta: cloneNativeJson(this.session.meta), messages };
+    return new CodexDisplayState(session, this.fold.clone(session), this.modelled);
+  }
+
+  async observe(record, text, reader) {
+    const { messages } = this.session; let live = messages.at(-1);
+    // A kept message that is last again (those after it were replaced) with its turn open is made again whole
+    // before a call may join it.
+    if (live && made.get(live).mark != null && live.role === 'assistant' && Object.hasOwn(live.metadata, '__codex_open_turn')) {
+      const entry = made.get(live); live = (await replay(entry, reader))[entry.ordinal];
+      made.set(live, { ...entry, mark: null }); messages[messages.length - 1] = live;
+    }
+    const calls = live?.tool_calls?.length ?? 0, placed = this.fold.observe(text);
+    if (live && messages.at(-1) === live && (live.tool_calls?.length ?? 0) !== calls) { const entry = made.get(live); entry.records.push(record); entry.bytes += record.length; }
+    let from = placed ? placed.at : messages.length; const end = placed ? placed.at + placed.count : messages.length;
+    if (!placed) while (from > 0 && !made.has(messages[from - 1])) from--;
+    for (let at = from; at < end; at++) made.set(messages[at], { records: [record], ordinal: at - from, paginated: this.fold.paginated, bytes: record.length, mark: null });
+    // The message that was last, where it stands now if it was not replaced: before what this record appended.
+    const before = end === messages.length ? from - 1 : messages.length - 1;
+    if (live && before >= 0 && before < messages.length - 1 && messages[before] === live && made.get(live).mark == null) this.#keep(before);
+    for (let at = from; at < end && at < messages.length - 1; at++) this.#keep(at);
+  }
+
+  #keep(at) {
+    const { messages } = this.session, whole = messages[at], metadata = Object.create(null);
+    for (const key of FOLDED) if (Object.hasOwn(whole.metadata, key)) metadata[key] = whole.metadata[key];
+    const kept = { role: whole.role, metadata };
+    if (Object.hasOwn(metadata, 'codex_event_message')) this.fold.events.set(kept, this.fold.eventKey(whole));
+    if (Object.hasOwn(metadata, 'model')) this.modelled = true;
+    made.set(kept, { ...made.get(whole), mark: markOf(whole) }); messages[at] = kept;
+  }
+
+  /** The mark of every message, and the model the session's profile reads: that of the last message naming one. */
+  view() {
+    const { messages } = this.session, last = messages.at(-1);
+    const modelled = this.modelled || (last != null && Object.hasOwn(last.metadata, 'model'));
+    return { state: this, messages, marks: messages.map((message) => made.get(message).mark ?? markOf(message)),
+      model: modelled ? messages.findLast((message) => Object.hasOwn(message.metadata, 'model'))?.metadata.model ?? null : null };
+  }
+}
+
+/** A rollout's complete lines from its display anchor as one pass over them leaves them, kept between reads of the
+ * same file: the next read takes only the lines written since (`extend`). The anchor's read is the header and every
+ * line after the record the anchor cuts (session-display.mjs loadSessionDisplayFrom): `head` is the header as it was
+ * read, and the bytes read through start after the cut record. */
+class CodexDisplayScan extends AppendScan {
+  state = new CodexDisplayState(); head = null; kept = null;
+
+  constructor(reader, anchor) { super(reader); this.anchor = anchor; }
+
+  async holds(reader) {
+    if (this.head == null || !await super.holds(reader)) return false;
+    return this.unchanged(reader) || this.head.hash === shortHash(await reader.read(0, this.head.length));
+  }
+
+  async #take(state, line, reader) {
+    let text;
+    try { text = line.text; } catch (error) { throw new Error(`${reader.path} contains non-UTF-8 data after its display anchor`, { cause: error }); }
+    const trimmed = nativeTrim(text);
+    if (trimmed !== '') await state.observe({ offset: line.offset, length: line.length }, trimmed, reader);
+  }
+
+  /** The lines completed since the last pass. A last line with no LF yet stays outside the scan: `project` reads it. */
+  async extend(reader, first) {
+    const from = this.bytes;
+    if (this.head == null) {
+      if (!first.terminated) return;
+      let start = null;
+      for (let at = this.anchor; at < reader.size && start == null;) {
+        const block = await reader.read(at, Math.min(64 * 1024, reader.size - at)), newline = block.indexOf(10);
+        if (newline !== -1) start = at + newline + 1;
+        at += block.length;
+      }
+      if (start == null) return;
+      await this.#take(this.state, first, reader);
+      this.head = { length: first.length, hash: shortHash(first.bytes) }; this.from = this.bytes = start;
+    }
+    for await (const line of sessionFileLines(reader, this.bytes)) {
+      if (!line.terminated) break;
+      await this.#take(this.state, line, reader); this.hashed.update(line.bytes); this.bytes = line.offset + line.length;
+    }
+    await this.settle(reader, from);
+  }
+
+  /** The fold of the file as `reader` holds it. A last line with no LF yet is taken for this answer alone; cut inside
+   * a character, it is a line still being written: counted as one that does not parse, as a cut record is. */
+  async project(reader, first) {
+    if (this.head != null && reader.size === this.bytes) return this.kept?.bytes === this.bytes ? this.kept.view : (this.kept = { bytes: this.bytes, view: this.state.view() }).view;
+    const state = this.head == null ? new CodexDisplayState() : this.state.fork();
+    if (this.head == null) await this.#take(state, first, reader);
+    else {
+      const bytes = await reader.read(this.bytes, reader.size - this.bytes); let text = null;
+      try { text = decodeSessionUtf8(bytes); } catch { state.fold.recordCount++; state.session.parse_error_lines++; }
+      if (text != null && nativeTrim(text) !== '') await state.observe({ offset: this.bytes, length: bytes.length }, nativeTrim(text), reader);
+    }
+    return state.view();
+  }
+}
+
+// The scans of the rollouts read most recently, at most this many messages between them (about 630 bytes a message
+// kept: 126 MB): a rollout read again is read from where its scan stopped, and one read long ago is scanned again.
+// Of the files whose scan read less than SCAN_KEPT_BYTES only the one read last is kept: scanning a short file again
+// costs less than keeping every one read.
+const SCANNED_MESSAGES = 200_000, SCAN_KEPT_BYTES = 8 * 1024 * 1024;
+const scans = new Map();
+const scanned = (scan) => scan.bytes - scan.from;
+
+async function scanOf(path, reader, anchor, first) {
+  let scan = scans.get(path); scans.delete(path);
+  if (scan?.anchor !== anchor || !await scan.holds(reader)) scan = new CodexDisplayScan(reader, anchor);
+  await scan.extend(reader, first);
+  if (scanned(scan) < SCAN_KEPT_BYTES) for (const [other, item] of scans) if (scanned(item) < SCAN_KEPT_BYTES) scans.delete(other);
+  scans.set(path, scan);
+  let held = 0; for (const item of scans.values()) held += item.state.session.messages.length;
+  for (const [other, item] of scans) { if (held <= SCANNED_MESSAGES || item === scan) break; scans.delete(other); held -= item.state.session.messages.length; }
+  return scan;
+}
+
+/**
+ * A window of a Codex rollout's display history as read from the byte `anchor` (loadSessionDisplayFrom), from the
+ * message at place `from`: at most `messages` of them and `bytes` of rollout (one message at least), with each one's
+ * mark and, when `marks` is asked, the mark of every message of that read. The rollout is read a line at a time and
+ * only as far as it was not read before; a message is the same one the whole read answers at that place, and its
+ * mark is the digest of it: while it stands at a place, so does what a reader took of that message there. Null when
+ * the locator names anything else, which is loaded as its document.
+ */
+export async function loadCodexRecordWindow(locator, anchor, { from, bytes = null, messages = null, marks = false }, { metrics } = {}) {
+  const { path, kind } = locator.storage;
+  if (kind !== 'file' || locator.harness === 'hermes' || anchor === 0 || isCompressedSessionPath(path)) return null;
+  if ((await sourceStat(path))?.isDirectory() || await looksLikeSessionSqlite(path, metrics)) return null;
+  return (await withSessionFile(path, async (reader) => {
+    let first = null;
+    for await (const line of sessionFileLines(reader)) { first = line; break; }
+    if (first == null || detectSessionSource(first.text) !== 'codex') return null;
+    if (anchor >= reader.size) throw new Error(`${path} is shorter than its display anchor (${anchor})`);
+    try {
+      const view = await (await scanOf(path, reader, anchor, first)).project(reader, first);
+      const total = view.messages.length, offset = Math.min(from, total), session = createSession('codex'), counted = new Set();
+      let end = offset, used = 0, again = null, againOf = null;
+      for (; end < total && (messages == null || end - offset < messages); end++) {
+        const message = view.messages[end], entry = made.get(message), record = entry.records[0].offset;
+        const cost = counted.has(record) ? 0 : entry.bytes;
+        if (bytes != null && end > offset && used + cost > bytes) break;
+        counted.add(record); used += cost;
+        if (entry.mark == null) { session.messages.push(answered(message)); continue; }
+        const key = `${record}:${entry.records.length}`;
+        if (againOf !== key) { again = await replay(entry, reader); againOf = key; }
+        const whole = again[entry.ordinal];
+        if (whole == null || markOf(whole) !== entry.mark) throw new Error(`${path} is no longer the rollout its scan read`);
+        session.messages.push(answered(whole));
+      }
+      const { state } = view;
+      session.meta = cloneNativeJson(state.session.meta); session.imported_message_count = total; session.parse_error_lines = state.session.parse_error_lines;
+      session.load_residue = ['display history is a bounded native-record projection, not resumable model context', `older native records remain before this display anchor (${anchor})`];
+      return { session: { ...normalizedSessionJson(session), raw_record_count: state.fold.recordCount,
+        resolved_profile: recordedSessionProfile(session, { model: view.model, version: null }), resolved_profile_history: recordedSessionProfileHistory(session),
+        window: { offset, returned: end - offset, total_messages: total, marks: view.marks.slice(offset, end), ...(marks ? { all_marks: view.marks } : {}) } } };
+    } catch (error) { scans.delete(path); throw error; }
+  }, metrics)).result;
+}

package/session-read.mjs

@@ -5,6 +5,7 @@ import { nativeInteger, nativeNumberKind, parseNativeJson, stringifyNativeJson,
 import { loadSessionLocator } from './session-path.mjs';
 import { loadSessionDisplayLocator, loadSessionDisplayFrom } from './session-display.mjs';
 import { withClaudeReadIndex, supportsClaudeReadIndex, loadClaudeRecordWindow } from './session-claude-index.mjs';
+import { loadCodexRecordWindow } from './session-codex-window.mjs';
 import { SessionFollower } from './session-follower.mjs';
 import { normalizedSessionJson } from './session-model.mjs';
 import { boundSessionView, projectedMessageWindow, projectedSessionJson, projectedSessionResult, projectedSessionSummary, recordedSessionProfile, recordedSessionProfileHistory } from './session-views.mjs';
@@ -103,6 +104,11 @@ export async function loadSessionRead(params, context = {}) {
     const windowed = await loadClaudeRecordWindow(locator, { from: view.fromMessage, bytes: view.windowBytes, messages: view.windowMessages, marks: view.marks }, readOptions);
     if (windowed != null) return windowed;
   }
+  // So is a view from a message on of a Codex rollout's display history read from an anchor.
+  if (view?.fromMessage != null && !view.includeSubagents && view.displayHistory && view.fromByte != null) {
+    const windowed = await loadCodexRecordWindow(locator, view.fromByte, { from: view.fromMessage, bytes: view.windowBytes, messages: view.windowMessages, marks: view.marks }, readOptions);
+    if (windowed != null) return windowed;
+  }
   const session = view?.displayHistory
     ? view.fromByte != null ? await loadSessionDisplayFrom(locator, view.fromByte, readOptions)
       : await loadSessionDisplayLocator(locator, view.messageLimit ?? 500, readOptions)