@axhub/genie 0.2.11 → 0.2.12

package/shared/conversationEvents.js

@@ -1,3 +1,11 @@
+import {
+  buildAcpCapabilities,
+  normalizeAcpAvailableCommands,
+  normalizeAcpConfigOptions,
+  normalizeAcpModeState,
+  normalizeAcpTokenUsage
+} from './acpCapabilities.js';
+
 export const SUPPORTED_PROVIDERS = ['claude', 'codex', 'gemini', 'opencode'];
 
 export const SESSION_STATES = [
@@ -6,6 +14,7 @@ export const SESSION_STATES = [
   'idle',
   'streaming',
   'awaiting_approval',
+  'awaiting_input',
   'completed',
   'aborted',
   'errored'
@@ -32,6 +41,8 @@ export const CONVERSATION_EVENT_KINDS = {
   USAGE_UPDATE: 'usage_update',
   APPROVAL_REQUEST: 'approval_request',
   APPROVAL_RESOLVED: 'approval_resolved',
+  ELICITATION_REQUEST: 'elicitation_request',
+  ELICITATION_RESOLVED: 'elicitation_resolved',
   ARTIFACT_CREATED: 'artifact_created',
   SESSION_STATE_CHANGED: 'session_state_changed',
   SYSTEM_NOTICE: 'system_notice',
@@ -75,6 +86,43 @@ export function createConversationEvent({
   };
 }
 
+export function createUserMessageConversationEvent({
+  provider = 'claude',
+  sessionId = null,
+  timestamp,
+  text = '',
+  contentBlocks = [],
+  clientRequestId = null,
+  eventId = null,
+  extensions = {},
+  rawRef = null
+} = {}) {
+  const normalizedClientRequestId = typeof clientRequestId === 'string' && clientRequestId.trim()
+    ? clientRequestId.trim()
+    : null;
+
+  return createConversationEvent({
+    kind: CONVERSATION_EVENT_KINDS.USER_MESSAGE,
+    provider,
+    sessionId,
+    timestamp,
+    eventId,
+    payload: {
+      text: String(text || ''),
+      contentBlocks: normalizeMessageContentBlocks(contentBlocks)
+    },
+    extensions: {
+      runtimeSource: 'acp',
+      ...(normalizedClientRequestId ? { clientRequestId: normalizedClientRequestId } : {}),
+      ...extensions
+    },
+    rawRef: rawRef || {
+      runtime: 'acp',
+      sourceType: 'acp-user-prompt'
+    }
+  });
+}
+
 export function isConversationEvent(value) {
   return !!(
     value &&
@@ -208,11 +256,23 @@ function hasAcpProtocolTags(value) {
   return /<\/?(?:subagent_notification|environment_context|dynamic_context|user_message)(?:\s[^>]*)?>/i.test(String(value || ''));
 }
 
-export function stripAssistantProtocolTags(text) {
+function stripAssistantThoughtProtocolPrelude(value) {
+  const text = String(value || '');
+  const markerPattern = /\[\s*Thought\s*:\s*true\s*\]/gi;
+  let markerEnd = -1;
+  let match;
+  while ((match = markerPattern.exec(text)) !== null) {
+    markerEnd = markerPattern.lastIndex;
+  }
+  return markerEnd >= 0 ? text.slice(markerEnd) : value;
+}
+
+export function stripAssistantProtocolTags(text, options = {}) {
   if (typeof text !== 'string') {
     return text;
   }
 
+  const shouldTrim = options.trim !== false;
   const visibleUserMessage = extractProtocolUserMessage(text);
   if (visibleUserMessage != null) {
     return visibleUserMessage;
@@ -230,7 +290,9 @@ export function stripAssistantProtocolTags(text) {
     result = result.replace(/["']?\s*\}\s*\}\s*$/g, '');
   }
 
-  return result.trim();
+  result = stripAssistantThoughtProtocolPrelude(result);
+
+  return shouldTrim ? result.trim() : result;
 }
 
 function extractVisibleUserMessage(value) {
@@ -331,6 +393,153 @@ function getTimelineMessageClientRequestId(message) {
     : null;
 }
 
+function getConversationEventMessageId(event, payload = {}) {
+  const rawValue = payload?.messageId || event?.extensions?.messageId || null;
+  return typeof rawValue === 'string' && rawValue.trim()
+    ? rawValue.trim()
+    : null;
+}
+
+function isReplayConversationEvent(event) {
+  const sourceType = String(event?.rawRef?.sourceType || '').trim().toLowerCase();
+  return Boolean(event?.extensions?.runtimeReplay) || sourceType === 'acp-session-loaded-replay';
+}
+
+function isUserEchoConversationEvent(event) {
+  const sourceType = String(event?.rawRef?.sourceType || '').trim().toLowerCase();
+  return sourceType === 'acp-user-message-chunk' || isReplayConversationEvent(event);
+}
+
+function getAppliedConversationEventIds(message) {
+  const ids = new Set();
+  if (typeof message?.eventId === 'string' && message.eventId.trim()) {
+    ids.add(message.eventId.trim());
+  }
+  if (Array.isArray(message?.appliedConversationEventIds)) {
+    message.appliedConversationEventIds.forEach((eventId) => {
+      if (typeof eventId === 'string' && eventId.trim()) {
+        ids.add(eventId.trim());
+      }
+    });
+  }
+  return ids;
+}
+
+function hasAppliedConversationEvent(messages, event) {
+  const eventId = typeof event?.eventId === 'string' && event.eventId.trim()
+    ? event.eventId.trim()
+    : null;
+  if (!eventId) {
+    return false;
+  }
+  return messages.some((message) => getAppliedConversationEventIds(message).has(eventId));
+}
+
+function markConversationEventApplied(message, event) {
+  const eventId = typeof event?.eventId === 'string' && event.eventId.trim()
+    ? event.eventId.trim()
+    : null;
+  if (!eventId || !message || typeof message !== 'object') {
+    return isReplayConversationEvent(event) && message && typeof message === 'object'
+      ? { ...message, runtimeReplay: true }
+      : message;
+  }
+
+  const existingIds = getAppliedConversationEventIds(message);
+  if (existingIds.has(eventId)) {
+    return isReplayConversationEvent(event) && message.runtimeReplay !== true
+      ? { ...message, runtimeReplay: true }
+      : message;
+  }
+
+  return {
+    ...message,
+    ...(isReplayConversationEvent(event) ? { runtimeReplay: true } : {}),
+    appliedConversationEventIds: [
+      ...(Array.isArray(message.appliedConversationEventIds) ? message.appliedConversationEventIds : []),
+      eventId
+    ]
+  };
+}
+
+function findCompletedTextMessageIndex(messages, { messageId, isThinking = false } = {}) {
+  if (!messageId) {
+    return -1;
+  }
+
+  return findLatestTimelineMessageIndex(messages, (message) => (
+    message?.eventMessageId === messageId &&
+    !message.isToolUse &&
+    !!message.isThinking === !!isThinking &&
+    message.isStreaming === false
+  ));
+}
+
+function isAssistantTextTimelineMessage(message, { isThinking = false } = {}) {
+  return (
+    String(message?.type || '').trim().toLowerCase() === 'assistant' &&
+    !message.isToolUse &&
+    !!message.isThinking === !!isThinking
+  );
+}
+
+function getTimelineMessageText(message) {
+  return String(message?.content || message?.reasoning || '').trim();
+}
+
+function getTimelineTextSignature(message, { isThinking = false } = {}) {
+  if (!isAssistantTextTimelineMessage(message, { isThinking })) {
+    return null;
+  }
+
+  const text = getTimelineMessageText(message);
+  if (!text) {
+    return null;
+  }
+
+  return `${isThinking ? 'reasoning' : 'answer'}\u0000${text}`;
+}
+
+function removeDuplicateReplayTextMessages(messages, { isThinking = false } = {}) {
+  const seenSignatures = new Set();
+  const completedTexts = [];
+  const nextMessages = [];
+
+  for (const message of messages) {
+    const isTextMessage = isAssistantTextTimelineMessage(message, { isThinking });
+    const text = isTextMessage ? getTimelineMessageText(message) : '';
+    const signature = getTimelineTextSignature(message, { isThinking });
+    if (message?.runtimeReplay === true && isTextMessage) {
+      const replayIsCoveredByCompletedMessage = completedTexts.some((completedText) => (
+        !text || completedText === text || completedText.includes(text)
+      ));
+      if ((signature && seenSignatures.has(signature)) || replayIsCoveredByCompletedMessage) {
+        continue;
+      }
+    }
+    if (signature) {
+      seenSignatures.add(signature);
+    }
+    if (isTextMessage && message?.isStreaming === false && text) {
+      completedTexts.push(text);
+    }
+    nextMessages.push(message);
+  }
+
+  return nextMessages;
+}
+
+function shouldDedupeReplayTextEvent(event) {
+  return isReplayConversationEvent(event) && (
+    event.kind === CONVERSATION_EVENT_KINDS.ASSISTANT_TEXT_START ||
+    event.kind === CONVERSATION_EVENT_KINDS.ASSISTANT_TEXT_DELTA ||
+    event.kind === CONVERSATION_EVENT_KINDS.ASSISTANT_TEXT_END ||
+    event.kind === CONVERSATION_EVENT_KINDS.REASONING_START ||
+    event.kind === CONVERSATION_EVENT_KINDS.REASONING_DELTA ||
+    event.kind === CONVERSATION_EVENT_KINDS.REASONING_END
+  );
+}
+
 function buildComparableUserMessageContentBlocks(message = {}) {
   const imageBlocks = Array.isArray(message?.images)
     ? message.images.map((image) => ({
@@ -349,22 +558,36 @@ function buildComparableUserMessageContentBlocks(message = {}) {
 
 function findMatchingOptimisticUserMessageIndex(messages, event, payload = {}) {
   const clientRequestId = getConversationEventClientRequestId(event);
-  if (!clientRequestId) {
+  if (!clientRequestId && !isUserEchoConversationEvent(event)) {
     return -1;
   }
 
   const expectedContentBlocks = JSON.stringify(normalizeMessageContentBlocks(payload.contentBlocks));
+  const rawText = typeof payload.text === 'string' ? payload.text : '';
+  const visibleText = rawText ? extractVisibleUserMessage(rawText) : '';
+  const expectedText = visibleText || rawText;
 
   return findLatestTimelineMessageIndex(messages, (message) => {
     if (String(message?.type || '').trim().toLowerCase() !== 'user') {
       return false;
     }
 
-    if (getTimelineMessageClientRequestId(message) !== clientRequestId) {
+    const messageClientRequestId = getTimelineMessageClientRequestId(message);
+    if (clientRequestId) {
+      if (messageClientRequestId !== clientRequestId) {
+        return false;
+      }
+    } else if (!messageClientRequestId) {
       return false;
+    } else {
+      const eventProvider = String(event?.provider || '').trim().toLowerCase();
+      const messageProvider = String(message?.provider || message?.__provider || '').trim().toLowerCase();
+      if (eventProvider && messageProvider && eventProvider !== messageProvider) {
+        return false;
+      }
     }
 
-    if (String(message?.content || '') !== String(payload.text || '')) {
+    if (String(message?.content || '') !== String(expectedText || '')) {
       return false;
     }
 
@@ -373,70 +596,6 @@ function findMatchingOptimisticUserMessageIndex(messages, event, payload = {}) {
   });
 }
 
-function normalizeAcpModeState(value) {
-  if (!value || typeof value !== 'object') {
-    return null;
-  }
-
-  const availableModes = Array.isArray(value.availableModes)
-    ? value.availableModes
-        .filter((mode) => mode && typeof mode === 'object' && String(mode.id || '').trim())
-        .map((mode) => ({
-          id: String(mode.id).trim(),
-          name: String(mode.name || mode.id || '').trim() || String(mode.id).trim(),
-          description: mode.description == null ? null : String(mode.description)
-        }))
-    : [];
-  const currentModeId = typeof value.currentModeId === 'string' && value.currentModeId.trim()
-    ? value.currentModeId.trim()
-    : null;
-
-  if (!availableModes.length && !currentModeId) {
-    return null;
-  }
-
-  return {
-    availableModes,
-    currentModeId: currentModeId || availableModes[0]?.id || null
-  };
-}
-
-function normalizeAcpAvailableCommands(value) {
-  const commands = Array.isArray(value?.availableCommands)
-    ? value.availableCommands
-    : Array.isArray(value)
-      ? value
-      : [];
-
-  return commands
-    .filter((command) => command && typeof command === 'object' && String(command.name || '').trim())
-    .map((command) => ({
-      name: String(command.name).trim(),
-      description: command.description == null ? '' : String(command.description),
-      input: command.input && typeof command.input === 'object' ? cloneJsonValue(command.input) : null,
-      source: 'acp',
-      namespace: 'acp',
-      type: 'acp'
-    }));
-}
-
-function normalizeAcpConfigOptions(value) {
-  const configOptions = Array.isArray(value?.configOptions)
-    ? value.configOptions
-    : Array.isArray(value)
-      ? value
-      : [];
-
-  return configOptions
-    .filter((option) => option && typeof option === 'object' && String(option.key || '').trim())
-    .map((option) => ({
-      key: String(option.key).trim(),
-      description: typeof option.description === 'string' ? option.description : '',
-      value: cloneJsonValue(option.value),
-      schema: option.schema && typeof option.schema === 'object' ? cloneJsonValue(option.schema) : null
-    }));
-}
-
 function normalizeAcpSessionInfo(value) {
   if (!value || typeof value !== 'object') {
     return null;
@@ -459,32 +618,6 @@ function normalizeAcpSessionInfo(value) {
   };
 }
 
-function normalizeAcpTokenUsage(value) {
-  if (!value || typeof value !== 'object') {
-    return null;
-  }
-
-  const used = Number(value.used);
-  const total = Number(value.size);
-  if (!Number.isFinite(used) || used < 0 || !Number.isFinite(total) || total < 0) {
-    return null;
-  }
-
-  const safeUsed = Math.round(used);
-  const safeTotal = Math.round(total);
-  const percentage = safeTotal > 0
-    ? Math.min(100, Math.max(0, Math.round((safeUsed / safeTotal) * 100)))
-    : 0;
-
-  return {
-    used: safeUsed,
-    total: safeTotal,
-    percentage,
-    remaining: Math.max(0, safeTotal - safeUsed),
-    cost: value.cost && typeof value.cost === 'object' ? cloneJsonValue(value.cost) : null
-  };
-}
-
 function mergeToolCallSnapshot(existingSnapshot = null, payload = {}) {
   const nextSnapshot = existingSnapshot && typeof existingSnapshot === 'object'
     ? { ...existingSnapshot }
@@ -555,6 +688,20 @@ function appendDeltaText(existing = '', delta = '') {
   return `${existing}${delta}`;
 }
 
+function closeOpenStreamingTextMessages(messages) {
+  for (let index = 0; index < messages.length; index += 1) {
+    const message = messages[index];
+    if (!message || message.isStreaming !== true || message.isToolUse) {
+      continue;
+    }
+
+    messages[index] = {
+      ...message,
+      isStreaming: false
+    };
+  }
+}
+
 function ensureStreamingTextMessage(messages, {
   messageId,
   timestamp,
@@ -562,10 +709,30 @@ function ensureStreamingTextMessage(messages, {
   isThinking = false,
   kind = 'assistant'
 }) {
-  const index = findLatestTimelineMessageIndex(messages, (message) => (
+  const hasRoleBoundaryAfter = (candidateIndex) => {
+    const targetRole = String(kind || 'assistant').trim().toLowerCase();
+    for (let index = candidateIndex + 1; index < messages.length; index += 1) {
+      const messageRole = String(messages[index]?.type || messages[index]?.role || '').trim().toLowerCase();
+      if (messageRole && messageRole !== targetRole) {
+        return true;
+      }
+    }
+    return false;
+  };
+
+  const index = findLatestTimelineMessageIndex(messages, (message, messageIndex) => (
     message?.eventMessageId === messageId &&
     !message.isToolUse &&
-    !!message.isThinking === !!isThinking
+    !!message.isThinking === !!isThinking &&
+    !hasRoleBoundaryAfter(messageIndex) &&
+    (
+      message.isStreaming !== false ||
+      (
+        !String(message?.content || '').trim() &&
+        Array.isArray(message?.contentBlocks) &&
+        message.contentBlocks.length > 0
+      )
+    )
   ));
 
   if (index >= 0) {
@@ -776,6 +943,7 @@ export function normalizeLegacyHistoryEntries(rawMessages = [], provider = 'clau
 export function applyConversationEventToTimelineMessages(messages = [], event, sessionProvider = 'claude') {
   const nextMessages = Array.isArray(messages) ? [...messages] : [];
   if (!isConversationEvent(event)) return nextMessages;
+  if (hasAppliedConversationEvent(nextMessages, event)) return nextMessages;
 
   const provider = event.provider || sessionProvider;
   const timestamp = event.timestamp || new Date().toISOString();
@@ -783,6 +951,7 @@ export function applyConversationEventToTimelineMessages(messages = [], event, s
 
   switch (event.kind) {
     case CONVERSATION_EVENT_KINDS.USER_MESSAGE: {
+      closeOpenStreamingTextMessages(nextMessages);
       const clientRequestId = getConversationEventClientRequestId(event);
       const optimisticIndex = findMatchingOptimisticUserMessageIndex(nextMessages, event, payload);
       const normalizedContentBlocks = normalizeMessageContentBlocks(payload.contentBlocks);
@@ -799,7 +968,7 @@ export function applyConversationEventToTimelineMessages(messages = [], event, s
           ? normalizedContentBlocks.filter((block) => block?.type !== 'image')
           : normalizedContentBlocks;
 
-        nextMessages[optimisticIndex] = {
+        nextMessages[optimisticIndex] = markConversationEventApplied({
           ...existingMessage,
           type: 'user',
           content: visibleText || existingMessage.content || '',
@@ -809,46 +978,65 @@ export function applyConversationEventToTimelineMessages(messages = [], event, s
           clientRequestId: clientRequestId || existingMessage.clientRequestId || null,
           eventId: event.eventId || existingMessage.eventId,
           id: existingMessage.id || event.eventId || existingMessage.id
-        };
+        }, event);
         break;
       }
 
-      nextMessages.push({
+      nextMessages.push(markConversationEventApplied({
         type: 'user',
         content: visibleText,
         timestamp,
         provider,
         contentBlocks: normalizedContentBlocks,
-        clientRequestId
-      });
+        clientRequestId,
+        eventId: event.eventId
+      }, event));
       break;
     }
 
     case CONVERSATION_EVENT_KINDS.ASSISTANT_TEXT_START: {
-      const messageId = payload.messageId || event.extensions?.messageId || createEventId('assistant_text');
-      ensureStreamingTextMessage(nextMessages, { messageId, timestamp, provider, isThinking: false });
+      const messageId = getConversationEventMessageId(event, payload) || createEventId('assistant_text');
+      const completedReplayIndex = isReplayConversationEvent(event)
+        ? findCompletedTextMessageIndex(nextMessages, { messageId, isThinking: false })
+        : -1;
+      if (completedReplayIndex >= 0) {
+        nextMessages[completedReplayIndex] = markConversationEventApplied(nextMessages[completedReplayIndex], event);
+        break;
+      }
+      const { index } = ensureStreamingTextMessage(nextMessages, { messageId, timestamp, provider, isThinking: false });
+      nextMessages[index] = markConversationEventApplied(nextMessages[index], event);
       break;
     }
 
     case CONVERSATION_EVENT_KINDS.ASSISTANT_TEXT_DELTA: {
-      const messageId = payload.messageId || event.extensions?.messageId || createEventId('assistant_text');
+      const messageId = getConversationEventMessageId(event, payload) || createEventId('assistant_text');
+      const completedReplayIndex = isReplayConversationEvent(event)
+        ? findCompletedTextMessageIndex(nextMessages, { messageId, isThinking: false })
+        : -1;
+      if (completedReplayIndex >= 0) {
+        nextMessages[completedReplayIndex] = markConversationEventApplied(nextMessages[completedReplayIndex], event);
+        break;
+      }
       const { index } = ensureStreamingTextMessage(nextMessages, { messageId, timestamp, provider, isThinking: false });
       const target = { ...nextMessages[index] };
-      target.content = appendDeltaText(target.content || '', payload.text || '');
+      target.content = stripAssistantProtocolTags(
+        appendDeltaText(target.content || '', payload.text || ''),
+        { trim: false }
+      );
       target.timestamp = target.timestamp || timestamp;
       target.provider = target.provider || provider;
-      nextMessages[index] = target;
+      nextMessages[index] = markConversationEventApplied(target, event);
       break;
     }
 
     case CONVERSATION_EVENT_KINDS.ASSISTANT_TEXT_END: {
-      const messageId = payload.messageId || event.extensions?.messageId;
+      const messageId = getConversationEventMessageId(event, payload);
       if (!messageId) break;
       const index = findLatestTimelineMessageIndex(nextMessages, (message) => (
         message?.eventMessageId === messageId && !message.isToolUse && !message.isThinking
       ));
       if (index >= 0) {
-        nextMessages[index] = { ...nextMessages[index], isStreaming: false };
+        nextMessages[index] = markConversationEventApplied({ ...nextMessages[index], isStreaming: false }, event);
       }
       break;
     }
@@ -874,31 +1062,46 @@ export function applyConversationEventToTimelineMessages(messages = [], event, s
     }
 
     case CONVERSATION_EVENT_KINDS.REASONING_START: {
-      const messageId = payload.messageId || event.extensions?.messageId || createEventId('reasoning');
-      ensureStreamingTextMessage(nextMessages, { messageId, timestamp, provider, isThinking: true });
+      const messageId = getConversationEventMessageId(event, payload) || createEventId('reasoning');
+      const completedReplayIndex = isReplayConversationEvent(event)
+        ? findCompletedTextMessageIndex(nextMessages, { messageId, isThinking: true })
+        : -1;
+      if (completedReplayIndex >= 0) {
+        nextMessages[completedReplayIndex] = markConversationEventApplied(nextMessages[completedReplayIndex], event);
+        break;
+      }
+      const { index } = ensureStreamingTextMessage(nextMessages, { messageId, timestamp, provider, isThinking: true });
+      nextMessages[index] = markConversationEventApplied(nextMessages[index], event);
       break;
     }
 
     case CONVERSATION_EVENT_KINDS.REASONING_DELTA: {
-      const messageId = payload.messageId || event.extensions?.messageId || createEventId('reasoning');
+      const messageId = getConversationEventMessageId(event, payload) || createEventId('reasoning');
+      const completedReplayIndex = isReplayConversationEvent(event)
+        ? findCompletedTextMessageIndex(nextMessages, { messageId, isThinking: true })
+        : -1;
+      if (completedReplayIndex >= 0) {
+        nextMessages[completedReplayIndex] = markConversationEventApplied(nextMessages[completedReplayIndex], event);
+        break;
+      }
       const { index } = ensureStreamingTextMessage(nextMessages, { messageId, timestamp, provider, isThinking: true });
       const target = { ...nextMessages[index] };
       target.content = appendDeltaText(target.content || '', payload.text || '');
       target.timestamp = target.timestamp || timestamp;
       target.provider = target.provider || provider;
       target.isThinking = true;
-      nextMessages[index] = target;
+      nextMessages[index] = markConversationEventApplied(target, event);
       break;
     }
 
     case CONVERSATION_EVENT_KINDS.REASONING_END: {
-      const messageId = payload.messageId || event.extensions?.messageId;
+      const messageId = getConversationEventMessageId(event, payload);
       if (!messageId) break;
       const index = findLatestTimelineMessageIndex(nextMessages, (message) => (
         message?.eventMessageId === messageId && !!message.isThinking
       ));
       if (index >= 0) {
-        nextMessages[index] = { ...nextMessages[index], isStreaming: false, isThinking: true };
+        nextMessages[index] = markConversationEventApplied({ ...nextMessages[index], isStreaming: false, isThinking: true }, event);
       }
       break;
     }
@@ -1069,28 +1272,79 @@ export function applyConversationEventToTimelineMessages(messages = [], event, s
       break;
   }
 
+  if (shouldDedupeReplayTextEvent(event)) {
+    return removeDuplicateReplayTextMessages(nextMessages, {
+      isThinking: (
+        event.kind === CONVERSATION_EVENT_KINDS.REASONING_START ||
+        event.kind === CONVERSATION_EVENT_KINDS.REASONING_DELTA ||
+        event.kind === CONVERSATION_EVENT_KINDS.REASONING_END
+      )
+    });
+  }
+
   return nextMessages;
 }
 
+function normalizeConversationTimelineEntries(entries = [], sessionProvider = 'claude') {
+  const normalizedEvents = [];
+  let legacyEntries = [];
+
+  const flushLegacyEntries = () => {
+    if (legacyEntries.length === 0) {
+      return;
+    }
+
+    normalizedEvents.push(...normalizeLegacyHistoryEntries(legacyEntries, sessionProvider));
+    legacyEntries = [];
+  };
+
+  for (const entry of entries) {
+    if (isConversationEvent(entry)) {
+      flushLegacyEntries();
+      normalizedEvents.push(entry);
+    } else {
+      legacyEntries.push(entry);
+    }
+  }
+
+  flushLegacyEntries();
+  return normalizedEvents;
+}
+
 export function conversationEventsToTimelineMessages(events = [], sessionProvider = 'claude') {
   if (!Array.isArray(events)) return [];
-  if (events.length > 0 && !isConversationEvent(events[0])) {
-    return conversationEventsToTimelineMessages(normalizeLegacyHistoryEntries(events, sessionProvider), sessionProvider);
-  }
+  const normalizedEvents = events.every((event) => isConversationEvent(event))
+    ? events
+    : normalizeConversationTimelineEntries(events, sessionProvider);
 
-  return events.reduce(
+  return normalizedEvents.reduce(
     (messages, event) => applyConversationEventToTimelineMessages(messages, event, sessionProvider),
     []
   );
 }
 
+function mergeAcpConfigOptions(previousOptions = [], nextOptions = []) {
+  const mergedByKey = new Map();
+
+  for (const option of normalizeAcpConfigOptions(previousOptions)) {
+    mergedByKey.set(option.key, option);
+  }
+
+  for (const option of normalizeAcpConfigOptions(nextOptions)) {
+    mergedByKey.set(option.key, option);
+  }
+
+  return Array.from(mergedByKey.values());
+}
+
 export function extractAcpSessionMetadataFromConversationEvents(events = []) {
   const metadata = {
     modeState: null,
     availableCommands: [],
     configOptions: [],
     sessionInfo: null,
-    tokenUsage: null
+    tokenUsage: null,
+    capabilitySnapshot: null
   };
 
   for (const event of Array.isArray(events) ? events : []) {
@@ -1117,7 +1371,7 @@ export function extractAcpSessionMetadataFromConversationEvents(events = []) {
     }
 
     if (event.kind === CONVERSATION_EVENT_KINDS.CONFIG_OPTION_UPDATE) {
-      metadata.configOptions = normalizeAcpConfigOptions(event.payload || {});
+      metadata.configOptions = mergeAcpConfigOptions(metadata.configOptions, event.payload || {});
     }
 
     if (event.kind === CONVERSATION_EVENT_KINDS.SESSION_INFO_UPDATE) {
@@ -1138,6 +1392,14 @@ export function extractAcpSessionMetadataFromConversationEvents(events = []) {
     }
   }
 
+  metadata.capabilitySnapshot = buildAcpCapabilities({
+    configOptions: metadata.configOptions,
+    modeState: metadata.modeState,
+    tokenUsage: metadata.tokenUsage,
+    availableCommands: metadata.availableCommands,
+    source: 'history'
+  });
+
   return metadata;
 }
 
@@ -1241,6 +1503,48 @@ export function normalizeRealtimePayloadToConversationEvents(payload, fallbackPr
       );
     }
 
+    const initialAvailableCommands = normalizeAcpAvailableCommands(payload.availableCommands || []);
+    if (initialAvailableCommands.length > 0) {
+      events.push(
+        createConversationEvent({
+          kind: CONVERSATION_EVENT_KINDS.AVAILABLE_COMMANDS_UPDATE,
+          provider,
+          sessionId,
+          timestamp,
+          payload: { availableCommands: initialAvailableCommands },
+          rawRef
+        })
+      );
+    }
+
+    const initialConfigOptions = normalizeAcpConfigOptions(payload.configOptions || []);
+    if (initialConfigOptions.length > 0) {
+      events.push(
+        createConversationEvent({
+          kind: CONVERSATION_EVENT_KINDS.CONFIG_OPTION_UPDATE,
+          provider,
+          sessionId,
+          timestamp,
+          payload: { configOptions: initialConfigOptions },
+          rawRef
+        })
+      );
+    }
+
+    const initialTokenUsage = normalizeAcpTokenUsage(payload.tokenUsage || null);
+    if (initialTokenUsage) {
+      events.push(
+        createConversationEvent({
+          kind: CONVERSATION_EVENT_KINDS.USAGE_UPDATE,
+          provider,
+          sessionId,
+          timestamp,
+          payload: initialTokenUsage,
+          rawRef
+        })
+      );
+    }
+
     return events;
   }