replicas-engine 0.1.868 → 0.1.870

package/dist/src/{chunk-IT5R5GJT.js → chunk-XHX6IRSG.js}

@@ -946,16 +946,26 @@ function coerceClaudePartialMessagePayload(payload) {
     status: payload.status === "completed" ? "completed" : "in_progress"
   };
 }
-function getClaudePartialMessageStreamId(event) {
-  if (event.type !== CLAUDE_PARTIAL_MESSAGE_EVENT_TYPE) return null;
-  return typeof event.payload.streamId === "string" && event.payload.streamId ? event.payload.streamId : null;
-}
 var ACCEPTED_USER_MESSAGE_SOURCE = "replicas-chat-turn-accepted";
 var QUEUED_MESSAGE_REMOVED_EVENT_TYPE = "replicas-queued-message-removed";
 var REMOVED_MESSAGE_IDS_PAYLOAD_KEY = "removedMessageIds";
 var USER_MESSAGE_ID_PAYLOAD_KEY = "replicasMessageId";
 var CODEX_ASP_ITEM_ID_PAYLOAD_KEY = "codexAspItemId";
 var CODEX_ASP_TRANSCRIPT_UPDATED_EVENT_TYPE = "codex-asp-transcript-updated";
+var CODEX_ITEM_EVENT_TYPE = "codex-item";
+var CODEX_ITEM_PARTIAL_EVENT_TYPE = "codex-item-partial";
+var CODEX_TURN_EVENT_TYPE = "codex-turn";
+var CODEX_HISTORY_FORMAT_EVENT_TYPE = "codex-history-format";
+function getEventStreamId(event) {
+  if (event.type === CLAUDE_PARTIAL_MESSAGE_EVENT_TYPE) {
+    return typeof event.payload.streamId === "string" && event.payload.streamId ? event.payload.streamId : null;
+  }
+  if (event.type === CODEX_ITEM_EVENT_TYPE || event.type === CODEX_ITEM_PARTIAL_EVENT_TYPE) {
+    const item = event.payload.item;
+    return isRecord(item) && typeof item.id === "string" ? item.id : null;
+  }
+  return null;
+}
 var CODEX_QUOTA_STATUS_EVENT_TYPE = "codex-quota-status";
 var COMPACTION_STATUS_EVENT_TYPE = "compaction-status";
 var CHAT_INTERRUPTED_EVENT_TYPE = "replicas-interrupted";
@@ -1146,16 +1156,66 @@ function getCodexAspTurnResponse(turn) {
   if (normalizeCodexAspTranscriptStatus(turn.status) === "in_progress") return null;
   return turn.items.findLast((item) => item.type === "agentMessage") ?? null;
 }
-function renumberCodexAspTranscriptItems(transcript) {
-  let sequence = 0;
+function codexItemEvent(turnId, item, partial = false) {
+  const { sequence: _sequence, ...payloadItem } = item;
+  return {
+    timestamp: item.timestamp,
+    type: partial ? CODEX_ITEM_PARTIAL_EVENT_TYPE : CODEX_ITEM_EVENT_TYPE,
+    payload: { turnId, item: payloadItem }
+  };
+}
+function codexTurnEvent(turnId, status, timestamp, error) {
   return {
-    ...transcript,
-    turns: transcript.turns.map((turn) => ({
-      ...turn,
-      items: turn.items.map((item) => ({ ...item, sequence: sequence++ }))
-    }))
+    timestamp,
+    type: CODEX_TURN_EVENT_TYPE,
+    payload: { turnId, status, ...error ? { error } : {} }
   };
 }
+function isTranscriptItemStatus(value) {
+  return value === "in_progress" || value === "completed" || value === "failed";
+}
+var CODEX_ITEM_FIELD_CHECKS = {
+  userMessage: (item) => typeof item.content === "string",
+  agentMessage: (item) => typeof item.text === "string",
+  reasoning: (item) => typeof item.text === "string" && isTranscriptItemStatus(item.status),
+  commandExecution: (item) => typeof item.command === "string" && isTranscriptItemStatus(item.status),
+  fileChange: (item) => Array.isArray(item.operations) && isTranscriptItemStatus(item.status),
+  toolCall: (item) => typeof item.server === "string" && typeof item.tool === "string" && isTranscriptItemStatus(item.status),
+  subagent: (item) => typeof item.description === "string" && typeof item.prompt === "string" && typeof item.subagentType === "string" && isTranscriptItemStatus(item.status),
+  webSearch: (item) => typeof item.query === "string" && isTranscriptItemStatus(item.status),
+  plan: (item) => typeof item.text === "string" && isTranscriptItemStatus(item.status),
+  contextCompaction: (item) => isTranscriptItemStatus(item.status),
+  error: (item) => typeof item.message === "string"
+};
+function isCodexAspTranscriptItem(value) {
+  if (!isRecord(value) || typeof value.id !== "string" || typeof value.timestamp !== "string") return false;
+  if (value.sequence !== void 0 && typeof value.sequence !== "number") return false;
+  if (typeof value.type !== "string" || !Object.hasOwn(CODEX_ITEM_FIELD_CHECKS, value.type)) return false;
+  return CODEX_ITEM_FIELD_CHECKS[value.type](value);
+}
+function codexItemFromEvent(event) {
+  if (event.type !== CODEX_ITEM_EVENT_TYPE && event.type !== CODEX_ITEM_PARTIAL_EVENT_TYPE) return null;
+  const { turnId, item } = event.payload;
+  return typeof turnId === "string" && isCodexAspTranscriptItem(item) ? { turnId, item } : null;
+}
+function codexTurnFromEvent(event) {
+  if (event.type !== CODEX_TURN_EVENT_TYPE) return null;
+  const { turnId, status, error } = event.payload;
+  return typeof turnId === "string" && typeof status === "string" ? { turnId, status, ...typeof error === "string" ? { error } : {} } : null;
+}
+function codexTranscriptToEvents(transcript) {
+  return transcript.turns.flatMap((turn) => {
+    const events = turn.items.map((item) => codexItemEvent(turn.id, item));
+    if (normalizeCodexAspTranscriptStatus(turn.status) !== "in_progress") {
+      events.push(codexTurnEvent(
+        turn.id,
+        turn.status,
+        turn.completedAt ?? turn.items.at(-1)?.timestamp ?? turn.startedAt
+      ));
+    }
+    return events;
+  });
+}
 function isCodexAspTranscript(value) {
   if (!isRecord(value)) return false;
   return typeof value.threadId === "string" && typeof value.updatedAt === "string" && Array.isArray(value.turns);
@@ -1280,20 +1340,11 @@ function paginateChatHistory(full, params) {
     params.limit,
     params.beforeEvent
   );
-  const turns = full.codexAspTranscript?.turns;
-  const { startIndex: turnsStartIndex, endIndex: turnsEnd } = getChatHistoryPageWindow(
-    turns?.length ?? 0,
-    params.limit,
-    params.beforeTurn
-  );
-  const codexAspTranscript = full.codexAspTranscript && turns && (turnsStartIndex > 0 || turnsEnd < turns.length) ? { ...full.codexAspTranscript, turns: turns.slice(turnsStartIndex, turnsEnd) } : full.codexAspTranscript;
   return {
     ...full,
     events: full.events.slice(eventsStartIndex, eventsEnd),
     eventsStartIndex,
-    totalEvents: full.events.length,
-    codexAspTranscript,
-    ...full.codexAspTranscript ? { turnsStartIndex } : {}
+    totalEvents: full.events.length
   };
 }
 
@@ -3844,6 +3895,201 @@ function removeReplicasInstructions(text) {
   return removeTag(text, REPLICAS_INSTRUCTIONS_TAG);
 }
 
+// ../shared/src/display-message/parsers/codex-asp-parser.ts
+function collectCodexTurns(events) {
+  const turns = /* @__PURE__ */ new Map();
+  const turnFor = (id) => {
+    const existing = turns.get(id);
+    if (existing) return existing;
+    const turn = { id, status: "inProgress", items: [] };
+    turns.set(id, turn);
+    return turn;
+  };
+  for (const event of events) {
+    const item = codexItemFromEvent(event);
+    if (item) {
+      const turn = turnFor(item.turnId);
+      const index = turn.items.findIndex((candidate) => candidate.id === item.item.id);
+      if (index === -1) turn.items.push(item.item);
+      else turn.items[index] = item.item;
+      continue;
+    }
+    const turnEvent = codexTurnFromEvent(event);
+    if (turnEvent) {
+      const turn = turnFor(turnEvent.turnId);
+      turn.status = turnEvent.status;
+      turn.completedAt = event.timestamp;
+      turn.error = turnEvent.error;
+    }
+  }
+  return turns;
+}
+function messagesForCodexTurn(turn) {
+  const items = turn.items.map((item, index) => ({ item, index })).sort((a, b) => parseTimestampMs(a.item.timestamp) - parseTimestampMs(b.item.timestamp) || a.index - b.index).map(({ item }) => item);
+  const reasoning = items.filter(
+    (item) => item.type === "reasoning" && item.text.trim().length > 0
+  );
+  const firstReasoningIndex = items.findIndex((item) => item.type === "reasoning");
+  const coalesced = items.flatMap((item, index) => {
+    if (item.type !== "reasoning") return [item];
+    if (index !== firstReasoningIndex || reasoning.length === 0) return [];
+    return [{
+      type: "reasoning",
+      id: turn.id,
+      text: reasoning.map(({ text }) => text.trim()).join("\n\n"),
+      timestamp: reasoning[0].timestamp,
+      status: reasoning.at(-1)?.status ?? "completed"
+    }];
+  });
+  const response = getCodexAspTurnResponse({ status: turn.status, items: coalesced });
+  const reasoningIndex = coalesced.findIndex((item) => item.type === "reasoning");
+  const responseIndex = response ? coalesced.indexOf(response) : -1;
+  if (responseIndex !== -1 && reasoningIndex > responseIndex) {
+    coalesced.splice(responseIndex, 0, ...coalesced.splice(reasoningIndex, 1));
+  }
+  const messages = coalesced.flatMap((item) => {
+    const message = messageForItem(item);
+    return [...message ? [message] : [], ...skillMessagesForItem(item)];
+  });
+  if (turn.error) {
+    messages.push({
+      id: `error-${turn.id}`,
+      type: "error",
+      message: turn.error,
+      timestamp: turn.completedAt ?? items.at(-1)?.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString()
+    });
+  }
+  return messages;
+}
+function inputForDisplay(input) {
+  if (input === void 0 || input === null) return void 0;
+  if (typeof input === "string") return input;
+  if (isRecord(input)) return input;
+  return String(input);
+}
+function isInternalUserMessage(content) {
+  const trimmed = content.trim();
+  return trimmed.startsWith("<environment_context>") || trimmed.startsWith("<goal_context>");
+}
+function messageForItem(item) {
+  if (item.type === "userMessage") {
+    if (isInternalUserMessage(item.content)) return null;
+    return {
+      id: `user-${item.id}`,
+      type: "user",
+      content: item.content,
+      images: item.images,
+      timestamp: item.timestamp
+    };
+  }
+  if (item.type === "agentMessage" || item.type === "plan") {
+    if (!item.text) return null;
+    return {
+      id: `agent-${item.id}`,
+      type: "agent",
+      content: item.text,
+      timestamp: item.timestamp,
+      ...item.type === "plan" ? { isPlan: true } : {}
+    };
+  }
+  if (item.type === "reasoning") {
+    if (!item.text) return null;
+    return {
+      id: `reasoning-${item.id}`,
+      type: "reasoning",
+      content: item.text,
+      status: normalizeCodexAspTranscriptStatus(item.status),
+      timestamp: item.timestamp,
+      ...item.sourceTimestamp ? { sourceTimestamp: item.sourceTimestamp } : {}
+    };
+  }
+  if (item.type === "commandExecution") {
+    const skillNames = skillNamesFromCommand(item.command);
+    return {
+      id: `command-${item.id}`,
+      type: "command",
+      command: item.command,
+      ...skillNames.length > 0 ? { skillNames } : {},
+      output: item.output,
+      exitCode: item.exitCode ?? void 0,
+      status: normalizeCodexAspTranscriptStatus(item.status),
+      timestamp: item.timestamp
+    };
+  }
+  if (item.type === "fileChange") {
+    return {
+      id: `patch-${item.id}`,
+      type: "patch",
+      operations: item.operations,
+      output: item.output,
+      exitCode: item.exitCode ?? void 0,
+      status: normalizeCodexAspTranscriptStatus(item.status),
+      timestamp: item.timestamp
+    };
+  }
+  if (item.type === "toolCall") {
+    return createCallDisplayMessage({
+      id: `toolcall-${item.id}`,
+      server: item.server,
+      tool: item.tool,
+      input: inputForDisplay(item.input),
+      output: item.output,
+      status: normalizeCodexAspTranscriptStatus(item.status),
+      timestamp: item.timestamp
+    });
+  }
+  if (item.type === "subagent") {
+    return {
+      id: `subagent-${item.id}`,
+      type: "subagent",
+      toolUseId: item.id,
+      description: item.description,
+      prompt: item.prompt,
+      subagentType: item.subagentType,
+      ...item.receiverThreadIds ? { receiverThreadIds: item.receiverThreadIds } : {},
+      ...item.model ? { model: item.model } : {},
+      status: normalizeCodexAspTranscriptStatus(item.status),
+      ...item.output ? { output: item.output } : {},
+      nestedEvents: [],
+      timestamp: item.timestamp
+    };
+  }
+  if (item.type === "webSearch") {
+    return {
+      id: `web-search-${item.id}`,
+      type: "web_search",
+      query: item.query,
+      status: normalizeCodexAspTranscriptStatus(item.status),
+      timestamp: item.timestamp
+    };
+  }
+  if (item.type === "contextCompaction") {
+    return {
+      id: `reasoning-${item.id}`,
+      type: "reasoning",
+      content: "Context compacted",
+      status: normalizeCodexAspTranscriptStatus(item.status),
+      timestamp: item.timestamp
+    };
+  }
+  return {
+    id: `error-${item.id}`,
+    type: "error",
+    message: item.message,
+    timestamp: item.timestamp
+  };
+}
+function skillMessagesForItem(item) {
+  if (item.type !== "userMessage" || !item.skillNames) return [];
+  return item.skillNames.filter((skillName) => skillName.trim().length > 0).map((skillName, index) => ({
+    id: `skill-${item.id}-${index}`,
+    type: "skill",
+    skillName,
+    status: "completed",
+    timestamp: item.timestamp
+  }));
+}
+
 // ../shared/src/display-message/parsers/codex-parser.ts
 function getStatusFromExitCode(exitCode) {
   return exitCode === 0 ? "completed" : "failed";
@@ -3918,17 +4164,29 @@ function parsePatch(input) {
 }
 function parseCodexEvents(events) {
   const messages = [];
+  const turns = collectCodexTurns(events);
+  const turnInsertions = [];
   const pendingCommands = /* @__PURE__ */ new Map();
   const pendingToolCalls = /* @__PURE__ */ new Map();
   const pendingPatches = /* @__PURE__ */ new Map();
   events.forEach((event, eventIndex) => {
+    const turnId = codexItemFromEvent(event)?.turnId ?? codexTurnFromEvent(event)?.turnId;
+    if (turnId !== void 0) {
+      if (!turnInsertions.some((insertion) => insertion.turnId === turnId)) {
+        turnInsertions.push({ index: messages.length, turnId });
+      }
+      return;
+    }
     if (event.type === "codex-asp-error") {
-      messages.push({
-        id: displayId(event, eventIndex, "error"),
-        type: "error",
-        message: getPayloadString(event, "message") ?? "Codex run failed",
-        timestamp: event.timestamp
-      });
+      const failedTurnId = getPayloadString(event, CODEX_ASP_ITEM_ID_PAYLOAD_KEY);
+      if (!(failedTurnId && turns.has(failedTurnId))) {
+        messages.push({
+          id: displayId(event, eventIndex, "error"),
+          type: "error",
+          message: getPayloadString(event, "message") ?? "Codex run failed",
+          timestamp: event.timestamp
+        });
+      }
       return;
     }
     if (event.type === CODEX_QUOTA_STATUS_EVENT_TYPE) {
@@ -4087,6 +4345,25 @@ function parseCodexEvents(events) {
       }
     }
   });
+  const claimedPrompts = /* @__PURE__ */ new Set();
+  for (const { index, turnId } of turnInsertions.reverse()) {
+    const turn = turns.get(turnId);
+    if (!turn) continue;
+    const kept = [];
+    for (const message of messagesForCodexTurn(turn)) {
+      const recordedIndex = message.type === "user" ? messages.findLastIndex((candidate, candidateIndex) => candidateIndex < index && candidate.type === "user" && candidate.content === message.content && !claimedPrompts.has(candidateIndex)) : -1;
+      if (recordedIndex === -1) {
+        kept.push(message);
+        continue;
+      }
+      claimedPrompts.add(recordedIndex);
+      const recorded = messages[recordedIndex];
+      if (recorded.type === "user" && message.type === "user" && !recorded.images && message.images) {
+        messages[recordedIndex] = { ...recorded, images: message.images };
+      }
+    }
+    messages.splice(index, 0, ...kept);
+  }
   return messages;
 }
 
@@ -5659,296 +5936,6 @@ function parseClaudeEvents(events, parentToolUseId) {
   return messages.filter((_2, index) => !staleIndexes.has(index));
 }
 
-// ../shared/src/display-message/parsers/codex-asp-parser.ts
-var DUPLICATE_WINDOW_MS = 5 * 60 * 1e3;
-function nearTimestamp(a, b) {
-  return Math.abs(parseTimestampMs(a) - parseTimestampMs(b)) <= DUPLICATE_WINDOW_MS;
-}
-function inputForDisplay(input) {
-  if (input === void 0 || input === null) return void 0;
-  if (typeof input === "string") return input;
-  if (isRecord(input)) return input;
-  return String(input);
-}
-function isInternalUserMessage(content) {
-  const trimmed = content.trim();
-  return trimmed.startsWith("<environment_context>") || trimmed.startsWith("<goal_context>");
-}
-function messageForItem(item) {
-  if (item.type === "userMessage") {
-    if (isInternalUserMessage(item.content)) return null;
-    return {
-      id: `user-${item.id}`,
-      type: "user",
-      content: item.content,
-      images: item.images,
-      timestamp: item.timestamp
-    };
-  }
-  if (item.type === "agentMessage" || item.type === "plan") {
-    if (!item.text) return null;
-    return {
-      id: `agent-${item.id}`,
-      type: "agent",
-      content: item.text,
-      timestamp: item.timestamp,
-      ...item.type === "plan" ? { isPlan: true } : {}
-    };
-  }
-  if (item.type === "reasoning") {
-    if (!item.text) return null;
-    return {
-      id: `reasoning-${item.id}`,
-      type: "reasoning",
-      content: item.text,
-      status: normalizeCodexAspTranscriptStatus(item.status),
-      timestamp: item.timestamp,
-      ...item.sourceTimestamp ? { sourceTimestamp: item.sourceTimestamp } : {}
-    };
-  }
-  if (item.type === "commandExecution") {
-    const skillNames = skillNamesFromCommand(item.command);
-    return {
-      id: `command-${item.id}`,
-      type: "command",
-      command: item.command,
-      ...skillNames.length > 0 ? { skillNames } : {},
-      output: item.output,
-      exitCode: item.exitCode ?? void 0,
-      status: normalizeCodexAspTranscriptStatus(item.status),
-      timestamp: item.timestamp
-    };
-  }
-  if (item.type === "fileChange") {
-    return {
-      id: `patch-${item.id}`,
-      type: "patch",
-      operations: item.operations,
-      output: item.output,
-      exitCode: item.exitCode ?? void 0,
-      status: normalizeCodexAspTranscriptStatus(item.status),
-      timestamp: item.timestamp
-    };
-  }
-  if (item.type === "toolCall") {
-    return createCallDisplayMessage({
-      id: `toolcall-${item.id}`,
-      server: item.server,
-      tool: item.tool,
-      input: inputForDisplay(item.input),
-      output: item.output,
-      status: normalizeCodexAspTranscriptStatus(item.status),
-      timestamp: item.timestamp
-    });
-  }
-  if (item.type === "subagent") {
-    return {
-      id: `subagent-${item.id}`,
-      type: "subagent",
-      toolUseId: item.id,
-      description: item.description,
-      prompt: item.prompt,
-      subagentType: item.subagentType,
-      ...item.receiverThreadIds ? { receiverThreadIds: item.receiverThreadIds } : {},
-      ...item.model ? { model: item.model } : {},
-      status: normalizeCodexAspTranscriptStatus(item.status),
-      ...item.output ? { output: item.output } : {},
-      nestedEvents: [],
-      timestamp: item.timestamp
-    };
-  }
-  if (item.type === "webSearch") {
-    return {
-      id: `web-search-${item.id}`,
-      type: "web_search",
-      query: item.query,
-      status: normalizeCodexAspTranscriptStatus(item.status),
-      timestamp: item.timestamp
-    };
-  }
-  if (item.type === "contextCompaction") {
-    return {
-      id: `reasoning-${item.id}`,
-      type: "reasoning",
-      content: "Context compacted",
-      status: normalizeCodexAspTranscriptStatus(item.status),
-      timestamp: item.timestamp
-    };
-  }
-  return {
-    id: `error-${item.id}`,
-    type: "error",
-    message: item.message,
-    timestamp: item.timestamp
-  };
-}
-function skillMessagesForItem(item) {
-  if (item.type !== "userMessage" || !item.skillNames) return [];
-  return item.skillNames.filter((skillName) => skillName.trim().length > 0).map((skillName, index) => ({
-    id: `skill-${item.id}-${index}`,
-    type: "skill",
-    skillName,
-    status: "completed",
-    timestamp: item.timestamp
-  }));
-}
-function parseLatestCodexAspTranscriptTurn(transcript) {
-  const latestTurn = transcript.turns.reduce((latest, turn) => !latest || Date.parse(turn.startedAt) >= Date.parse(latest.startedAt) ? turn : latest, null);
-  return latestTurn ? parseCodexAspTranscript({ ...transcript, turns: [latestTurn] }) : [];
-}
-function stableString(value) {
-  if (value === void 0) return "";
-  if (typeof value !== "object" || value === null) return String(value);
-  try {
-    return JSON.stringify(value, Object.keys(value).sort());
-  } catch {
-    return String(value);
-  }
-}
-function duplicateKey(message) {
-  if (message.type === "user" || message.type === "agent" || message.type === "reasoning") {
-    return JSON.stringify([message.type, message.content]);
-  }
-  if (message.type === "command") return JSON.stringify([message.type, message.command]);
-  if (message.type === "web_search") return JSON.stringify([message.type, message.query]);
-  if (message.type === "subagent") {
-    return JSON.stringify([
-      message.type,
-      message.description,
-      message.prompt,
-      message.subagentType,
-      message.model
-    ]);
-  }
-  if (message.type === "todo_list") {
-    return JSON.stringify([message.type, stableString(message.items)]);
-  }
-  if (message.type === "patch") {
-    return JSON.stringify([message.type, stableString(message.operations)]);
-  }
-  if (message.type === "tool_call") {
-    return JSON.stringify([
-      message.type,
-      message.server,
-      message.tool,
-      stableString(message.input)
-    ]);
-  }
-  return null;
-}
-function duplicateBucketKey(message, bucketOffset = 0) {
-  const key = duplicateKey(message);
-  if (key === null) return null;
-  const bucket = Math.floor(parseTimestampMs(message.timestamp) / DUPLICATE_WINDOW_MS) + bucketOffset;
-  return JSON.stringify([bucket, key]);
-}
-function mergeCodexAspDisplayMessages(primary, supplemental) {
-  const merged = [...primary];
-  const primaryCount = primary.length;
-  const firstIndexById = /* @__PURE__ */ new Map();
-  const indexesByDuplicateBucket = /* @__PURE__ */ new Map();
-  const indexMessage = (message, index) => {
-    if (!firstIndexById.has(message.id)) firstIndexById.set(message.id, index);
-    const key = duplicateBucketKey(message);
-    if (key === null) return;
-    const indexes = indexesByDuplicateBucket.get(key) ?? /* @__PURE__ */ new Set();
-    indexes.add(index);
-    indexesByDuplicateBucket.set(key, indexes);
-  };
-  const unindexMessage = (message, index) => {
-    const key = duplicateBucketKey(message);
-    if (key === null) return;
-    const indexes = indexesByDuplicateBucket.get(key);
-    indexes?.delete(index);
-    if (indexes?.size === 0) indexesByDuplicateBucket.delete(key);
-  };
-  merged.forEach(indexMessage);
-  for (const message of supplemental) {
-    let duplicateIndex = firstIndexById.get(message.id);
-    if (duplicateIndex === void 0) {
-      for (let bucketOffset = -1; bucketOffset <= 1; bucketOffset += 1) {
-        const key = duplicateBucketKey(message, bucketOffset);
-        for (const index of (key === null ? void 0 : indexesByDuplicateBucket.get(key)) ?? []) {
-          if (nearTimestamp(merged[index].timestamp, message.timestamp) && (duplicateIndex === void 0 || index < duplicateIndex)) {
-            duplicateIndex = index;
-          }
-        }
-      }
-    }
-    if (duplicateIndex === void 0) {
-      indexMessage(message, merged.push(message) - 1);
-    } else if (message.type === "user") {
-      unindexMessage(merged[duplicateIndex], duplicateIndex);
-      merged[duplicateIndex] = {
-        ...merged[duplicateIndex],
-        id: message.id
-      };
-      firstIndexById.set(message.id, duplicateIndex);
-      indexMessage(merged[duplicateIndex], duplicateIndex);
-    }
-  }
-  const ordered = merged.slice(0, primaryCount);
-  const supplementalOnly = merged.slice(primaryCount).map((message, index) => ({ message, index })).sort((a, b) => parseTimestampMs(a.message.timestamp) - parseTimestampMs(b.message.timestamp) || a.index - b.index);
-  for (const { message } of supplementalOnly) {
-    insertDisplayMessageByTimestamp(ordered, message);
-  }
-  return ordered;
-}
-function parseCodexAspTranscript(transcript) {
-  const messages = [];
-  const orderedItems = transcript.turns.map((turn, turnIndex) => ({ turn, turnIndex })).flatMap(({ turn, turnIndex }) => turn.items.map((item, itemIndex) => ({ item, turn, turnIndex, itemIndex }))).sort((a, b) => {
-    const aSequence = a.item.sequence ?? Number.MAX_SAFE_INTEGER;
-    const bSequence = b.item.sequence ?? Number.MAX_SAFE_INTEGER;
-    return aSequence - bSequence || parseTimestampMs(a.item.timestamp) - parseTimestampMs(b.item.timestamp) || a.turnIndex - b.turnIndex || a.itemIndex - b.itemIndex;
-  });
-  const reasoningByTurnId = /* @__PURE__ */ new Map();
-  for (const { item, turn } of orderedItems) {
-    if (item.type !== "reasoning" || !item.text.trim()) continue;
-    const reasoning = reasoningByTurnId.get(turn.id) ?? [];
-    reasoning.push(item);
-    reasoningByTurnId.set(turn.id, reasoning);
-  }
-  const emittedReasoningTurnIds = /* @__PURE__ */ new Set();
-  const coalescedItems = orderedItems.flatMap((entry) => {
-    if (entry.item.type !== "reasoning") return [entry];
-    const reasoning = reasoningByTurnId.get(entry.turn.id);
-    if (!reasoning || emittedReasoningTurnIds.has(entry.turn.id)) return [];
-    emittedReasoningTurnIds.add(entry.turn.id);
-    return [{
-      ...entry,
-      item: {
-        type: "reasoning",
-        id: entry.turn.id,
-        text: reasoning.map(({ text }) => text.trim()).join("\n\n"),
-        timestamp: entry.turn.startedAt,
-        ...reasoning[0] ? { sourceTimestamp: reasoning[0].timestamp } : {},
-        status: reasoning.at(-1)?.status ?? "completed",
-        sequence: entry.item.sequence
-      }
-    }];
-  });
-  for (const turn of transcript.turns) {
-    const reasoningIndex = coalescedItems.findIndex(({ item, turn: itemTurn }) => itemTurn.id === turn.id && item.type === "reasoning");
-    if (reasoningIndex === -1) continue;
-    const responseItem = getCodexAspTurnResponse({
-      status: turn.status,
-      items: coalescedItems.filter(({ turn: itemTurn }) => itemTurn.id === turn.id).map(({ item }) => item)
-    });
-    const finalAnswerIndex = responseItem ? coalescedItems.findIndex(({ item }) => item === responseItem) : -1;
-    if (finalAnswerIndex === -1 || reasoningIndex < finalAnswerIndex) continue;
-    const [reasoning] = coalescedItems.splice(reasoningIndex, 1);
-    coalescedItems.splice(finalAnswerIndex, 0, reasoning);
-  }
-  for (const { item } of coalescedItems) {
-    const message = messageForItem(item);
-    if (message) {
-      messages.push(message);
-    }
-    messages.push(...skillMessagesForItem(item));
-  }
-  return messages;
-}
-
 // ../shared/src/display-message/parsers/index.ts
 var INTERRUPTION_DEDUP_WINDOW_MS = 15e3;
 function parseAgentEvents(events, agentType) {
@@ -5982,22 +5969,19 @@ function parseAgentEvents(events, agentType) {
   }
   return parseClaudeEvents(events);
 }
-function parseDisplayMessages(events, agentType, codexAspTranscript, options = {}) {
+function parseDisplayMessages(events, agentType, options = {}) {
   events = excludeQueuedAcceptedEvents(events, []);
-  const shouldFilter = options.filter ?? true;
   const parsedEvents = agentType === "claude" || agentType === "relay" ? parseClaudeEvents(events, options.parentToolUseId) : parseAgentEvents(events, agentType);
   const reconciledEvents = [];
   for (const message of parsedEvents) {
     if (message.type === "user") upsertDisplayMessage(reconciledEvents, message);
     else reconciledEvents.push(message);
   }
-  const legacyMessages = shouldFilter ? filterDisplayMessages(reconciledEvents, agentType) : reconciledEvents;
-  const applySyntheticNotices = (messages) => shouldFilter ? applyAuthFallbackNotices(applyInterruptions(messages, events), events) : messages;
-  if (agentType !== "codex" || !codexAspTranscript) {
-    return applySyntheticNotices(legacyMessages);
-  }
-  const nativeCodexMessages = shouldFilter ? filterDisplayMessages(parseCodexAspTranscript(codexAspTranscript), agentType) : parseCodexAspTranscript(codexAspTranscript);
-  return applySyntheticNotices(mergeCodexAspDisplayMessages(nativeCodexMessages, legacyMessages));
+  if (options.filter === false) return reconciledEvents;
+  return applyAuthFallbackNotices(
+    applyInterruptions(filterDisplayMessages(reconciledEvents, agentType), events),
+    events
+  );
 }
 function applyInterruptions(messages, events) {
   const result = [...messages];
@@ -6171,52 +6155,64 @@ function areSameUserMessageEvents(a, b) {
     { content: bMessage, timestamp: b.timestamp }
   );
 }
+function parseAgentEventJsonlLine(line, options = {}) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (isAgentBackendEvent(parsed)) return parsed;
+    options.onInvalidLine?.({ line: trimmed });
+  } catch (error) {
+    options.onInvalidLine?.({ line: trimmed, error });
+  }
+  return null;
+}
 function parseAgentEventJsonl(content, options = {}) {
   const events = [];
   for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    try {
-      const parsed = JSON.parse(trimmed);
-      if (isAgentBackendEvent(parsed)) {
-        events.push(parsed);
-      } else {
-        options.onInvalidLine?.({ line: trimmed });
-      }
-    } catch (error) {
-      options.onInvalidLine?.({ line: trimmed, error });
-    }
+    const event = parseAgentEventJsonlLine(line, options);
+    if (event) events.push(event);
   }
   return events;
 }
-function parseAgentEventJsonlWithCodexAspTranscript(content, options = {}) {
-  const events = [];
-  let transcript = null;
-  const transcriptsByThreadId = /* @__PURE__ */ new Map();
-  for (const event of parseAgentEventJsonl(content, options)) {
+
+// ../shared/src/codex-history.ts
+function isChatHistoryEvent(value) {
+  return isAgentBackendEvent(value) && value.type !== CODEX_ASP_TRANSCRIPT_UPDATED_EVENT_TYPE && value.type !== CODEX_HISTORY_FORMAT_EVENT_TYPE;
+}
+function codexHistoryFormatEvent() {
+  return { timestamp: (/* @__PURE__ */ new Date()).toISOString(), type: CODEX_HISTORY_FORMAT_EVENT_TYPE, payload: { version: 2 } };
+}
+function chronological(events) {
+  return [...events].sort((a, b) => getEventTimestampMs(a) - getEventTimestampMs(b));
+}
+var CodexHistoryEventFolder = class {
+  events = [];
+  transcripts = /* @__PURE__ */ new Map();
+  push(event) {
+    if (event.type === CODEX_HISTORY_FORMAT_EVENT_TYPE) return;
     if (event.type !== CODEX_ASP_TRANSCRIPT_UPDATED_EVENT_TYPE) {
-      events.push(event);
-      continue;
+      this.events.push(event);
+      return;
     }
     const delta = event.payload.transcriptDelta;
-    if (isCodexAspTranscriptDelta(delta)) {
-      const previous = transcriptsByThreadId.get(delta.threadId) ?? null;
-      transcript = applyCodexAspTranscriptDelta(previous, delta);
-    } else if (isCodexAspTranscript(event.payload.transcript)) {
-      transcript = event.payload.transcript;
-    }
-    if (transcript) {
-      transcriptsByThreadId.set(transcript.threadId, transcript);
-    }
+    const transcript = isCodexAspTranscriptDelta(delta) ? applyCodexAspTranscriptDelta(this.transcripts.get(delta.threadId) ?? null, delta) : isCodexAspTranscript(event.payload.transcript) ? event.payload.transcript : null;
+    if (transcript) this.transcripts.set(transcript.threadId, transcript);
+  }
+  finish() {
+    return chronological([...this.events, ...[...this.transcripts.values()].flatMap(codexTranscriptToEvents)]);
   }
-  return { events, transcript, transcriptsByThreadId };
+};
+function parseCodexHistoryEvents(content, options) {
+  const folder = new CodexHistoryEventFolder();
+  for (const event of parseAgentEventJsonl(content, options)) folder.push(event);
+  return folder.finish();
 }
 
 // ../shared/src/transcript-canonicalize.ts
 function canonicalizeChatTranscriptBlocks(content, provider, senders) {
-  const parsed = parseAgentEventJsonlWithCodexAspTranscript(content);
   const messages = attachSendersToMessages(
-    parseDisplayMessages(parsed.events, provider, parsed.transcript),
+    parseDisplayMessages(parseCodexHistoryEvents(content), provider),
     senders
   );
   return messages.flatMap((message) => {
@@ -7768,33 +7764,6 @@ function parseChatTranscriptHistoryIndex(value) {
     }
   };
 }
-function getChatTranscriptHistorySize(index) {
-  return index.codexAspTranscript?.size ?? 0;
-}
-function createChatTranscriptPages(sourceBytes) {
-  const history = parseAgentEventJsonlWithCodexAspTranscript(new TextDecoder("utf-8", { fatal: true }).decode(sourceBytes));
-  const removedMessageIds = /* @__PURE__ */ new Set();
-  for (const event of history.events) {
-    for (const messageId of getRemovedMessageIds(event)) removedMessageIds.add(messageId);
-  }
-  const bytes = new TextEncoder().encode(history.transcript?.turns.length ? `${history.transcript.turns.map((turn) => JSON.stringify(turn)).join("\n")}
-` : "");
-  return {
-    bytes,
-    index: {
-      version: 2,
-      sourceSize: sourceBytes.byteLength,
-      ...removedMessageIds.size ? { removedMessageIds: [...removedMessageIds] } : {},
-      ...history.transcript ? {
-        codexAspTranscript: {
-          threadId: history.transcript.threadId,
-          updatedAt: history.transcript.updatedAt,
-          size: bytes.byteLength
-        }
-      } : {}
-    }
-  };
-}
 function isNonNegativeInteger(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 }
@@ -7997,13 +7966,13 @@ export {
   agentQuotaExhaustedPayloadSchema,
   defaultForkChatTitle,
   CLAUDE_PARTIAL_MESSAGE_EVENT_TYPE,
-  getClaudePartialMessageStreamId,
   ACCEPTED_USER_MESSAGE_SOURCE,
   QUEUED_MESSAGE_REMOVED_EVENT_TYPE,
   REMOVED_MESSAGE_IDS_PAYLOAD_KEY,
   USER_MESSAGE_ID_PAYLOAD_KEY,
   CODEX_ASP_ITEM_ID_PAYLOAD_KEY,
-  CODEX_ASP_TRANSCRIPT_UPDATED_EVENT_TYPE,
+  CODEX_HISTORY_FORMAT_EVENT_TYPE,
+  getEventStreamId,
   CODEX_QUOTA_STATUS_EVENT_TYPE,
   COMPACTION_STATUS_EVENT_TYPE,
   CHAT_INTERRUPTED_EVENT_TYPE,
@@ -8028,17 +7997,15 @@ export {
   normalizeCodexAspTranscriptStatus,
   imageContentToUserMessageImages,
   createAcceptedUserMessageEvent,
-  getCodexAspTurnResponse,
-  renumberCodexAspTranscriptItems,
-  isCodexAspTranscript,
-  isCodexAspTranscriptDelta,
-  applyCodexAspTranscriptDelta,
+  codexItemEvent,
+  codexTurnEvent,
+  codexTurnFromEvent,
+  codexTranscriptToEvents,
   isLatestChatHistoryPage,
   getChatHistoryPageSenders,
   parseChatHistoryCursor,
   createChatHistoryCursor,
   chatHistoryPageParamsFromQuery,
-  getChatHistoryPageWindow,
   paginateChatHistory,
   coerceBackgroundTaskPayload,
   isGitHubUrl,
@@ -8057,17 +8024,18 @@ export {
   coerceClaudeResultPayload,
   stripAgentDiagnosticErrors,
   isClaudeResultError,
-  parseLatestCodexAspTranscriptTurn,
   parseAgentEvents,
   parseDisplayMessages,
-  isAgentBackendEvent,
   getUserMessage,
   getUserMessageId,
   getRemovedMessageIds,
   excludeQueuedAcceptedEvents,
   getEventTimestampMs,
   areSameUserMessageEvents,
-  parseAgentEventJsonlWithCodexAspTranscript,
+  parseAgentEventJsonlLine,
+  isChatHistoryEvent,
+  codexHistoryFormatEvent,
+  CodexHistoryEventFolder,
   getMemoryOutputSafetyViolation,
   canonicalizeChatTranscriptBlocks,
   lastUserBlockText,
@@ -8133,8 +8101,6 @@ export {
   isExcludedRepoFilePath,
   formatChatForkHandoffMessage,
   readJsonlPage,
-  getChatTranscriptHistorySize,
-  createChatTranscriptPages,
   parseChatTranscriptArtifact,
   readSseStream,
   parseFrontmatter,