replicas-cli 0.2.699 → 0.2.701

package/dist/index.cjs

@@ -22917,6 +22917,9 @@ 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_ITEM_EVENT_TYPE = "codex-item";
+var CODEX_ITEM_PARTIAL_EVENT_TYPE = "codex-item-partial";
+var CODEX_TURN_EVENT_TYPE = "codex-turn";
 var CODEX_QUOTA_STATUS_EVENT_TYPE = "codex-quota-status";
 var CHAT_INTERRUPTED_EVENT_TYPE = "replicas-interrupted";
 var AUTH_FALLBACK_EVENT_TYPE = "auth-fallback";
@@ -23030,6 +23033,38 @@ function getCodexAspTurnResponse(turn) {
   if (normalizeCodexAspTranscriptStatus(turn.status) === "in_progress") return null;
   return turn.items.findLast((item) => item.type === "agentMessage") ?? null;
 }
+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: error51 } = event.payload;
+  return typeof turnId === "string" && typeof status === "string" ? { turnId, status, ...typeof error51 === "string" ? { error: error51 } : {} } : null;
+}
 
 // ../shared/src/display-message/types.ts
 var BACKGROUND_TASK_SUBTYPES = /* @__PURE__ */ new Set([
@@ -25008,6 +25043,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";
@@ -25082,10 +25312,31 @@ 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") {
+      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) {
       const state = event.payload?.state;
       if (state) {
@@ -25242,6 +25493,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;
 }
 
@@ -26785,292 +27055,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 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) {
@@ -27104,22 +27088,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];
@@ -27369,7 +27350,7 @@ var headlessFilesystemAgentResultSchema = external_exports.object({
 });
 
 // ../shared/src/cli-version.ts
-var CLI_VERSION = "0.2.699";
+var CLI_VERSION = "0.2.701";
 
 // ../shared/src/version.ts
 function compareVersions(v1, v2) {
@@ -30093,7 +30074,7 @@ Conversation History
     }
     console.log(import_chalk15.default.gray("-".repeat(60)));
     const agentType = response.coding_agent || "claude";
-    const displayMessages = parseDisplayMessages(response.events, agentType, response.codexAspTranscript);
+    const displayMessages = parseDisplayMessages(response.events, agentType);
     for (const message of displayMessages) {
       formatDisplayMessage(message);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-cli",
-  "version": "0.2.699",
+  "version": "0.2.701",
   "description": "CLI for managing Replicas workspaces - SSH into cloud dev environments with automatic port forwarding",
   "main": "dist/index.cjs",
   "bin": {