@ellipsis-dev/sdk 0.28.0 → 0.30.0

package/dist/store/index.js

@@ -1,6 +1,6 @@
 import {
   SESSION_STREAM_PROTOCOL_VERSION
-} from "../chunk-YJC53TA7.js";
+} from "../chunk-K252XHLI.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,6 +104,117 @@ function codexAppServerContent(event) {
   }
 }
 
+// src/store/progress.ts
+function messageProgress(records) {
+  const messages = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Set();
+  const turns = /* @__PURE__ */ new Map();
+  let starting = "queued";
+  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 updatePending = () => {
+    for (const id of pending) messages.get(id).phase = starting;
+  };
+  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;
+    starting = "queued";
+    updatePending();
+  };
+  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: starting, turns: [] });
+            pending.add(messageId);
+          }
+          break;
+        case "message_delivered":
+          if (messageId && turnId) attach(messageId, turnId);
+          break;
+        case "message_requeued":
+          if (messageId && messages.has(messageId)) {
+            pending.add(messageId);
+            messages.get(messageId).phase = "queued";
+          }
+          break;
+        case "session_starting":
+        case "session_retrying":
+          ready = false;
+          starting = typeof p.wake_index === "number" && p.wake_index > 0 ? "waking" : "starting";
+          updatePending();
+          break;
+        case "session_resumed":
+          starting = "starting";
+          updatePending();
+          break;
+        case "turn_started":
+          if (turnId) getTurn(turnId).timing.startedAt = record.created_at;
+          break;
+        case "turn_completed":
+        case "turn_failed":
+          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;
+            }
+          }
+          starting = "queued";
+          break;
+        case "session_idle":
+        case "session_closed":
+        case "session_cancelled":
+          ready = false;
+          starting = "queued";
+          for (const id of pending) 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) {
   if (typeof payload.step === "string" && payload.step) return payload.step;
@@ -221,8 +333,8 @@ function lifecycleText(recordType, payload) {
 }
 
 // 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 +489,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,8 +629,8 @@ 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 [];
@@ -589,9 +701,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
@@ -633,20 +745,29 @@ var SANDBOX_RECORD_TYPES = /* @__PURE__ */ new Set([
   "sandbox_output",
   "sandbox_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 deliveredTurnByMessageId = /* @__PURE__ */ new Map();
+  const failedTurnIds = /* @__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,
@@ -672,6 +793,7 @@ function groupRecordsToChatTurns(records) {
           resumed: false,
           isError: false,
           key: `msg:${messageId}`,
+          messageId,
           role: "user",
           nodes: [{ key: `msg:${messageId}`, kind: "user", text: body.trim() }],
           startedAt: record.created_at,
@@ -685,19 +807,24 @@ 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") {
+          deliveredTurnByMessageId.set(messageId, record.payload.turn_id);
+          activeMessageByTurnId.set(record.payload.turn_id, messageId);
+          lastDeliveredMessageId = messageId;
+        }
+        continue;
+      }
+      if (record.record_type === "message_requeued" && messageId) {
+        deliveredTurnByMessageId.delete(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 (typeof record.payload.turn_id === "string")
+          failedTurnIds.add(record.payload.turn_id);
         continue;
       }
-      const text = lifecycleText(record.record_type, record.payload);
-      if (!text) continue;
+      const text2 = lifecycleText(record.record_type, record.payload);
+      if (!text2) 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;
@@ -718,13 +845,13 @@ function groupRecordsToChatTurns(records) {
       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;
+          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,
@@ -741,7 +868,7 @@ function groupRecordsToChatTurns(records) {
           {
             key: nextKey(record.id),
             kind: "lifecycle",
-            text,
+            text: text2,
             recordType: record.record_type,
             step,
             lines,
@@ -758,9 +885,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 +914,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 +926,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 +990,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 +1007,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 +1043,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 deliveredTurnByMessageId) {
+    const turn = userTurnByMessageId.get(messageId);
+    if (turn) turn.isError = failedTurnIds.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 initialDelivery = initialTurn && records.find(
+    (r) => r.kind === "platform" && r.record_type === "message_delivered" && r.payload.turn_id === (initialTurn.turn_id ?? initialTurn.payload.turn_id)
+  );
+  const initialReceived = initialTurn && records.find(
+    (r) => r.kind === "platform" && r.record_type === "message_received" && r.turn_id === (initialTurn.turn_id ?? initialTurn.payload.turn_id)
+  );
+  const initialMessage = initialReceived ?? initialDelivery;
+  const initialId = initialMessage?.kind === "platform" && typeof initialMessage.payload.message_id === "string" ? initialMessage.payload.message_id : void 0;
+  const opening = initialId ? userTurnByMessageId.get(initialId) : void 0;
+  const includesStart = records.length === 0 || records.some((r) => r.record_type === "session_scheduled");
+  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.lifecycle.timestamps.created_at,
+      completedAt: session.lifecycle.timestamps.created_at,
+      durationMs: null,
+      costUsd: null,
+      tokens: null,
+      resumed: false,
+      isError: false,
+      progress: { phase: "starting", turns: [] }
+    };
+    if (opening) turns.splice(turns.indexOf(opening), 1);
+    first.key = "prompt";
+    first.startedAt = session.lifecycle.timestamps.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 +1105,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;
     }
@@ -1164,8 +1352,8 @@ function deriveSandboxState(records, minFeedSeq) {
   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 };
+  const push = (record, kind, text2) => {
+    const entry = { key: `${record.feed_seq}:${log.length}`, kind, text: text2 };
     log.push(entry);
     return entry;
   };
@@ -1190,8 +1378,8 @@ function deriveSandboxState(records, minFeedSeq) {
       case "session_starting":
       case "session_retrying": {
         seen = true;
-        const text = lifecycleText(record.record_type, p);
-        headline = !text || text === "Session starting\u2026" ? STARTING_SANDBOX : text;
+        const text2 = lifecycleText(record.record_type, p);
+        headline = !text2 || text2 === "Session starting\u2026" ? STARTING_SANDBOX : text2;
         done = false;
         readySeconds = null;
         reset();
@@ -1220,7 +1408,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,10 +1416,10 @@ 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`));
@@ -1296,8 +1484,8 @@ function startupSettled(sandbox, status) {
 }
 function startupHeadline(sandbox, status) {
   const activity = statusActivityText(status);
-  const text = !sandbox || sandbox.done ? activity ?? STARTING_SANDBOX : sandbox.headline;
-  return `${text.replace(/…$/, "")}\u2026`;
+  const text2 = !sandbox || sandbox.done ? activity ?? STARTING_SANDBOX : sandbox.headline;
+  return `${text2.replace(/…$/, "")}\u2026`;
 }
 function sandboxSummary(sandbox) {
   const seconds = sandbox?.readySeconds ?? null;
@@ -1342,13 +1530,13 @@ function chatTurnsToItems(turns) {
           settleWake();
           continue;
         }
-        const text = sessionLogText(node.recordType, node.payload ?? {});
-        if (!text) continue;
-        const waking = text === SESSION_WAKING;
+        const text2 = sessionLogText(node.recordType, node.payload ?? {});
+        if (!text2) continue;
+        const waking = text2 === SESSION_WAKING;
         items.push({
           key: node.key,
           kind: "notice",
-          text,
+          text: text2,
           spaceBefore: true,
           ...waking ? { loading: true } : {}
         });
@@ -1363,6 +1551,7 @@ function chatTurnsToItems(turns) {
             key: node.key,
             kind: "user",
             text: node.text,
+            createdAt: turn.startedAt,
             spaceBefore: true,
             ...turn.isError ? { isError: true } : {}
           });
@@ -1376,6 +1565,7 @@ function chatTurnsToItems(turns) {
           key: node.key,
           kind: "assistant",
           text: node.text,
+          createdAt: node.createdAt,
           spaceBefore: true
         });
       } else if (node.kind === "thinking") {
@@ -1430,14 +1620,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 +1657,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 +1706,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 +1729,224 @@ 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 wakeKeys = new Set(
+    entry.turns.flatMap(
+      (turn) => turn.nodes.flatMap(
+        (node) => node.kind === "lifecycle" && (node.recordType === "session_resumed" || node.recordType === "session_starting" && typeof node.payload?.wake_index === "number" && node.payload.wake_index > 0) ? [node.key] : []
+      )
+    )
+  );
+  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 === "waking" ? "Waking session" : 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.filter((item) => !wakeKeys.has(item.key)).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 (!wakeKeys.has(item.key) && (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.lifecycle.conversation === "closed";
 }
 function seedTranscriptStore(store, seed) {
   store.ingest({
@@ -1602,6 +1967,7 @@ var EMPTY_SNAPSHOT = {
   acknowledgedMessageIds: /* @__PURE__ */ new Set(),
   historyTruncated: false,
   liveText: "",
+  liveSummary: "",
   liveOutputTokens: null,
   lastEventAt: null,
   conversationOver: false
@@ -1625,7 +1991,10 @@ var SessionTranscriptStore = class {
   cursorSeq = 0;
   // Derived-turn cache, keyed on the records array identity.
   turnsFor = null;
+  turnsSession = null;
   turnsCache = [];
+  summaryTurnId = null;
+  summaryExecutionId = null;
   get cursor() {
     return this.cursorSeq;
   }
@@ -1640,9 +2009,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;
   };
@@ -1709,6 +2079,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 +2104,8 @@ var SessionTranscriptStore = class {
             acknowledgedNew = true;
           }
           if (record.source === "lifecycle") {
+            if (record.record_type === "turn_started" && (record.turn_id !== this.summaryTurnId || record.session_execution_id !== this.summaryExecutionId) || (record.record_type === "turn_completed" || record.record_type === "turn_failed") && record.turn_id === this.summaryTurnId && record.session_execution_id === this.summaryExecutionId)
+              next.liveSummary = "";
             inboxChanged = this.applyMessageRecord(record) || inboxChanged;
             if (record.record_type === "message_received" || record.record_type === "message_delivered") {
               const payload = record.payload;
@@ -1754,17 +2127,35 @@ var SessionTranscriptStore = class {
       case "session": {
         next.session = frame.session;
         next.conversationOver = isConversationOver(frame.session);
+        if (next.conversationOver || frame.session.lifecycle.status === "idle") {
+          next.liveSummary = "";
+        }
         break;
       }
       case "delta": {
+        if (frame.kind === "thinking") {
+          if (next.conversationOver) break;
+          this.summaryTurnId = frame.turn_id;
+          this.summaryExecutionId = frame.session_execution_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:
@@ -1780,6 +2171,7 @@ export {
   SESSION_WAKING,
   SessionTranscriptStore,
   USER_BAR,
+  activitySummary,
   awaitingAgentPhase,
   cacheTierLabel,
   chatTurnsToItems,
@@ -1808,11 +2200,13 @@ export {
   isFoldable,
   isToolActivity,
   isToolFold,
+  isWorkFold,
   lastLines,
   layOutItems,
   lifecycleText,
   oneLine,
   pendingToolCalls,
+  reasoningSummaryTitle,
   recordSlice,
   recordToItems,
   resultCostUsd,
@@ -1829,6 +2223,7 @@ export {
   statusActivityText,
   summarizeToolInput,
   tailLines,
+  toolActivities,
   toolResultText,
   toolRunMembers
 };