@ellipsis-dev/sdk 0.35.0 → 0.37.0

package/dist/store/index.js

@@ -47,6 +47,42 @@ function claudePayload(record) {
 }
 
 // src/store/codexAppServer.ts
+function codexSubagentThreads(records) {
+  const threads = /* @__PURE__ */ new Set();
+  for (const record of records) addCodexSubagentThreads(threads, record);
+  return threads;
+}
+function addCodexSubagentThreads(threads, record) {
+  if (record.kind !== "codex_app_server") return false;
+  const event = record.payload;
+  if (event.method !== "item/started" && event.method !== "item/completed") {
+    return false;
+  }
+  const item = event.params.item;
+  if (item.type === "subAgentActivity") {
+    threads.add(item.agentThreadId);
+    return true;
+  }
+  if (item.type === "collabAgentToolCall") {
+    for (const thread of item.receiverThreadIds) threads.add(thread);
+    return true;
+  }
+  return false;
+}
+function isCodexSubagentSpawn(record) {
+  if (record.kind !== "codex_app_server") return false;
+  const event = record.payload;
+  if (event.method !== "item/started" && event.method !== "item/completed") {
+    return false;
+  }
+  const item = event.params.item;
+  return item.type === "subAgentActivity" && item.kind === "started";
+}
+function isCodexSubagentRecord(threads, record) {
+  if (record.kind !== "codex_app_server") return false;
+  const params = record.payload.params;
+  return "threadId" in params && typeof params.threadId === "string" && threads.has(params.threadId);
+}
 function codexAppServerContent(event) {
   if (event.method === "turn/completed") {
     return { kind: "end", isError: event.params.turn.status !== "completed" };
@@ -86,6 +122,15 @@ function codexAppServerContent(event) {
         result: item.changes.map((change) => change.diff).join("\n"),
         isError: item.status === "failed" || item.status === "declined"
       };
+    case "subAgentActivity":
+      return {
+        kind: "tool",
+        name: "Agent",
+        input: { agentPath: item.agentPath ?? null, kind: item.kind },
+        summary: item.agentPath ?? item.agentThreadId,
+        result: item.kind,
+        isError: false
+      };
     case "webSearch":
       return {
         kind: "tool",
@@ -101,16 +146,19 @@ function codexAppServerContent(event) {
 }
 
 // src/store/lifecycle.ts
-function environmentOutputStep(payload) {
+function environmentOutputStep(source) {
+  const payload = source;
   if (typeof payload.step === "string" && payload.step) return payload.step;
   return typeof payload.phase === "string" ? payload.phase : "setup";
 }
-function environmentOutputLines(payload) {
+function environmentOutputLines(source) {
+  const payload = source;
   return Array.isArray(payload.lines) ? payload.lines.filter(
     (l) => typeof l === "string" && l.trim().length > 0
   ) : [];
 }
-function environmentOutputLine(payload) {
+function environmentOutputLine(source) {
+  const payload = source;
   const lines = environmentOutputLines(payload);
   return lines.length ? lines[lines.length - 1].trim() : null;
 }
@@ -170,13 +218,16 @@ function environmentPhaseText(payload) {
       return label;
   }
 }
-function turnEndedText(payload) {
+function messageEndedText(source) {
+  const payload = source;
   const status = typeof payload.status === "string" ? payload.status : "";
   if (!status || status === "completed") return null;
-  const detail = typeof payload.detail === "string" ? payload.detail.trim() : "";
-  return detail || `Turn ${status}`;
+  const error = payload.error && typeof payload.error === "object" ? payload.error : {};
+  const detail = typeof error.detail === "string" ? error.detail.trim() : "";
+  return detail || `Message ${status}`;
 }
-function lifecycleText(recordType, payload) {
+function lifecycleText(recordType, source) {
+  const payload = source;
   switch (recordType) {
     case "environment_phase":
       return environmentPhaseText(payload);
@@ -194,12 +245,12 @@ function lifecycleText(recordType, payload) {
       if (duration) parts.push(duration);
       return parts.join(", ");
     }
-    case "turn_queued":
+    case "message_queued":
       return typeof payload.limit === "number" ? `Waiting because ${payload.limit} sessions are already alive on this account` : null;
-    case "turn_ended":
-      return turnEndedText(payload);
+    case "message_ended":
+      return messageEndedText(payload);
     case "session_closed":
-      return "Conversation closed";
+      return "Session closed";
     default:
       return null;
   }
@@ -689,97 +740,74 @@ function geminiStreamContent(event) {
 // src/store/progress.ts
 function messageProgress(records) {
   const messages = /* @__PURE__ */ new Map();
-  const pending = /* @__PURE__ */ new Map();
-  const turns = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Set();
   let ready = false;
-  const getTurn = (id) => {
-    let turn = turns.get(id);
-    if (!turn) {
-      turn = {
-        timing: { id, startedAt: null, completedAt: null },
-        phase: ready ? "working" : "starting",
-        messages: /* @__PURE__ */ new Set()
+  const get = (id) => {
+    let message = messages.get(id);
+    if (!message) {
+      message = {
+        phase: "queued",
+        timing: { startedAt: null, completedAt: null }
       };
-      turns.set(id, turn);
+      messages.set(id, message);
     }
-    return turn;
+    return message;
   };
-  const attach = (messageId, turnId) => {
-    const message = messages.get(messageId);
-    if (!message) return;
-    const turn = getTurn(turnId);
-    if (!turn.messages.has(messageId)) {
-      turn.messages.add(messageId);
-      message.turns.push(turn.timing);
-    }
-    pending.delete(messageId);
-    message.phase = turn.phase;
-  };
-  const setPending = (turnId, phase) => {
-    for (const [id, turn] of pending) {
-      if (turnId == null || turn == null || turn === turnId)
-        messages.get(id).phase = phase;
+  const setPending = (messageId, phase) => {
+    for (const id of pending) {
+      if (messageId == null || messageId === id) get(id).phase = phase;
     }
   };
   for (const record of records) {
+    const recordMessageId = record.message_id ?? null;
     if (record.kind === "platform") {
-      const p = record.payload;
-      const messageId = typeof p.message_id === "string" ? p.message_id : null;
-      const turnId = typeof p.turn_id === "string" ? p.turn_id : record.turn_id;
+      const p = { ...record.payload };
+      const messageId = typeof p.message_id === "string" ? p.message_id : typeof p.id === "string" && record.record_type === "message" ? p.id : recordMessageId;
       switch (record.record_type) {
-        case "message_received":
+        case "message":
           if (messageId && !messages.has(messageId)) {
-            messages.set(messageId, { phase: "queued", turns: [] });
-            if (turnId && turns.has(turnId)) attach(messageId, turnId);
-            else pending.set(messageId, turnId ?? null);
+            get(messageId);
+            pending.add(messageId);
           }
           break;
-        case "message_delivered":
-          if (messageId && turnId) attach(messageId, turnId);
-          break;
         case "message_requeued":
           if (messageId && messages.has(messageId)) {
-            const requeued = typeof p.requeued_turn_id === "string" ? p.requeued_turn_id : null;
-            pending.set(messageId, requeued);
-            messages.get(messageId).phase = "queued";
+            pending.add(messageId);
+            const message = get(messageId);
+            message.phase = "queued";
+            message.timing.startedAt = null;
+            message.timing.completedAt = null;
           }
           break;
         case "environment_phase":
         case "environment_output":
           ready = false;
-          setPending(turnId ?? null, "preparing");
+          setPending(recordMessageId, "preparing");
           break;
         case "environment_ready":
           ready = false;
-          setPending(turnId ?? null, "starting");
+          setPending(recordMessageId, "starting");
           break;
-        case "turn_started":
-          if (turnId) {
-            getTurn(turnId).timing.startedAt = record.created_at;
-            for (const [id, turn] of pending) {
-              if (turn === turnId) attach(id, turnId);
-            }
+        case "message_started":
+          if (messageId) {
+            const message = get(messageId);
+            message.timing.startedAt = record.created_at;
+            message.phase = ready ? "working" : "starting";
+            pending.delete(messageId);
           }
           break;
-        case "turn_ended":
-          if (turnId) {
-            const turn = getTurn(turnId);
-            turn.timing.completedAt = record.created_at;
-            turn.phase = null;
-            for (const id of turn.messages) {
-              if (!pending.has(id)) messages.get(id).phase = null;
-            }
-            for (const [id, pendingTurn] of pending) {
-              if (pendingTurn === turnId) {
-                pending.delete(id);
-                messages.get(id).phase = null;
-              }
-            }
+        case "message_ended":
+          if (messageId) {
+            const message = get(messageId);
+            message.timing.completedAt = record.created_at;
+            message.phase = null;
+            pending.delete(messageId);
           }
           break;
         case "session_closed":
           ready = false;
-          for (const id of pending.keys()) messages.get(id).phase = null;
+          for (const id of pending) get(id).phase = null;
+          pending.clear();
           break;
       }
       continue;
@@ -788,18 +816,15 @@ function messageProgress(records) {
     const agentStarted = record.kind === "codex_app_server" && record.payload.method === "turn/started" || record.kind === "codex" && record.payload.type === "turn.started" || record.kind === "gemini" && record.payload.type === "init" || claude != null && (claude.kind === "assistant" || claude.kind === "user" || claude.kind === "system" && claude.subtype === "init");
     if (agentStarted) {
       ready = true;
-      if (record.turn_id) {
-        const turn = getTurn(record.turn_id);
-        if (turn.timing.completedAt == null) {
-          turn.timing.startedAt ??= record.created_at;
-          turn.phase = "working";
-          for (const id of turn.messages) messages.get(id).phase = "working";
+      if (recordMessageId) {
+        const message = get(recordMessageId);
+        if (message.timing.completedAt == null) {
+          message.timing.startedAt ??= record.created_at;
+          message.phase = "working";
+          pending.delete(recordMessageId);
         }
       }
     }
-    if (record.session_message_id && record.turn_id) {
-      attach(record.session_message_id, record.turn_id);
-    }
   }
   return messages;
 }
@@ -815,10 +840,9 @@ function groupRecordsToChatTurns(records, session) {
   const turns = [];
   const toolNodeByUseId = /* @__PURE__ */ new Map();
   const openGeminiTools = /* @__PURE__ */ new Map();
+  const codexSubagentThreads2 = /* @__PURE__ */ new Set();
   const userTurnByMessageId = /* @__PURE__ */ new Map();
-  const turnByMessageId = /* @__PURE__ */ new Map();
-  const unansweredTurnIds = /* @__PURE__ */ new Set();
-  const activeMessageByTurnId = /* @__PURE__ */ new Map();
+  const unansweredMessageIds = /* @__PURE__ */ new Set();
   let lastDeliveredMessageId;
   let seq = 0;
   const nextKey = (base) => `${base}:${seq++}`;
@@ -826,15 +850,14 @@ function groupRecordsToChatTurns(records, session) {
   let initCount = 0;
   let pendingResume = false;
   const openSessionTurn = (record) => {
-    const messageId = (record.turn_id ? activeMessageByTurnId.get(record.turn_id) : void 0) ?? lastDeliveredMessageId;
-    if (openIdx >= 0 && (turns[openIdx].turnId !== (record.turn_id ?? void 0) || turns[openIdx].messageId !== messageId)) {
+    const messageId = record.message_id ?? lastDeliveredMessageId;
+    if (openIdx >= 0 && turns[openIdx].messageId !== messageId) {
       openIdx = -1;
     }
     if (openIdx < 0) {
       turns.push({
         key: nextKey(record.id),
         messageId,
-        turnId: record.turn_id ?? void 0,
         role: "assistant",
         nodes: [],
         startedAt: record.created_at,
@@ -850,13 +873,26 @@ function groupRecordsToChatTurns(records, session) {
     }
     return turns[openIdx];
   };
+  const subagentTurn = (record) => {
+    for (let i = turns.length - 1; i >= 0; i--) {
+      const turn = turns[i];
+      if (turn.role === "assistant" && turn.messageId === (record.message_id ?? void 0))
+        return turn;
+    }
+    return null;
+  };
+  const newestAssistantTurn = () => {
+    for (let i = turns.length - 1; i >= 0; i--) {
+      if (turns[i].role === "assistant") return turns[i];
+    }
+    return null;
+  };
   for (const record of records) {
     if (record.kind === "platform") {
-      const messageId = typeof record.payload.message_id === "string" ? record.payload.message_id : null;
-      if (record.record_type === "message_received" && messageId) {
-        if (typeof record.payload.turn_id === "string")
-          turnByMessageId.set(messageId, record.payload.turn_id);
-        const body = typeof record.payload.body === "string" ? record.payload.body : "";
+      const payload = { ...record.payload };
+      const messageId = typeof payload.message_id === "string" ? payload.message_id : record.record_type === "message" && typeof payload.id === "string" ? payload.id : null;
+      if (record.record_type === "message" && messageId) {
+        const body = typeof payload.body === "string" ? payload.body : "";
         if (!body.trim() || userTurnByMessageId.has(messageId)) continue;
         const turn2 = {
           resumed: false,
@@ -875,29 +911,23 @@ function groupRecordsToChatTurns(records, session) {
         turns.push(turn2);
         continue;
       }
-      if (record.record_type === "message_delivered" && messageId) {
-        if (typeof record.payload.turn_id === "string") {
-          turnByMessageId.set(messageId, record.payload.turn_id);
-          activeMessageByTurnId.set(record.payload.turn_id, messageId);
-          lastDeliveredMessageId = messageId;
-        }
+      if (record.record_type === "message_started" && messageId) {
+        lastDeliveredMessageId = messageId;
         continue;
       }
       if (record.record_type === "message_requeued" && messageId) {
-        if (typeof record.payload.requeued_turn_id === "string")
-          turnByMessageId.set(messageId, record.payload.requeued_turn_id);
-        else turnByMessageId.delete(messageId);
+        unansweredMessageIds.delete(messageId);
         continue;
       }
-      if (record.record_type === "turn_ended" && typeof record.payload.turn_id === "string" && record.payload.status !== "completed")
-        unansweredTurnIds.add(record.payload.turn_id);
-      const text2 = lifecycleText(record.record_type, record.payload);
+      if (record.record_type === "message_ended" && messageId && payload.status !== "completed")
+        unansweredMessageIds.add(messageId);
+      const text2 = lifecycleText(record.record_type, payload);
       if (!text2) continue;
       const isEnvironment = ENVIRONMENT_RECORD_TYPES.has(record.record_type);
       const isOutput = record.record_type === "environment_output";
-      const step = isOutput ? environmentOutputStep(record.payload) : void 0;
-      const lines = isOutput ? environmentOutputLines(record.payload) : void 0;
-      const turnId = record.turn_id ?? void 0;
+      const step = isOutput ? environmentOutputStep(payload) : void 0;
+      const lines = isOutput ? environmentOutputLines(payload) : void 0;
+      const messageKey = record.message_id ?? void 0;
       let foldTarget = null;
       if (isEnvironment) {
         for (let i = turns.length - 1; i >= 0; i--) {
@@ -906,7 +936,7 @@ function groupRecordsToChatTurns(records, session) {
           if (candidate.nodes.some(
             (n) => n.kind === "lifecycle" && ENVIRONMENT_RECORD_TYPES.has(n.recordType)
           )) {
-            if (candidate.turnId === turnId) foldTarget = candidate;
+            if (candidate.messageId === messageKey) foldTarget = candidate;
             break;
           }
         }
@@ -924,7 +954,7 @@ function groupRecordsToChatTurns(records, session) {
             recordType: record.record_type,
             step,
             lines,
-            payload: record.payload
+            payload
           });
         }
         foldTarget.completedAt = record.created_at;
@@ -932,7 +962,7 @@ function groupRecordsToChatTurns(records, session) {
       }
       turns.push({
         key: nextKey(record.id),
-        turnId,
+        messageId: messageKey,
         role: "lifecycle",
         nodes: [
           {
@@ -942,7 +972,7 @@ function groupRecordsToChatTurns(records, session) {
             recordType: record.record_type,
             step,
             lines,
-            payload: record.payload
+            payload
           }
         ],
         startedAt: record.created_at,
@@ -955,11 +985,7 @@ function groupRecordsToChatTurns(records, session) {
       });
       continue;
     }
-    if (record.session_message_id) {
-      lastDeliveredMessageId = record.session_message_id;
-      if (record.turn_id)
-        activeMessageByTurnId.set(record.turn_id, record.session_message_id);
-    }
+    if (record.message_id) lastDeliveredMessageId = record.message_id;
     if (record.kind === "codex") {
       codexEventIntoTurns(record, record.payload, {
         openSessionTurn,
@@ -1018,16 +1044,31 @@ function groupRecordsToChatTurns(records, session) {
       continue;
     }
     if (record.kind === "codex_app_server") {
+      const fromSubagent = isCodexSubagentRecord(codexSubagentThreads2, record);
+      const announces = addCodexSubagentThreads(codexSubagentThreads2, record);
       const content = codexAppServerContent(record.payload);
       if (!content) continue;
+      const late = fromSubagent || announces && !isCodexSubagentSpawn(record);
+      const turnFor = () => {
+        if (!late) return openSessionTurn(record);
+        const open = openIdx >= 0 ? turns[openIdx] : null;
+        if (open !== null && open.messageId === (record.message_id ?? void 0)) {
+          return open;
+        }
+        if (record.message_id == null) {
+          return open ?? newestAssistantTurn() ?? openSessionTurn(record);
+        }
+        return subagentTurn(record) ?? openSessionTurn(record);
+      };
       if (content.kind === "end") {
+        if (fromSubagent) continue;
         if (openIdx >= 0) {
           turns[openIdx].completedAt = record.created_at;
           if (content.isError) turns[openIdx].isError = true;
           openIdx = -1;
         }
       } else if (content.kind === "tool") {
-        openSessionTurn(record).nodes.push({
+        turnFor().nodes.push({
           key: nextKey(record.id),
           kind: "tool",
           name: content.name,
@@ -1039,8 +1080,8 @@ function groupRecordsToChatTurns(records, session) {
           completedAt: record.created_at
         });
       } else if (content.text.trim()) {
-        const turn2 = openSessionTurn(record);
-        if (content.kind === "error") turn2.isError = true;
+        const turn2 = turnFor();
+        if (content.kind === "error" && !fromSubagent) turn2.isError = true;
         turn2.nodes.push({
           key: nextKey(record.id),
           kind: content.kind === "error" ? "assistant" : content.kind,
@@ -1077,7 +1118,7 @@ function groupRecordsToChatTurns(records, session) {
       if (typeof content === "string") {
         if (content.trim()) {
           openIdx = -1;
-          if (record.session_message_id != null && userTurnByMessageId.has(record.session_message_id))
+          if (record.message_id != null && userTurnByMessageId.has(record.message_id))
             continue;
           turns.push({
             resumed: false,
@@ -1162,27 +1203,19 @@ function groupRecordsToChatTurns(records, session) {
       }
     }
   }
-  for (const [messageId, turnId] of turnByMessageId) {
-    const turn = userTurnByMessageId.get(messageId);
-    if (turn) turn.isError = unansweredTurnIds.has(turnId);
+  for (const [messageId, turn] of userTurnByMessageId) {
+    turn.isError = unansweredMessageIds.has(messageId);
   }
   for (const [messageId, progress] of messageProgress(records)) {
     const turn = userTurnByMessageId.get(messageId);
     if (turn) turn.progress = progress;
   }
-  const initialTurn = records.find(
-    (r) => r.kind === "platform" && r.record_type === "turn_started" && r.payload.turn_index === 0
-  );
-  const openingTurnId = initialTurn?.turn_id ?? initialTurn?.payload.turn_id ?? (session?.turn?.index === 0 ? session.turn.id : void 0);
-  const initialReceived = openingTurnId == null ? void 0 : records.find(
-    (r) => r.kind === "platform" && r.record_type === "message_received" && (r.turn_id === openingTurnId || r.payload.turn_id === openingTurnId)
+  const initialMessage = records.find(
+    (r) => r.kind === "platform" && r.record_type === "message" && r.payload.index === 0
   );
-  const initialDelivery = openingTurnId == null ? void 0 : records.find(
-    (r) => r.kind === "platform" && r.record_type === "message_delivered" && r.payload.turn_id === openingTurnId
-  );
-  const initialId = (initialReceived ?? initialDelivery)?.payload.message_id;
+  const initialId = initialMessage?.payload.id;
   const opening = initialId ? userTurnByMessageId.get(initialId) : void 0;
-  const includesStart = records.length === 0 || initialTurn != null;
+  const includesStart = records.length === 0 || initialMessage != null;
   const prompt = (session?.claude_code ?? session?.codex)?.prompt;
   if (prompt?.trim() && session && (opening || includesStart)) {
     const first = opening ?? {
@@ -1196,7 +1229,10 @@ function groupRecordsToChatTurns(records, session) {
       tokens: null,
       resumed: false,
       isError: false,
-      progress: { phase: "preparing", turns: [] }
+      progress: {
+        phase: "preparing",
+        timing: { startedAt: null, completedAt: null }
+      }
     };
     if (opening) turns.splice(turns.indexOf(opening), 1);
     first.key = "prompt";
@@ -1204,7 +1240,7 @@ function groupRecordsToChatTurns(records, session) {
     turns.unshift(first);
     if (!opening) {
       for (const turn of turns) {
-        if (turn !== first && turn.role === "user" && turn.progress && !turn.progress.turns.length) {
+        if (turn !== first && turn.role === "user" && turn.progress && turn.progress.timing.startedAt == null) {
           turn.progress.phase = turn.progress.phase === null ? null : "queued";
         }
       }
@@ -1318,9 +1354,9 @@ function codexEventIntoTurns(record, event, ops) {
 function recordSlice(records) {
   return records;
 }
-function turnOf(record) {
-  if (record.turn_id != null) return record.turn_id;
-  return typeof record.payload.turn_id === "string" ? record.payload.turn_id : null;
+function messageOf(record) {
+  if (record.message_id != null) return record.message_id;
+  return typeof record.payload.message_id === "string" ? record.payload.message_id : null;
 }
 function humanDuration(seconds) {
   const clamped = Math.max(0, seconds);
@@ -1342,10 +1378,10 @@ function humanDuration(seconds) {
 }
 function sessionLogText(recordType, payload) {
   switch (recordType) {
-    case "turn_ended":
-      return turnEndedText(payload);
+    case "message_ended":
+      return messageEndedText(payload);
     case "session_closed":
-      return "Conversation closed";
+      return "Session closed";
     default:
       return null;
   }
@@ -1359,10 +1395,10 @@ function awaitingAgentPhase(records) {
       continue;
     }
     switch (r.record_type) {
-      case "turn_started":
+      case "message_started":
         inFlight = true;
         break;
-      case "turn_ended":
+      case "message_ended":
         inFlight = false;
         break;
       case "environment_phase":
@@ -1377,37 +1413,34 @@ function awaitingAgentPhase(records) {
 }
 function deliveredUnechoedSends(records) {
   const received = /* @__PURE__ */ new Map();
-  const delivered = /* @__PURE__ */ new Map();
+  const started = /* @__PURE__ */ new Set();
   const unanswered = /* @__PURE__ */ new Set();
   const echoed = /* @__PURE__ */ new Set();
   for (const r of records) {
-    if (r.session_message_id != null) echoed.add(r.session_message_id);
-    if (r.source !== "lifecycle") continue;
-    if (r.record_type === "turn_ended") {
-      if (typeof r.payload.turn_id === "string" && r.payload.status !== "completed")
-        unanswered.add(r.payload.turn_id);
+    if (r.source !== "lifecycle") {
+      if (r.message_id != null) echoed.add(r.message_id);
       continue;
     }
-    const id = typeof r.payload.message_id === "string" ? r.payload.message_id : null;
+    const id = messageOf(r) ?? (typeof r.payload.id === "string" ? r.payload.id : null);
     if (!id) continue;
-    if (r.record_type === "message_received") {
+    if (r.record_type === "message") {
       if (!received.has(id))
         received.set(
           id,
           typeof r.payload.body === "string" ? r.payload.body : ""
         );
-    } else if (r.record_type === "message_delivered") {
-      delivered.set(
-        id,
-        typeof r.payload.turn_id === "string" ? r.payload.turn_id : ""
-      );
-    } else if (r.record_type === "message_requeued") delivered.delete(id);
+    } else if (r.record_type === "message_started") {
+      started.add(id);
+    } else if (r.record_type === "message_requeued") {
+      started.delete(id);
+    } else if (r.record_type === "message_ended") {
+      if (r.payload.status !== "completed") unanswered.add(id);
+    }
   }
   const out = [];
   for (const [id, body] of received) {
-    const turnId = delivered.get(id);
-    if (turnId === void 0 || echoed.has(id)) continue;
-    out.push({ id, body, cancelled: unanswered.has(turnId) });
+    if (!started.has(id) || echoed.has(id)) continue;
+    out.push({ id, body, cancelled: unanswered.has(id) });
   }
   return out;
 }
@@ -1457,22 +1490,22 @@ function deriveEnvironmentState(records, minFeedSeq) {
   let readySeconds = null;
   let log = [];
   let open = /* @__PURE__ */ new Map();
-  let storyTurn = null;
+  let storyMessage = null;
   const push = (record, kind, text2) => {
     const entry = { key: `${record.feed_seq}:${log.length}`, kind, text: text2 };
     log.push(entry);
     return entry;
   };
   const begin = (record) => {
-    const turn = turnOf(record);
-    if (seen && turn !== storyTurn) {
+    const message = messageOf(record);
+    if (seen && message !== storyMessage) {
       log = [];
       open = /* @__PURE__ */ new Map();
       done = false;
       readySeconds = null;
     }
     seen = true;
-    storyTurn = turn;
+    storyMessage = message;
   };
   for (const record of records) {
     if (record.feed_seq <= minFeedSeq || record.source !== "lifecycle")
@@ -1528,9 +1561,9 @@ function deriveEnvironmentState(records, minFeedSeq) {
         done = true;
         break;
       }
-      case "turn_started":
-      case "turn_ended":
-        if (seen && turnOf(record) === storyTurn) done = true;
+      case "message_started":
+      case "message_ended":
+        if (seen && messageOf(record) === storyMessage) done = true;
         break;
       case "session_closed":
         if (seen) done = true;
@@ -1730,12 +1763,10 @@ function splitLedger(turns) {
   return { preamble, entries };
 }
 function entrySeconds(entry, now) {
-  if (entry.progress?.turns.length) {
-    return entry.progress.turns.reduce((ms2, turn) => {
-      if (turn.startedAt == null) return ms2;
-      const end = turn.completedAt == null ? now : Date.parse(turn.completedAt);
-      return ms2 + Math.max(0, end - Date.parse(turn.startedAt));
-    }, 0) / 1e3;
+  const timing = entry.progress?.timing;
+  if (timing?.startedAt != null) {
+    const end = timing.completedAt == null ? now : Date.parse(timing.completedAt);
+    return Math.max(0, end - Date.parse(timing.startedAt)) / 1e3;
   }
   let ms = 0;
   for (const turn of entry.turns) {
@@ -1811,7 +1842,7 @@ function entryBody(entry, {
   const items = [];
   const work = [];
   const phase = entry.progress?.phase;
-  const seconds = entry.progress && !entry.progress.turns.some((turn) => turn.startedAt != null) ? null : entrySeconds(entry, now);
+  const seconds = entry.progress && entry.progress.timing.startedAt == null ? null : entrySeconds(entry, now);
   const key = `work:${entry.key}`;
   const header = {
     key,
@@ -1981,25 +2012,17 @@ function activitySummary(activities) {
 
 // src/store/index.ts
 function isConversationOver(session) {
-  return session.conversation.state === "closed";
+  return session.status === "closed";
 }
 function seedTranscriptStore(store, seed) {
-  store.ingest({
-    type: "snapshot",
-    earliest_feed_seq: seed.earliestFeedSeq ?? null,
-    session: seed.session,
-    messages: [...seed.messages ?? []]
-  });
+  store.ingest({ type: "session", session: seed.session });
   const ordered = [...seed.records].sort((a, b) => a.feed_seq - b.feed_seq);
-  if (ordered.length)
-    store.ingest({ type: "records_append", records: ordered });
+  if (ordered.length) store.ingest({ type: "records", records: ordered });
 }
 var EMPTY_SNAPSHOT = {
   session: null,
   records: [],
-  messages: [],
   acknowledgedMessageIds: /* @__PURE__ */ new Set(),
-  historyTruncated: false,
   liveText: "",
   liveSummary: "",
   liveOutputTokens: null,
@@ -2013,21 +2036,16 @@ var SessionTranscriptStore = class {
   snapshot = EMPTY_SNAPSHOT;
   listeners = /* @__PURE__ */ new Set();
   acknowledged = /* @__PURE__ */ new Set();
-  // The inbox projection: message_received/delivered/requeued
-  // RECORDS drive it; the snapshot seeds the pending set at connect. Keyed by
-  // message id so a requeue can restore a message the delivered record
-  // removed from the pending view.
-  inbox = /* @__PURE__ */ new Map();
-  // The resume cursor: the highest feed_seq received via records_append. Only
-  // records advance it — never messages/session frames. streamSession
-  // tracks its own copy; this one seeds a NEW streamSession call (e.g. a
-  // page-level reconnect after unmount) from already-held state.
+  // The resume cursor: the highest feed_seq received via records frames. Only
+  // records advance it — never session frames. streamSession tracks its own
+  // copy; this one seeds a NEW streamSession call (e.g. a page-level
+  // reconnect after unmount) from already-held state.
   cursorSeq = 0;
   // Derived-turn cache, keyed on the records array identity.
   turnsFor = null;
   turnsSession = null;
   turnsCache = [];
-  summaryTurnId = null;
+  summaryMessageId = null;
   get cursor() {
     return this.cursorSeq;
   }
@@ -2049,59 +2067,6 @@ var SessionTranscriptStore = class {
     }
     return this.turnsCache;
   };
-  // The current pending set, in feed order — what queued chips render.
-  pendingMessages = () => [...this.inbox.values()].filter((m) => m.status === "pending").sort((a, b) => (a.feed_seq ?? 0) - (b.feed_seq ?? 0));
-  // Fold one lifecycle record into the inbox projection; returns whether the
-  // pending view changed. Unknown fields/types are ignored.
-  applyMessageRecord = (record) => {
-    if (record.kind !== "platform") return false;
-    const payload = record.payload;
-    const messageId = typeof payload.message_id === "string" ? payload.message_id : null;
-    switch (record.record_type) {
-      case "message_received": {
-        if (messageId == null || this.inbox.has(messageId)) return false;
-        this.inbox.set(messageId, {
-          id: messageId,
-          session_id: record.session_id,
-          feed_seq: record.feed_seq,
-          status: "pending",
-          body: typeof payload.body === "string" ? payload.body : "",
-          author: typeof payload.author === "string" ? payload.author : null,
-          sender_attribution_type: typeof payload.sender_attribution_type === "string" ? payload.sender_attribution_type : null,
-          sender_attribution_id: typeof payload.sender_attribution_id === "string" ? payload.sender_attribution_id : null,
-          created_at: record.created_at,
-          delivered_at: null,
-          images: [],
-          turn_id: typeof payload.turn_id === "string" ? payload.turn_id : null
-        });
-        return true;
-      }
-      case "message_delivered": {
-        const existing = messageId != null ? this.inbox.get(messageId) : null;
-        if (!existing || existing.status !== "pending") return false;
-        this.inbox.set(messageId, {
-          ...existing,
-          status: "delivered",
-          delivered_at: record.created_at,
-          turn_id: typeof payload.turn_id === "string" ? payload.turn_id : existing.turn_id
-        });
-        return true;
-      }
-      case "message_requeued": {
-        const existing = messageId != null ? this.inbox.get(messageId) : null;
-        if (!existing || existing.status === "pending") return false;
-        this.inbox.set(messageId, {
-          ...existing,
-          status: "pending",
-          delivered_at: null,
-          turn_id: typeof payload.requeued_turn_id === "string" ? payload.requeued_turn_id : null
-        });
-        return true;
-      }
-      default:
-        return false;
-    }
-  };
   // Ingest one frame from the stream client. Unknown frame types stamp
   // liveness and change nothing else.
   ingest = (rawFrame) => {
@@ -2112,45 +2077,29 @@ var SessionTranscriptStore = class {
     };
     const frame = rawFrame;
     switch (frame.type) {
-      case "snapshot": {
-        next.liveSummary = "";
-        next.session = frame.session;
-        for (const message of frame.messages) {
-          this.inbox.set(message.id, message);
-          this.acknowledged.add(message.id);
-        }
-        next.messages = this.pendingMessages();
-        next.acknowledgedMessageIds = new Set(this.acknowledged);
-        next.conversationOver = isConversationOver(frame.session);
-        next.historyTruncated = frame.earliest_feed_seq != null && this.cursorSeq < frame.earliest_feed_seq - 1;
-        break;
-      }
-      case "records_append": {
+      case "records": {
         const fresh = frame.records.filter((r) => r.feed_seq > this.cursorSeq);
         if (fresh.length === 0) break;
         this.cursorSeq = fresh[fresh.length - 1].feed_seq;
         next.records = [...prev.records, ...fresh];
         let acknowledgedNew = false;
-        let inboxChanged = false;
         for (const record of fresh) {
-          if (record.session_message_id != null) {
-            this.acknowledged.add(record.session_message_id);
+          if (record.message_id != null) {
+            this.acknowledged.add(record.message_id);
             acknowledgedNew = true;
           }
           if (record.source === "lifecycle") {
-            if (record.record_type === "turn_started" && record.turn_id !== this.summaryTurnId || record.record_type === "turn_ended" && record.turn_id === this.summaryTurnId)
+            if (record.record_type === "message_started" && record.message_id !== this.summaryMessageId || record.record_type === "message_ended" && record.message_id === this.summaryMessageId)
               next.liveSummary = "";
-            inboxChanged = this.applyMessageRecord(record) || inboxChanged;
-            if (record.record_type === "message_received" || record.record_type === "message_delivered") {
+            if (record.record_type === "message") {
               const payload = record.payload;
-              if (typeof payload.message_id === "string") {
-                this.acknowledged.add(payload.message_id);
+              if (typeof payload.id === "string") {
+                this.acknowledged.add(payload.id);
                 acknowledgedNew = true;
               }
             }
           }
         }
-        if (inboxChanged) next.messages = this.pendingMessages();
         if (acknowledgedNew) {
           next.acknowledgedMessageIds = new Set(this.acknowledged);
         }
@@ -2161,15 +2110,13 @@ var SessionTranscriptStore = class {
       case "session": {
         next.session = frame.session;
         next.conversationOver = isConversationOver(frame.session);
-        if (next.conversationOver || frame.session.turn?.status !== "running") {
-          next.liveSummary = "";
-        }
+        if (frame.session.status !== "running") next.liveSummary = "";
         break;
       }
       case "delta": {
         if (frame.kind === "thinking") {
           if (next.conversationOver) break;
-          this.summaryTurnId = frame.turn_id;
+          this.summaryMessageId = frame.message_id;
           if (frame.text != null) next.liveSummary = frame.text;
           break;
         }
@@ -2182,11 +2129,6 @@ var SessionTranscriptStore = class {
           next.liveOutputTokens = frame.output_tokens;
         break;
       }
-      case "done": {
-        next.conversationOver = true;
-        next.liveSummary = "";
-        break;
-      }
       case "error": {
         next.liveSummary = "";
         break;
@@ -2212,6 +2154,7 @@ export {
   codexChangedPaths,
   codexEventToItems,
   codexMcpToolName,
+  codexSubagentThreads,
   collapseToolRuns,
   deliveredUnechoedSends,
   deriveEnvironmentState,
@@ -2232,6 +2175,7 @@ export {
   gutterFor,
   hookPhrase,
   humanDuration,
+  isCodexSubagentRecord,
   isConnectVisibleRecord,
   isConversationOver,
   isFoldable,
@@ -2241,6 +2185,7 @@ export {
   lastLines,
   layOutItems,
   lifecycleText,
+  messageEndedText,
   oneLine,
   pendingToolCalls,
   reasoningSummaryTitle,
@@ -2257,6 +2202,5 @@ export {
   tailLines,
   toolActivities,
   toolResultText,
-  toolRunMembers,
-  turnEndedText
+  toolRunMembers
 };