@ellipsis-dev/sdk 0.28.0 → 0.31.0

package/dist/store/index.js

@@ -1,6 +1,6 @@
 import {
   SESSION_STREAM_PROTOCOL_VERSION
-} from "../chunk-YJC53TA7.js";
+} from "../chunk-G2AEYZW2.js";
 
 // src/store/claude.ts
 function claudePayload(record) {
@@ -62,8 +62,9 @@ function codexAppServerContent(event) {
   const item = event.params.item;
   switch (item.type) {
     case "agentMessage":
+      return { kind: "assistant", text: item.text, phase: item.phase };
     case "plan":
-      return { kind: "assistant", text: item.text };
+      return { kind: "assistant", text: item.text, phase: "commentary" };
     case "reasoning":
       return {
         kind: "thinking",
@@ -75,7 +76,7 @@ function codexAppServerContent(event) {
       return {
         kind: "tool",
         name: "Bash",
-        input: { command: item.command },
+        input: { command: item.command, commandActions: item.commandActions },
         summary: item.command,
         result: item.aggregatedOutput?.trim() || "(no output)",
         isError: item.status === "failed" || item.status === "declined" || typeof item.exitCode === "number" && item.exitCode !== 0
@@ -103,18 +104,136 @@ function codexAppServerContent(event) {
   }
 }
 
+// src/store/progress.ts
+function messageProgress(records) {
+  const messages = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  const turns = /* @__PURE__ */ new Map();
+  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()
+      };
+      turns.set(id, turn);
+    }
+    return turn;
+  };
+  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;
+    }
+  };
+  for (const record of records) {
+    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;
+      switch (record.record_type) {
+        case "message_received":
+          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);
+          }
+          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";
+          }
+          break;
+        case "environment_phase":
+        case "environment_output":
+          ready = false;
+          setPending(turnId ?? null, "preparing");
+          break;
+        case "environment_ready":
+          ready = false;
+          setPending(turnId ?? null, "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);
+            }
+          }
+          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;
+              }
+            }
+          }
+          break;
+        case "session_closed":
+          ready = false;
+          for (const id of pending.keys()) messages.get(id).phase = null;
+          break;
+      }
+      continue;
+    }
+    const claude = claudePayload(record);
+    const agentStarted = record.kind === "codex_app_server" && record.payload.method === "turn/started" || record.kind === "codex" && record.payload.type === "turn.started" || 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 (record.session_message_id && record.turn_id) {
+      attach(record.session_message_id, record.turn_id);
+    }
+  }
+  return messages;
+}
+
 // src/store/lifecycle.ts
-function sandboxOutputStep(payload) {
+function environmentOutputStep(payload) {
   if (typeof payload.step === "string" && payload.step) return payload.step;
   return typeof payload.phase === "string" ? payload.phase : "setup";
 }
-function sandboxOutputLines(payload) {
+function environmentOutputLines(payload) {
   return Array.isArray(payload.lines) ? payload.lines.filter(
     (l) => typeof l === "string" && l.trim().length > 0
   ) : [];
 }
-function sandboxOutputLine(payload) {
-  const lines = sandboxOutputLines(payload);
+function environmentOutputLine(payload) {
+  const lines = environmentOutputLines(payload);
   return lines.length ? lines[lines.length - 1].trim() : null;
 }
 function cacheTierLabel(tier) {
@@ -129,7 +248,7 @@ function cacheTierLabel(tier) {
       return null;
   }
 }
-function sandboxPhaseLabel(phase) {
+function environmentPhaseLabel(phase) {
   switch (phase) {
     case "image":
       return "Preparing image";
@@ -151,8 +270,8 @@ function durationLabel(ms) {
   if (typeof ms !== "number" || !isFinite(ms) || ms < 0) return null;
   return ms >= 1e3 ? `${(ms / 1e3).toFixed(1)}s` : `${Math.round(ms)}ms`;
 }
-function sandboxPhaseText(payload) {
-  const label = sandboxPhaseLabel(payload.phase);
+function environmentPhaseText(payload) {
+  const label = environmentPhaseLabel(payload.phase);
   const detail = payload.detail && typeof payload.detail === "object" ? payload.detail : {};
   switch (payload.status) {
     case "started":
@@ -173,56 +292,42 @@ function sandboxPhaseText(payload) {
       return label;
   }
 }
+function turnEndedText(payload) {
+  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}`;
+}
 function lifecycleText(recordType, payload) {
   switch (recordType) {
-    case "session_scheduled": {
-      const config = typeof payload.config_name === "string" ? payload.config_name : null;
-      return config ? `Session scheduled, ${config}` : "Session scheduled";
-    }
-    case "session_starting": {
-      const attempt = typeof payload.attempt === "number" ? payload.attempt : 0;
-      if (attempt > 0) return "Retrying\u2026";
-      const wakeIndex = typeof payload.wake_index === "number" ? payload.wake_index : 0;
-      return wakeIndex > 0 ? "Waking the session\u2026" : "Session starting\u2026";
+    case "environment_phase":
+      return environmentPhaseText(payload);
+    case "environment_output": {
+      const last = environmentOutputLine(payload);
+      return last ? `${environmentOutputStep(payload)}, ${last}` : null;
     }
-    case "session_retrying":
-      return typeof payload.reason === "string" && payload.reason ? `Retrying, ${payload.reason}` : "Retrying after a transient error\u2026";
-    case "sandbox_starting":
-      return "Starting sandbox\u2026";
-    case "sandbox_phase":
-      return sandboxPhaseText(payload);
-    case "sandbox_output": {
-      const last = sandboxOutputLine(payload);
-      return last ? `${sandboxOutputStep(payload)}, ${last}` : null;
-    }
-    case "sandbox_ready": {
+    case "environment_ready": {
       const repos = Array.isArray(payload.repositories) ? payload.repositories.filter(
         (r) => typeof r === "string"
       ) : [];
-      const parts = ["Sandbox ready"];
+      const parts = ["Environment ready"];
       if (repos.length) parts.push(repos.join(", "));
-      const tier = cacheTierLabel(payload.cache_tier);
-      if (tier) parts.push(tier);
+      const duration = durationLabel(payload.duration_ms);
+      if (duration) parts.push(duration);
       return parts.join(", ");
     }
-    case "session_resumed":
-      return "Resumed the conversation";
-    case "session_idle":
-      return "Idle \u2014 your next message wakes it";
+    case "turn_ended":
+      return turnEndedText(payload);
     case "session_closed":
       return "Conversation closed";
-    case "session_cancelled": {
-      const reason = typeof payload.reason === "string" ? payload.reason : null;
-      return reason ? `Session cancelled, ${reason}` : "Session cancelled";
-    }
     default:
       return null;
   }
 }
 
 // src/store/transcript.ts
-function oneLine(text, max) {
-  const collapsed = text.replace(/\s+/g, " ").trim();
+function oneLine(text2, max) {
+  const collapsed = text2.replace(/\s+/g, " ").trim();
   return collapsed.length <= max ? collapsed : `${collapsed.slice(0, max - 3)}...`;
 }
 function summarizeToolInput(name, input) {
@@ -377,15 +482,15 @@ function codexEventToItems(event, keyBase) {
   const item = event.item;
   switch (item.type) {
     case "agent_message": {
-      const text = (item.text ?? "").trim();
-      if (text) push({ kind: "assistant", text, spaceBefore: true });
+      const text2 = (item.text ?? "").trim();
+      if (text2) push({ kind: "assistant", text: text2, spaceBefore: true });
       break;
     }
     case "reasoning": {
       const r = item;
-      const text = (r.text ?? r.summary ?? "").trim();
-      if (text)
-        push({ kind: "thinking", gutter: "\u273B", text, spaceBefore: true });
+      const text2 = (r.text ?? r.summary ?? "").trim();
+      if (text2)
+        push({ kind: "thinking", gutter: "\u273B", text: text2, spaceBefore: true });
       break;
     }
     case "command_execution": {
@@ -517,15 +622,15 @@ function recordToItems(record, keyBase, options = {}) {
       ] : [];
     }
     case "platform": {
-      const text = lifecycleText(record.record_type, record.payload);
-      return text ? [{ key: keyBase, kind: "notice", text, spaceBefore: true }] : [];
+      const text2 = lifecycleText(record.record_type, record.payload);
+      return text2 ? [{ key: keyBase, kind: "notice", text: text2, spaceBefore: true }] : [];
     }
     default:
       return [];
   }
 }
 function isConnectVisibleRecord(record) {
-  return record.source !== "lifecycle" || record.record_type === "sandbox_ready";
+  return record.source !== "lifecycle" || record.record_type === "environment_ready";
 }
 function pendingToolCalls(items) {
   let pending = [];
@@ -589,9 +694,9 @@ function collapseToolRuns(items, { working = false } = {}) {
   flush(true);
   return out;
 }
-function clampLines(text, maxLines) {
-  const lines = text.split("\n");
-  if (lines.length <= maxLines) return { body: text, more: 0 };
+function clampLines(text2, maxLines) {
+  const lines = text2.split("\n");
+  if (lines.length <= maxLines) return { body: text2, more: 0 };
   return {
     body: lines.slice(0, maxLines).join("\n"),
     more: lines.length - maxLines
@@ -614,12 +719,8 @@ function foldCosts(events) {
 }
 function statusActivityText(status) {
   switch (status) {
-    case "scheduled":
-      return "Waiting for a worker";
-    case "starting":
-      return "Starting sandbox";
-    case "retrying":
-      return "Retrying after a transient error";
+    case "pending":
+      return "Waiting to start";
     default:
       return null;
   }
@@ -627,26 +728,34 @@ function statusActivityText(status) {
 
 // src/store/chatTurns.ts
 var isInitEvent = (data) => data.kind === "system" && data.subtype === "init";
-var SANDBOX_RECORD_TYPES = /* @__PURE__ */ new Set([
-  "sandbox_starting",
-  "sandbox_phase",
-  "sandbox_output",
-  "sandbox_ready"
+var ENVIRONMENT_RECORD_TYPES = /* @__PURE__ */ new Set([
+  "environment_phase",
+  "environment_output",
+  "environment_ready"
 ]);
-function groupRecordsToChatTurns(records) {
+function groupRecordsToChatTurns(records, session) {
   const turns = [];
   const toolNodeByUseId = /* @__PURE__ */ new Map();
   const userTurnByMessageId = /* @__PURE__ */ new Map();
-  const messageIdByTurnId = /* @__PURE__ */ new Map();
+  const turnByMessageId = /* @__PURE__ */ new Map();
+  const unansweredTurnIds = /* @__PURE__ */ new Set();
+  const activeMessageByTurnId = /* @__PURE__ */ new Map();
+  let lastDeliveredMessageId;
   let seq = 0;
   const nextKey = (base) => `${base}:${seq++}`;
   let openIdx = -1;
   let initCount = 0;
   let pendingResume = false;
-  const openAgentTurn = (record) => {
+  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)) {
+      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,
@@ -666,12 +775,15 @@ function groupRecordsToChatTurns(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 : "";
         if (!body.trim() || userTurnByMessageId.has(messageId)) continue;
         const turn2 = {
           resumed: false,
           isError: false,
           key: `msg:${messageId}`,
+          messageId,
           role: "user",
           nodes: [{ key: `msg:${messageId}`, kind: "user", text: body.trim() }],
           startedAt: record.created_at,
@@ -685,46 +797,51 @@ function groupRecordsToChatTurns(records) {
         continue;
       }
       if (record.record_type === "message_delivered" && messageId) {
-        if (typeof record.payload.turn_id === "string")
-          messageIdByTurnId.set(record.payload.turn_id, messageId);
+        if (typeof record.payload.turn_id === "string") {
+          turnByMessageId.set(messageId, record.payload.turn_id);
+          activeMessageByTurnId.set(record.payload.turn_id, messageId);
+          lastDeliveredMessageId = messageId;
+        }
         continue;
       }
-      if (record.record_type === "turn_failed") {
-        const turnId = typeof record.payload.turn_id === "string" ? record.payload.turn_id : null;
-        const owner = turnId ? messageIdByTurnId.get(turnId) : void 0;
-        const userTurn = owner ? userTurnByMessageId.get(owner) : void 0;
-        if (userTurn) userTurn.isError = true;
+      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);
         continue;
       }
-      const text = lifecycleText(record.record_type, record.payload);
-      if (!text) continue;
-      const isSandbox = SANDBOX_RECORD_TYPES.has(record.record_type);
-      const isSandboxOutput = record.record_type === "sandbox_output";
-      const step = isSandboxOutput ? sandboxOutputStep(record.payload) : void 0;
-      const lines = isSandboxOutput ? sandboxOutputLines(record.payload) : void 0;
+      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 (!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;
       let foldTarget = null;
-      if (isSandbox && record.record_type !== "sandbox_starting") {
+      if (isEnvironment) {
         for (let i = turns.length - 1; i >= 0; i--) {
           const candidate = turns[i];
           if (candidate.role !== "lifecycle") break;
           if (candidate.nodes.some(
-            (n) => n.kind === "lifecycle" && SANDBOX_RECORD_TYPES.has(n.recordType)
+            (n) => n.kind === "lifecycle" && ENVIRONMENT_RECORD_TYPES.has(n.recordType)
           )) {
-            foldTarget = candidate;
+            if (candidate.turnId === turnId) foldTarget = candidate;
             break;
           }
         }
       }
       if (foldTarget) {
         const last = foldTarget.nodes[foldTarget.nodes.length - 1];
-        if (isSandboxOutput && last && last.kind === "lifecycle" && last.recordType === "sandbox_output" && last.step === step) {
-          last.text = text;
+        if (isOutput && last && last.kind === "lifecycle" && last.recordType === "environment_output" && last.step === step) {
+          last.text = text2;
           last.lines = [...last.lines ?? [], ...lines ?? []];
         } else {
           foldTarget.nodes.push({
             key: nextKey(record.id),
             kind: "lifecycle",
-            text,
+            text: text2,
             recordType: record.record_type,
             step,
             lines,
@@ -736,12 +853,13 @@ function groupRecordsToChatTurns(records) {
       }
       turns.push({
         key: nextKey(record.id),
+        turnId,
         role: "lifecycle",
         nodes: [
           {
             key: nextKey(record.id),
             kind: "lifecycle",
-            text,
+            text: text2,
             recordType: record.record_type,
             step,
             lines,
@@ -758,9 +876,14 @@ function groupRecordsToChatTurns(records) {
       });
       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.kind === "codex") {
       codexEventIntoTurns(record, record.payload, {
-        openAgentTurn,
+        openSessionTurn,
         closeTurn: (completedAt, isError) => {
           if (openIdx >= 0) {
             turns[openIdx].completedAt = completedAt;
@@ -782,7 +905,7 @@ function groupRecordsToChatTurns(records) {
           openIdx = -1;
         }
       } else if (content.kind === "tool") {
-        openAgentTurn(record).nodes.push({
+        openSessionTurn(record).nodes.push({
           key: nextKey(record.id),
           kind: "tool",
           name: content.name,
@@ -794,12 +917,14 @@ function groupRecordsToChatTurns(records) {
           completedAt: record.created_at
         });
       } else if (content.text.trim()) {
-        const turn2 = openAgentTurn(record);
+        const turn2 = openSessionTurn(record);
         if (content.kind === "error") turn2.isError = true;
         turn2.nodes.push({
           key: nextKey(record.id),
           kind: content.kind === "error" ? "assistant" : content.kind,
-          text: content.text.trim()
+          text: content.text.trim(),
+          createdAt: record.created_at,
+          ...content.kind === "assistant" && content.phase != null ? { phase: content.phase } : {}
         });
       }
       continue;
@@ -856,6 +981,9 @@ function groupRecordsToChatTurns(records) {
         const node = toolNodeByUseId.get(useId);
         if (node) {
           node.result = body;
+          if (record.kind === "claude_code" || record.kind === "claude_sdk") {
+            node.resultDetails = record.payload.tool_use_result;
+          }
           node.isError = !!block.is_error;
           node.completedAt = record.created_at;
         } else {
@@ -870,14 +998,14 @@ function groupRecordsToChatTurns(records) {
             startedAt: null,
             completedAt: record.created_at
           };
-          openAgentTurn(record).nodes.push(orphan);
+          openSessionTurn(record).nodes.push(orphan);
           toolNodeByUseId.set(useId, orphan);
         }
       }
       continue;
     }
     if (data.kind !== "assistant") continue;
-    const turn = openAgentTurn(record);
+    const turn = openSessionTurn(record);
     if (data.usage && typeof data.usage.output_tokens === "number") {
       turn.tokens = (turn.tokens ?? 0) + data.usage.output_tokens;
     }
@@ -906,11 +1034,60 @@ function groupRecordsToChatTurns(records) {
         turn.nodes.push({
           key: nextKey(record.id),
           kind: "assistant",
-          text: block.text.trim()
+          text: block.text.trim(),
+          createdAt: record.created_at
         });
       }
     }
   }
+  for (const [messageId, turnId] of turnByMessageId) {
+    const turn = userTurnByMessageId.get(messageId);
+    if (turn) turn.isError = unansweredTurnIds.has(turnId);
+  }
+  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 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 opening = initialId ? userTurnByMessageId.get(initialId) : void 0;
+  const includesStart = records.length === 0 || initialTurn != null;
+  const prompt = (session?.claude_code ?? session?.codex)?.prompt;
+  if (prompt?.trim() && session && (opening || includesStart)) {
+    const first = opening ?? {
+      key: "prompt",
+      role: "user",
+      nodes: [{ key: "prompt", kind: "user", text: prompt }],
+      startedAt: session.created_at,
+      completedAt: session.created_at,
+      durationMs: null,
+      costUsd: null,
+      tokens: null,
+      resumed: false,
+      isError: false,
+      progress: { phase: "preparing", turns: [] }
+    };
+    if (opening) turns.splice(turns.indexOf(opening), 1);
+    first.key = "prompt";
+    first.startedAt = session.created_at;
+    turns.unshift(first);
+    if (!opening) {
+      for (const turn of turns) {
+        if (turn !== first && turn.role === "user" && turn.progress && !turn.progress.turns.length) {
+          turn.progress.phase = turn.progress.phase === null ? null : "queued";
+        }
+      }
+    }
+  }
   return turns;
 }
 function codexEventIntoTurns(record, event, ops) {
@@ -919,36 +1096,38 @@ function codexEventIntoTurns(record, event, ops) {
     return;
   }
   if (event.type === "error") {
-    const turn2 = ops.openAgentTurn(record);
+    const turn2 = ops.openSessionTurn(record);
     turn2.nodes.push({
       key: ops.nextKey(record.id),
       kind: "assistant",
-      text: event.message?.trim() || "error"
+      text: event.message?.trim() || "error",
+      createdAt: record.created_at
     });
     return;
   }
   if (event.type !== "item.completed") return;
   const item = event.item;
-  const turn = () => ops.openAgentTurn(record);
+  const turn = () => ops.openSessionTurn(record);
   switch (item.type) {
     case "agent_message": {
-      const text = (item.text ?? "").trim();
-      if (text)
+      const text2 = (item.text ?? "").trim();
+      if (text2)
         turn().nodes.push({
           key: ops.nextKey(record.id),
           kind: "assistant",
-          text
+          text: text2,
+          createdAt: record.created_at
         });
       break;
     }
     case "reasoning": {
       const r = item;
-      const text = (r.text ?? r.summary ?? "").trim();
-      if (text)
+      const text2 = (r.text ?? r.summary ?? "").trim();
+      if (text2)
         turn().nodes.push({
           key: ops.nextKey(record.id),
           kind: "thinking",
-          text
+          text: text2
         });
       break;
     }
@@ -1017,6 +1196,10 @@ 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 humanDuration(seconds) {
   const clamped = Math.max(0, seconds);
   if (clamped === 0) return "0s";
@@ -1035,26 +1218,12 @@ function humanDuration(seconds) {
   if (s > 0 || bits.length === 0) bits.push(`${s}s`);
   return bits.join(" ");
 }
-var SESSION_WAKING = "Session waking";
 function sessionLogText(recordType, payload) {
-  const p = payload;
   switch (recordType) {
-    case "session_idle":
-      return "Session asleep";
-    case "session_starting": {
-      const wake = typeof p.wake_index === "number" ? p.wake_index : 0;
-      const attempt = typeof p.attempt === "number" ? p.attempt : 0;
-      if (attempt > 0) return "Restarting the sandbox after a transient error\u2026";
-      return wake > 0 ? SESSION_WAKING : null;
-    }
-    case "session_retrying":
-      return typeof p.reason === "string" && p.reason ? `Retrying, ${p.reason}` : "Retrying after a transient error\u2026";
-    case "session_resumed":
-      return "Session awake";
-    case "session_cancelled": {
-      const reason = typeof p.reason === "string" && p.reason ? `, ${p.reason}` : "";
-      return `Session cancelled${reason}`;
-    }
+    case "turn_ended":
+      return turnEndedText(payload);
+    case "session_closed":
+      return "Conversation closed";
     default:
       return null;
   }
@@ -1065,14 +1234,20 @@ function awaitingAgentPhase(records) {
   for (const r of records) {
     if (r.source !== "lifecycle") {
       sawAgent = true;
-    } else {
-      if (r.record_type === "turn_started") inFlight = true;
-      else if (r.record_type === "turn_completed" || r.record_type === "turn_failed") {
-        inFlight = false;
-      } else if (r.record_type === "session_starting" || r.record_type === "session_retrying") {
+      continue;
+    }
+    switch (r.record_type) {
+      case "turn_started":
+        inFlight = true;
+        break;
+      case "turn_ended":
         inFlight = false;
+        break;
+      case "environment_phase":
+      case "environment_output":
+      case "environment_ready":
         sawAgent = false;
-      }
+        break;
     }
   }
   if (!inFlight) return null;
@@ -1081,14 +1256,14 @@ function awaitingAgentPhase(records) {
 function deliveredUnechoedSends(records) {
   const received = /* @__PURE__ */ new Map();
   const delivered = /* @__PURE__ */ new Map();
-  const failedTurns = /* @__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_failed") {
-      if (typeof r.payload.turn_id === "string")
-        failedTurns.add(r.payload.turn_id);
+    if (r.record_type === "turn_ended") {
+      if (typeof r.payload.turn_id === "string" && r.payload.status !== "completed")
+        unanswered.add(r.payload.turn_id);
       continue;
     }
     const id = typeof r.payload.message_id === "string" ? r.payload.message_id : null;
@@ -1110,11 +1285,11 @@ function deliveredUnechoedSends(records) {
   for (const [id, body] of received) {
     const turnId = delivered.get(id);
     if (turnId === void 0 || echoed.has(id)) continue;
-    out.push({ id, body, cancelled: failedTurns.has(turnId) });
+    out.push({ id, body, cancelled: unanswered.has(turnId) });
   }
   return out;
 }
-var STARTING_SANDBOX = "Starting sandbox\u2026";
+var PREPARING_ENVIRONMENT = "Preparing environment";
 function msLabel(ms) {
   if (typeof ms !== "number" || !isFinite(ms) || ms < 0) return null;
   return humanDuration(ms / 1e3);
@@ -1152,64 +1327,38 @@ function stepLabel(phase, step) {
     if (phase === "image") return imageStepLabel(step);
     return step;
   }
-  return sandboxPhaseLabel(phase);
+  return environmentPhaseLabel(phase);
 }
-function deriveSandboxState(records, minFeedSeq) {
+function deriveEnvironmentState(records, minFeedSeq) {
   let seen = false;
-  let headline = STARTING_SANDBOX;
   let done = false;
-  let sandboxDone = false;
   let readySeconds = null;
-  let configName = null;
-  let configCommitSha = null;
   let log = [];
   let open = /* @__PURE__ */ new Map();
-  const push = (record, kind, text) => {
-    const entry = { key: `${record.feed_seq}:${log.length}`, kind, text };
+  let storyTurn = null;
+  const push = (record, kind, text2) => {
+    const entry = { key: `${record.feed_seq}:${log.length}`, kind, text: text2 };
     log.push(entry);
     return entry;
   };
-  const reset = () => {
-    log = [];
-    open = /* @__PURE__ */ new Map();
-    sandboxDone = false;
+  const begin = (record) => {
+    const turn = turnOf(record);
+    if (seen && turn !== storyTurn) {
+      log = [];
+      open = /* @__PURE__ */ new Map();
+      done = false;
+      readySeconds = null;
+    }
+    seen = true;
+    storyTurn = turn;
   };
   for (const record of records) {
     if (record.feed_seq <= minFeedSeq || record.source !== "lifecycle")
       continue;
     const p = record.payload;
     switch (record.record_type) {
-      case "session_scheduled": {
-        seen = true;
-        headline = "Session scheduled\u2026";
-        done = false;
-        configName = typeof p.config_name === "string" && p.config_name ? p.config_name : null;
-        configCommitSha = typeof p.config_commit_sha === "string" && p.config_commit_sha ? p.config_commit_sha : null;
-        break;
-      }
-      case "session_starting":
-      case "session_retrying": {
-        seen = true;
-        const text = lifecycleText(record.record_type, p);
-        headline = !text || text === "Session starting\u2026" ? STARTING_SANDBOX : text;
-        done = false;
-        readySeconds = null;
-        reset();
-        break;
-      }
-      case "session_resumed":
-      case "session_idle": {
-        seen = true;
-        done = true;
-        break;
-      }
-      case "sandbox_starting": {
-        seen = true;
-        reset();
-        break;
-      }
-      case "sandbox_phase": {
-        seen = true;
+      case "environment_phase": {
+        begin(record);
         const phase = typeof p.phase === "string" && p.phase ? p.phase : "setup";
         const step = typeof p.step === "string" && p.step ? p.step : null;
         const key = step ? `${phase}:${step}` : phase;
@@ -1220,7 +1369,7 @@ function deriveSandboxState(records, minFeedSeq) {
           const dur = msLabel(p.duration_ms);
           const failed = p.status === "failed";
           const base = failed ? `${label} failed` : label;
-          const text = [
+          const text2 = [
             base,
             ...tier ? [tier] : [],
             ...dur ? [dur] : []
@@ -1228,80 +1377,60 @@ function deriveSandboxState(records, minFeedSeq) {
           const line = open.get(key);
           if (line) {
             line.kind = failed ? "failed" : "done";
-            line.text = text;
+            line.text = text2;
             open.delete(key);
           } else {
-            push(record, failed ? "failed" : "done", text);
+            push(record, failed ? "failed" : "done", text2);
           }
         } else if (!open.has(key)) {
           open.set(key, push(record, "step", `${label}\u2026`));
         }
         break;
       }
-      case "sandbox_output": {
-        seen = true;
-        for (const l of sandboxOutputLines(p)) push(record, "output", l);
+      case "environment_output": {
+        begin(record);
+        for (const l of environmentOutputLines(p)) push(record, "output", l);
         break;
       }
-      case "sandbox_ready": {
-        seen = true;
+      case "environment_ready": {
+        begin(record);
         for (const [, line] of open) line.kind = "done";
         open = /* @__PURE__ */ new Map();
-        const timings = p.phase_timings && typeof p.phase_timings === "object" ? Object.values(p.phase_timings) : [];
-        const totalSeconds = timings.reduce(
-          (acc, v) => typeof v === "number" && isFinite(v) ? acc + v : acc,
-          0
-        );
-        const tier = cacheTierLabel(p.cache_tier);
+        const seconds = typeof p.duration_ms === "number" && isFinite(p.duration_ms) && p.duration_ms > 0 ? p.duration_ms / 1e3 : null;
         push(
           record,
           "done",
-          [
-            "Sandbox ready",
-            ...tier ? [tier] : [],
-            ...totalSeconds > 0 ? [humanDuration(totalSeconds)] : []
-          ].join(", ")
+          seconds == null ? "Environment ready" : `Environment ready, ${humanDuration(seconds)}`
         );
-        sandboxDone = true;
-        readySeconds = totalSeconds > 0 ? totalSeconds : null;
+        readySeconds = seconds;
         done = true;
         break;
       }
+      case "turn_started":
+      case "turn_ended":
+        if (seen && turnOf(record) === storyTurn) done = true;
+        break;
+      case "session_closed":
+        if (seen) done = true;
+        break;
       default:
         break;
     }
   }
   const openLines = [...open.values()];
   if (openLines.length) openLines[openLines.length - 1].loading = true;
-  const full = configName ? [
-    {
-      key: "config",
-      kind: "done",
-      text: `Using ${configName}${configCommitSha ? ` @ ${configCommitSha.slice(0, 7)}` : ""}`
-    },
-    ...log
-  ] : log;
-  return seen ? {
-    headline,
-    done,
-    readySeconds,
-    sandboxDone,
-    configName,
-    configCommitSha,
-    log: full
-  } : null;
-}
-function startupSettled(sandbox, status) {
-  return (sandbox?.done ?? false) && statusActivityText(status) == null;
-}
-function startupHeadline(sandbox, status) {
-  const activity = statusActivityText(status);
-  const text = !sandbox || sandbox.done ? activity ?? STARTING_SANDBOX : sandbox.headline;
-  return `${text.replace(/…$/, "")}\u2026`;
-}
-function sandboxSummary(sandbox) {
-  const seconds = sandbox?.readySeconds ?? null;
-  return seconds ? `Sandbox ready in ${humanDuration(seconds)}` : "Sandbox started";
+  return seen ? { done, readySeconds, log } : null;
+}
+function startupSettled(environment, status) {
+  return (environment?.done ?? false) && statusActivityText(status) == null;
+}
+function startupHeadline(environment, status) {
+  const text2 = !environment || environment.done ? statusActivityText(status) ?? PREPARING_ENVIRONMENT : PREPARING_ENVIRONMENT;
+  return `${text2}\u2026`;
+}
+function environmentSummary(environment) {
+  const seconds = environment?.readySeconds ?? null;
+  return seconds ? `Environment ready in ${humanDuration(seconds)}` : "Environment ready";
 }
 function lastLines(log, max) {
   return log.length <= max ? [...log] : log.slice(log.length - max);
@@ -1317,42 +1446,21 @@ function gutterFor(item) {
   if (item.kind === "system" || item.kind === "notice") return "\u2726";
   return item.gutter ?? "";
 }
-var SANDBOX_RECORD_TYPES2 = /* @__PURE__ */ new Set([
-  "sandbox_starting",
-  "sandbox_phase",
-  "sandbox_output",
-  "sandbox_ready"
+var ENVIRONMENT_RECORD_TYPES2 = /* @__PURE__ */ new Set([
+  "environment_phase",
+  "environment_output",
+  "environment_ready"
 ]);
 function chatTurnsToItems(turns) {
   const items = [];
-  let wakeAt = -1;
-  const settleWake = () => {
-    if (wakeAt < 0) return;
-    const { loading: _, ...settled } = items[wakeAt];
-    items[wakeAt] = { ...settled, text: "Session awake" };
-    wakeAt = -1;
-  };
   for (const turn of turns) {
-    if (turn.role === "assistant") settleWake();
     if (turn.role === "lifecycle") {
       for (const node of turn.nodes) {
         if (node.kind !== "lifecycle") continue;
-        if (SANDBOX_RECORD_TYPES2.has(node.recordType)) continue;
-        if (node.recordType === "session_resumed") {
-          settleWake();
-          continue;
-        }
-        const text = sessionLogText(node.recordType, node.payload ?? {});
-        if (!text) continue;
-        const waking = text === SESSION_WAKING;
-        items.push({
-          key: node.key,
-          kind: "notice",
-          text,
-          spaceBefore: true,
-          ...waking ? { loading: true } : {}
-        });
-        wakeAt = waking ? items.length - 1 : -1;
+        if (ENVIRONMENT_RECORD_TYPES2.has(node.recordType)) continue;
+        const text2 = sessionLogText(node.recordType, node.payload ?? {});
+        if (!text2) continue;
+        items.push({ key: node.key, kind: "notice", text: text2, spaceBefore: true });
       }
       continue;
     }
@@ -1363,6 +1471,7 @@ function chatTurnsToItems(turns) {
             key: node.key,
             kind: "user",
             text: node.text,
+            createdAt: turn.startedAt,
             spaceBefore: true,
             ...turn.isError ? { isError: true } : {}
           });
@@ -1376,6 +1485,7 @@ function chatTurnsToItems(turns) {
           key: node.key,
           kind: "assistant",
           text: node.text,
+          createdAt: node.createdAt,
           spaceBefore: true
         });
       } else if (node.kind === "thinking") {
@@ -1430,14 +1540,19 @@ function isToolActivity(item) {
   return item.kind === "tool" || item.kind === "tool_result" || isToolFold(item);
 }
 function layOutItems(items) {
-  return items.map((item) => ({ item, nested: false, attach: false }));
+  const isActivity = (item) => item.kind === "thinking" || isToolActivity(item);
+  return items.map((item, index) => ({
+    item,
+    nested: false,
+    attach: index > 0 && isActivity(item) && isActivity(items[index - 1])
+  }));
 }
 function foldGutter(nested) {
   return nested ? BRANCH_GLYPH : "\u25CF";
 }
-function tailLines(text, maxLines) {
-  const lines = text.split("\n");
-  if (lines.length <= maxLines) return { body: text, hidden: 0 };
+function tailLines(text2, maxLines) {
+  const lines = text2.split("\n");
+  if (lines.length <= maxLines) return { body: text2, hidden: 0 };
   return {
     body: lines.slice(lines.length - maxLines).join("\n"),
     hidden: lines.length - maxLines
@@ -1462,24 +1577,44 @@ function toolRunMembers(items) {
 function splitLedger(turns) {
   const preamble = [];
   const entries = [];
+  const entryByTurn = /* @__PURE__ */ new Map();
+  const entryByMessage = /* @__PURE__ */ new Map();
   for (const turn of turns) {
     if (turn.role === "user") {
       const node = turn.nodes.find((n) => n.kind === "user");
-      entries.push({
+      const entry = {
         key: turn.key,
         prompt: node?.text ?? "",
+        createdAt: turn.startedAt,
         cancelled: turn.isError,
-        turns: []
-      });
+        turns: [],
+        ...turn.progress ? { progress: turn.progress } : {}
+      };
+      entries.push(entry);
+      entryByTurn.set(turn, entry);
+      if (turn.messageId) entryByMessage.set(turn.messageId, entry);
+    }
+  }
+  let last;
+  for (const turn of turns) {
+    if (turn.role === "user") {
+      last = entryByTurn.get(turn);
       continue;
     }
-    const last = entries[entries.length - 1];
-    if (last) last.turns.push(turn);
+    const owner = turn.messageId ? entryByMessage.get(turn.messageId) : last;
+    if (owner) owner.turns.push(turn);
     else preamble.push(turn);
   }
   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;
+  }
   let ms = 0;
   for (const turn of entry.turns) {
     if (turn.role !== "assistant" || turn.startedAt == null) continue;
@@ -1491,12 +1626,15 @@ function entrySeconds(entry, now) {
   }
   return ms / 1e3;
 }
-function foldToolTurn(raw, live, members) {
+function isWorkFold(item) {
+  return item.key.startsWith("work:");
+}
+function foldToolTurn(raw, members) {
   const items = [];
   let run = [];
   const flush = () => {
     if (run.length === 0) return;
-    const fold = foldRun(run, live && pendingToolCalls(run).length > 0);
+    const fold = foldRun(run, false);
     members.set(fold.key, run);
     items.push(fold);
     run = [];
@@ -1511,77 +1649,217 @@ function foldToolTurn(raw, live, members) {
   flush();
   return items;
 }
+function finalReplyKeys(entry, live) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const turn of entry.turns) {
+    if (turn.role !== "assistant") continue;
+    for (const node of turn.nodes) {
+      if (node.kind === "assistant" && node.phase === "final_answer") {
+        keys.add(node.key);
+      }
+    }
+    if (entry.cancelled || turn.isError) continue;
+    if (live && turn.completedAt == null && turn.durationMs == null) continue;
+    for (let i = turn.nodes.length - 1; i >= 0; i--) {
+      const node = turn.nodes[i];
+      if (node.kind !== "assistant" || node.phase === "commentary") break;
+      keys.add(node.key);
+      const previous = turn.nodes[i - 1];
+      if (node.createdAt == null || previous?.kind !== "assistant" || previous.createdAt !== node.createdAt)
+        break;
+    }
+  }
+  return keys;
+}
+function reasoningSummaryTitle(summary) {
+  const line = summary.trim().split(/\r?\n/, 1)[0] ?? "";
+  const title = line.replace(/^#{1,6}\s+/, "").replace(/^[*_`]+|[*_`]+$/g, "").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").trim();
+  return title.length > 120 ? `${title.slice(0, 119).trimEnd()}\u2026` : title;
+}
 function entryBody(entry, {
   live,
   now,
-  liveText = ""
+  liveText = "",
+  liveSummary = ""
 }) {
+  live = live && (entry.progress === void 0 || entry.progress.phase !== null);
   const raw = chatTurnsToItems(entry.turns);
+  const replies = finalReplyKeys(entry, live);
   const members = /* @__PURE__ */ new Map();
-  const toolRan = raw.some((i) => i.kind === "tool");
-  let items;
-  if (toolRan) {
-    items = foldToolTurn(raw, live, members);
-  } else {
-    const thoughts = raw.filter((i) => i.kind === "thinking");
-    items = raw.filter((i) => i.kind !== "thinking");
-    const key = `grp:thought:${entry.key}`;
-    if (thoughts.length) members.set(key, thoughts);
-    if (live && liveText === "") {
-      items.push({
-        key,
-        kind: "thinking",
-        text: "Thinking",
-        summary: true,
-        spaceBefore: true
-      });
-    } else if (!live && thoughts.length) {
-      items.push({
-        key,
-        kind: "thinking",
-        text: `Thought for ${humanDuration(entrySeconds(entry, now))}`,
-        summary: true,
+  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 key = `work:${entry.key}`;
+  const header = {
+    key,
+    kind: "summary",
+    text: live ? phase === "preparing" ? "Preparing environment" : phase === "starting" ? "Starting agent" : phase === "queued" ? "Queued" : reasoningSummaryTitle(liveSummary) || "Working" : seconds == null ? "Session startup" : `Worked for ${humanDuration(seconds)}`,
+    spaceBefore: true,
+    ...entry.cancelled || entry.turns.some((turn) => turn.isError) ? { isError: true } : {},
+    ...live ? { loading: true } : {}
+  };
+  if (live && (phase === void 0 || phase === "working")) {
+    const visible = raw.map(({ loading: _, ...item }) => item);
+    if (liveText !== "") {
+      visible.push({
+        key: `live:${entry.key}`,
+        kind: "assistant",
+        text: liveText,
         spaceBefore: true
       });
     }
+    return {
+      items: [header, ...foldToolTurn(visible, members)],
+      members,
+      seconds
+    };
+  }
+  const addWork = (item) => {
+    if (work.length === 0) items.push(header);
+    work.push(item);
+  };
+  for (const item of raw) {
+    const { loading: _, ...settled } = item;
+    if (replies.has(item.key) || !["assistant", "thinking", "tool", "tool_result"].includes(item.kind)) {
+      items.push(settled);
+    } else {
+      addWork(settled);
+    }
   }
   if (live && liveText !== "") {
-    items.push({
+    addWork({
       key: `live:${entry.key}`,
       kind: "assistant",
       text: liveText,
       spaceBefore: true
     });
   }
-  const chosen = live ? liveRow(items, members) : -1;
-  items = items.map((item, i) => {
-    const { loading: _, ...rest } = item;
-    return i === chosen ? { ...rest, loading: true } : rest;
-  });
-  return { items, members };
+  if (work.length > 0) {
+    members.set(key, foldToolTurn(work, members));
+  } else if (live) {
+    items.unshift(header);
+  }
+  return { items, members, seconds };
 }
-function liveRow(items, members) {
-  if (items.length === 0) return -1;
-  const running = items.findIndex((item) => {
-    const run = members.get(item.key);
-    return run != null && pendingToolCalls(run).length > 0;
-  });
-  if (running >= 0) return running;
-  return items.length - 1;
+
+// src/store/activity.ts
+var text = (value) => typeof value === "string" ? value : "";
+function toolActivities(item) {
+  const input = item.tool?.input ?? {};
+  const name = item.tool?.name ?? item.text;
+  const actions = input.commandActions;
+  if (Array.isArray(actions) && actions.length) {
+    const parsed = actions.flatMap((value) => {
+      if (!value || typeof value !== "object") return [];
+      const action = value;
+      switch (action.type) {
+        case "read":
+          return [
+            {
+              kind: "read",
+              label: "Read",
+              detail: text(action.path) || text(action.name)
+            }
+          ];
+        case "search": {
+          const query = text(action.query);
+          const path2 = text(action.path);
+          return [
+            {
+              kind: "search",
+              label: "Searched",
+              detail: (query ? `for ${query}` : "code") + (path2 ? ` in ${path2}` : "")
+            }
+          ];
+        }
+        case "listFiles":
+          return [
+            {
+              kind: "list",
+              label: "Listed",
+              detail: text(action.path) || "files"
+            }
+          ];
+        default:
+          return [
+            {
+              kind: "command",
+              label: "Ran",
+              detail: text(action.command) || text(input.command)
+            }
+          ];
+      }
+    });
+    if (parsed.length) return parsed;
+  }
+  const path = text(input.file_path) || text(input.path) || text(input.notebook_path);
+  switch (name.toLowerCase()) {
+    case "read":
+      return [{ kind: "read", label: "Read", detail: path }];
+    case "edit":
+    case "write":
+    case "multiedit":
+      if (Array.isArray(input.changes)) {
+        return input.changes.map((change) => ({
+          kind: "edit",
+          label: "Edited",
+          detail: text(change?.path)
+        }));
+      }
+      return [
+        {
+          kind: "edit",
+          label: name.toLowerCase() === "write" ? "Wrote" : "Edited",
+          detail: path
+        }
+      ];
+    case "grep":
+    case "glob":
+      return [
+        {
+          kind: "search",
+          label: "Searched",
+          detail: `for ${text(input.pattern)}` + (path ? ` in ${path}` : "")
+        }
+      ];
+    case "bash":
+      return [{ kind: "command", label: "Ran", detail: text(input.command) }];
+    case "websearch":
+      return [
+        { kind: "web", label: "Searched the web", detail: text(input.query) }
+      ];
+    case "webfetch":
+      return [{ kind: "web", label: "Opened", detail: text(input.url) }];
+    default:
+      return [
+        {
+          kind: "tool",
+          label: name.replace(/^mcp__/, "").replace("__", ":"),
+          detail: item.detail ?? ""
+        }
+      ];
+  }
+}
+function activitySummary(activities) {
+  const labels = {
+    read: "read files",
+    search: "searched code",
+    list: "listed files",
+    edit: "edited files",
+    command: "ran commands",
+    web: "browsed the web",
+    tool: "used tools"
+  };
+  const summary = [
+    ...new Set(activities.map((activity) => labels[activity.kind]))
+  ].join(", ");
+  return summary ? summary[0].toUpperCase() + summary.slice(1) : "Activity";
 }
 
 // src/store/index.ts
-var TERMINAL_SESSION_STATUSES = /* @__PURE__ */ new Set([
-  "completed",
-  "error",
-  "cancelled",
-  "stopped"
-]);
 function isConversationOver(session) {
-  if (session.session_state != null) {
-    return session.session_state === "closed";
-  }
-  return TERMINAL_SESSION_STATUSES.has(session.status);
+  return session.conversation.state === "closed";
 }
 function seedTranscriptStore(store, seed) {
   store.ingest({
@@ -1602,6 +1880,7 @@ var EMPTY_SNAPSHOT = {
   acknowledgedMessageIds: /* @__PURE__ */ new Set(),
   historyTruncated: false,
   liveText: "",
+  liveSummary: "",
   liveOutputTokens: null,
   lastEventAt: null,
   conversationOver: false
@@ -1625,7 +1904,9 @@ var SessionTranscriptStore = class {
   cursorSeq = 0;
   // Derived-turn cache, keyed on the records array identity.
   turnsFor = null;
+  turnsSession = null;
   turnsCache = [];
+  summaryTurnId = null;
   get cursor() {
     return this.cursorSeq;
   }
@@ -1640,9 +1921,10 @@ var SessionTranscriptStore = class {
   // records_append batch) — what a chat-style transcript renders.
   chatTurns = () => {
     const records = this.snapshot.records;
-    if (this.turnsFor !== records) {
-      this.turnsCache = groupRecordsToChatTurns(records);
+    if (this.turnsFor !== records || this.turnsSession !== this.snapshot.session) {
+      this.turnsCache = groupRecordsToChatTurns(records, this.snapshot.session);
       this.turnsFor = records;
+      this.turnsSession = this.snapshot.session;
     }
     return this.turnsCache;
   };
@@ -1668,7 +1950,8 @@ var SessionTranscriptStore = class {
           sender_attribution_id: typeof payload.sender_attribution_id === "string" ? payload.sender_attribution_id : null,
           created_at: record.created_at,
           delivered_at: null,
-          delivered_turn_id: null
+          images: [],
+          turn_id: typeof payload.turn_id === "string" ? payload.turn_id : null
         });
         return true;
       }
@@ -1679,7 +1962,7 @@ var SessionTranscriptStore = class {
           ...existing,
           status: "delivered",
           delivered_at: record.created_at,
-          delivered_turn_id: typeof payload.turn_id === "string" ? payload.turn_id : null
+          turn_id: typeof payload.turn_id === "string" ? payload.turn_id : existing.turn_id
         });
         return true;
       }
@@ -1690,7 +1973,7 @@ var SessionTranscriptStore = class {
           ...existing,
           status: "pending",
           delivered_at: null,
-          delivered_turn_id: null
+          turn_id: typeof payload.requeued_turn_id === "string" ? payload.requeued_turn_id : null
         });
         return true;
       }
@@ -1709,6 +1992,7 @@ 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);
@@ -1733,6 +2017,8 @@ var SessionTranscriptStore = class {
             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)
+              next.liveSummary = "";
             inboxChanged = this.applyMessageRecord(record) || inboxChanged;
             if (record.record_type === "message_received" || record.record_type === "message_delivered") {
               const payload = record.payload;
@@ -1754,17 +2040,34 @@ var SessionTranscriptStore = class {
       case "session": {
         next.session = frame.session;
         next.conversationOver = isConversationOver(frame.session);
+        if (next.conversationOver || frame.session.turn?.status !== "running") {
+          next.liveSummary = "";
+        }
         break;
       }
       case "delta": {
+        if (frame.kind === "thinking") {
+          if (next.conversationOver) break;
+          this.summaryTurnId = frame.turn_id;
+          if (frame.text != null) next.liveSummary = frame.text;
+          break;
+        }
         if (frame.kind !== "text") break;
-        if (frame.text != null) next.liveText = prev.liveText + frame.text;
+        if (frame.text != null) {
+          next.liveText = prev.liveText + frame.text;
+          next.liveSummary = "";
+        }
         if (frame.output_tokens != null)
           next.liveOutputTokens = frame.output_tokens;
         break;
       }
       case "done": {
         next.conversationOver = true;
+        next.liveSummary = "";
+        break;
+      }
+      case "error": {
+        next.liveSummary = "";
         break;
       }
       default:
@@ -1777,9 +2080,9 @@ var SessionTranscriptStore = class {
 export {
   BRANCH_GLYPH,
   LIVE_GLYPH,
-  SESSION_WAKING,
   SessionTranscriptStore,
   USER_BAR,
+  activitySummary,
   awaitingAgentPhase,
   cacheTierLabel,
   chatTurnsToItems,
@@ -1790,10 +2093,15 @@ export {
   codexMcpToolName,
   collapseToolRuns,
   deliveredUnechoedSends,
-  deriveSandboxState,
+  deriveEnvironmentState,
   emptySessionTranscriptSnapshot,
   entryBody,
   entrySeconds,
+  environmentOutputLine,
+  environmentOutputLines,
+  environmentOutputStep,
+  environmentPhaseLabel,
+  environmentSummary,
   eventToItems,
   foldCosts,
   foldGutter,
@@ -1808,19 +2116,16 @@ export {
   isFoldable,
   isToolActivity,
   isToolFold,
+  isWorkFold,
   lastLines,
   layOutItems,
   lifecycleText,
   oneLine,
   pendingToolCalls,
+  reasoningSummaryTitle,
   recordSlice,
   recordToItems,
   resultCostUsd,
-  sandboxOutputLine,
-  sandboxOutputLines,
-  sandboxOutputStep,
-  sandboxPhaseLabel,
-  sandboxSummary,
   seedTranscriptStore,
   sessionLogText,
   splitLedger,
@@ -1829,6 +2134,8 @@ export {
   statusActivityText,
   summarizeToolInput,
   tailLines,
+  toolActivities,
   toolResultText,
-  toolRunMembers
+  toolRunMembers,
+  turnEndedText
 };