@ellipsis-dev/sdk 0.15.1 → 0.16.0

package/dist/chunk-RMPAMUAE.js

@@ -0,0 +1,208 @@
+// src/stream/index.ts
+var SESSION_STREAM_PROTOCOL_VERSION = 3;
+var WS_CLOSE_NORMAL = 1e3;
+var WS_CLOSE_GOING_AWAY = 1001;
+var WS_CLOSE_UNSUPPORTED_PROTOCOL_VERSION = 1002;
+var WS_CLOSE_NO_PROTOCOL = 1003;
+var WS_CLOSE_AUTH_FAILED = 1008;
+var WS_CLOSE_SERVER_ERROR = 1011;
+var WS_CLOSE_OVER_CAPACITY = 1013;
+function sessionStatusWord(session) {
+  return session.surface?.status ?? session.status;
+}
+var StreamUnavailableError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "StreamUnavailableError";
+  }
+};
+var StreamAuthError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "StreamAuthError";
+  }
+};
+function streamQuery(afterSeq) {
+  const base = `protocol=${SESSION_STREAM_PROTOCOL_VERSION}`;
+  return afterSeq > 0 ? `${base}&after_seq=${afterSeq}` : base;
+}
+var HEARTBEAT_TIMEOUT_MS = 45e3;
+var DEFAULT_MAX_RECONNECTS = 5;
+function classifyCloseCode(code) {
+  switch (code) {
+    case WS_CLOSE_NORMAL:
+      return "normal";
+    case WS_CLOSE_AUTH_FAILED:
+    case 4401:
+    // dashboard ticket door: bad/expired ticket
+    case 4403:
+      return "auth";
+    case WS_CLOSE_UNSUPPORTED_PROTOCOL_VERSION:
+    case WS_CLOSE_NO_PROTOCOL:
+      return "unsupported";
+    default:
+      return "retry";
+  }
+}
+function nextReconnectDelayMs(attempt) {
+  const base = 500;
+  const max = 8e3;
+  return Math.min(max, base * 2 ** Math.max(0, attempt - 1));
+}
+function decideReconnect(params) {
+  const { closeKind, everReceivedFrame, attempt, maxReconnects } = params;
+  if (closeKind === "auth") return { action: "fail-auth" };
+  if (closeKind === "unsupported") return { action: "fallback" };
+  const cap = everReceivedFrame ? maxReconnects : Math.min(2, maxReconnects);
+  if (attempt >= cap) return { action: "fallback" };
+  return { action: "reconnect", delayMs: nextReconnectDelayMs(attempt) };
+}
+function connectOnce(sock, emit, signal) {
+  return new Promise((resolve) => {
+    let settled = false;
+    let heartbeat;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      if (heartbeat) clearTimeout(heartbeat);
+      if (signal) signal.removeEventListener("abort", onAbort);
+      sock.close();
+      resolve(result);
+    };
+    const onAbort = () => finish({ kind: "aborted" });
+    const bumpHeartbeat = () => {
+      if (heartbeat) clearTimeout(heartbeat);
+      heartbeat = setTimeout(
+        () => finish({ kind: "error", err: new Error("heartbeat timeout") }),
+        HEARTBEAT_TIMEOUT_MS
+      );
+    };
+    if (signal) {
+      if (signal.aborted) {
+        finish({ kind: "aborted" });
+        return;
+      }
+      signal.addEventListener("abort", onAbort);
+    }
+    sock.onOpen(() => bumpHeartbeat());
+    sock.onMessage((data) => {
+      bumpHeartbeat();
+      let frame;
+      try {
+        frame = JSON.parse(data);
+      } catch {
+        return;
+      }
+      emit(frame);
+      if (frame.type === "done") {
+        finish({ kind: "done" });
+      } else if (frame.type === "error") {
+        finish({
+          kind: "frameError",
+          message: frame.message ?? "stream error"
+        });
+      }
+    });
+    sock.onClose((code) => finish({ kind: "closed", code }));
+    sock.onError((err) => finish({ kind: "error", err }));
+  });
+}
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        resolve();
+      },
+      { once: true }
+    );
+  });
+}
+async function streamSession(opts) {
+  const maxReconnects = opts.maxReconnects ?? DEFAULT_MAX_RECONNECTS;
+  let afterSeq = opts.afterSeq ?? 0;
+  let everReceivedFrame = false;
+  let attempt = 0;
+  let lastStatusWord = "";
+  let lastExitStatus = null;
+  const emit = (frame) => {
+    everReceivedFrame = true;
+    attempt = 0;
+    if (frame.type === "records_append") {
+      const records = frame.records;
+      for (const record of records) {
+        if (typeof record.feed_seq === "number") {
+          afterSeq = Math.max(afterSeq, record.feed_seq);
+        }
+      }
+    } else if (frame.type === "snapshot" || frame.type === "session") {
+      const session = frame.session;
+      lastStatusWord = sessionStatusWord(session);
+      lastExitStatus = session.exit_status ?? null;
+    }
+    opts.onFrame(frame);
+  };
+  for (; ; ) {
+    if (opts.signal?.aborted) return { type: "aborted" };
+    let res;
+    try {
+      const sock = await opts.openSocket({
+        sessionId: opts.sessionId,
+        afterSeq,
+        query: streamQuery(afterSeq)
+      });
+      res = await connectOnce(sock, emit, opts.signal);
+    } catch (err) {
+      res = {
+        kind: "error",
+        err: err instanceof Error ? err : new Error(String(err))
+      };
+    }
+    if (res.kind === "done") {
+      return {
+        type: "done",
+        status: lastStatusWord,
+        exitStatus: lastExitStatus
+      };
+    }
+    if (res.kind === "frameError")
+      return { type: "error", message: res.message };
+    if (res.kind === "aborted") return { type: "aborted" };
+    attempt++;
+    const decision = decideReconnect({
+      closeKind: res.kind === "closed" ? classifyCloseCode(res.code) : void 0,
+      everReceivedFrame,
+      attempt,
+      maxReconnects
+    });
+    if (decision.action === "fail-auth") {
+      throw new StreamAuthError("not authorized to stream this session");
+    }
+    if (decision.action === "fallback") {
+      const why = res.kind === "error" ? res.err.message : `stream closed (code ${res.code})`;
+      throw new StreamUnavailableError(why);
+    }
+    await sleep(decision.delayMs ?? 0, opts.signal);
+  }
+}
+
+export {
+  SESSION_STREAM_PROTOCOL_VERSION,
+  WS_CLOSE_NORMAL,
+  WS_CLOSE_GOING_AWAY,
+  WS_CLOSE_UNSUPPORTED_PROTOCOL_VERSION,
+  WS_CLOSE_NO_PROTOCOL,
+  WS_CLOSE_AUTH_FAILED,
+  WS_CLOSE_SERVER_ERROR,
+  WS_CLOSE_OVER_CAPACITY,
+  sessionStatusWord,
+  StreamUnavailableError,
+  StreamAuthError,
+  streamQuery,
+  classifyCloseCode,
+  nextReconnectDelayMs,
+  decideReconnect,
+  streamSession
+};

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { c as components } from './types-D9g-eZui.js';
-export { A as AgentConfigSource, a as AttributionType, B as BudgetSource, C as ClaudeSessionRecord, b as CodexEvent, d as CodexItem, e as CodexSessionRecord, f as CreateReviewRequest, D as DeltaFrame, g as DoneFrame, E as ErrorFrame, F as Finding, G as GithubAccountSnippet, h as GithubAccountType, H as Harness, i as HeartbeatFrame, L as LifecycleSessionRecord, P as ParentKind, j as PromptBlockedReason, R as RecordsAppendFrame, k as ResolvedReviewScope, l as Review, m as ReviewConfiguration, n as ReviewCounters, o as ReviewFinding, p as ReviewRequester, q as ReviewScope, r as ReviewScopeKind, s as ReviewStage, t as ReviewedCommit, u as ReviewsListResponse, S as SdkAssistantRecord, v as SdkContentBlock, w as SdkRateLimitRecord, x as SdkRecord, y as SdkResultRecord, z as SdkSystemRecord, I as SdkUserRecord, J as SendSessionMessageRequest, K as Session, M as SessionExecution, N as SessionExecutionsListResponse, O as SessionExitStatus, Q as SessionFrame, T as SessionLiveness, U as SessionMessage, V as SessionMessageResponse, W as SessionMessageStatus, X as SessionPr, Y as SessionPrompting, Z as SessionRecord, _ as SessionRecordsListResponse, $ as SessionResponse, a0 as SessionSource, a1 as SessionState, a2 as SessionStatus, a3 as SessionStreamFrame, a4 as SessionSurface, a5 as SessionsListResponse, a6 as SnapshotFrame, a7 as StreamFrame, a8 as TokensInfo, a9 as paths } from './types-D9g-eZui.js';
+import { c as components } from './types-DB1hOyQE.js';
+export { A as AgentConfigSource, a as AttributionType, B as BudgetSource, C as ClaudeSessionRecord, b as CodexEvent, d as CodexItem, e as CodexSessionRecord, f as CreateReviewRequest, D as DeltaFrame, g as DoneFrame, E as ErrorFrame, F as Finding, G as GithubAccountSnippet, h as GithubAccountType, H as Harness, i as HeartbeatFrame, L as LifecycleSessionRecord, P as ParentKind, j as PromptBlockedReason, R as RecordsAppendFrame, k as ResolvedReviewScope, l as Review, m as ReviewConfiguration, n as ReviewCounters, o as ReviewFinding, p as ReviewRequester, q as ReviewScope, r as ReviewScopeKind, s as ReviewStage, t as ReviewedCommit, u as ReviewsListResponse, S as SdkAssistantRecord, v as SdkContentBlock, w as SdkRateLimitRecord, x as SdkRecord, y as SdkResultRecord, z as SdkSystemRecord, I as SdkUserRecord, J as SendSessionMessageRequest, K as Session, M as SessionExecution, N as SessionExecutionsListResponse, O as SessionExitStatus, Q as SessionFrame, T as SessionGit, U as SessionLiveness, V as SessionMessage, W as SessionMessageResponse, X as SessionMessageStatus, Y as SessionPrompting, Z as SessionRecord, _ as SessionRecordsListResponse, $ as SessionResponse, a0 as SessionSource, a1 as SessionState, a2 as SessionStatus, a3 as SessionStreamFrame, a4 as SessionSurface, a5 as SessionsListResponse, a6 as SnapshotFrame, a7 as StreamFrame, a8 as TokensInfo, a9 as paths } from './types-DB1hOyQE.js';
 
 interface CursorResponse {
     has_more: boolean;

package/dist/store/index.d.ts

@@ -1,4 +1,4 @@
-import { Z as SessionRecord, aa as CodexFileChangeItem, b as CodexEvent, ab as CodexMcpToolCallItem, x as SdkRecord, K as Session, U as SessionMessage, a7 as StreamFrame } from '../types-D9g-eZui.js';
+import { Z as SessionRecord, aa as CodexFileChangeItem, b as CodexEvent, ab as CodexMcpToolCallItem, x as SdkRecord, K as Session, V as SessionMessage, a7 as StreamFrame } from '../types-DB1hOyQE.js';
 
 interface ChatToolNode {
     key: string;
@@ -42,9 +42,46 @@ interface ChatTurn {
     costUsd: number | null;
     tokens: number | null;
     resumed: boolean;
+    isError: boolean;
 }
 declare function groupRecordsToChatTurns(records: readonly SessionRecord[]): ChatTurn[];
 
+type RecordSlice = {
+    feed_seq: number;
+    source: string;
+    record_type: string;
+    payload: Record<string, unknown>;
+    session_message_id?: string | null;
+};
+declare function recordSlice(records: readonly SessionRecord[]): readonly RecordSlice[];
+declare function humanDuration(seconds: number): string;
+declare function sessionLogText(recordType: string, payload: Record<string, unknown>): string | null;
+declare function awaitingAgentPhase(records: readonly RecordSlice[]): 'boot' | 'turn' | null;
+declare function deliveredUnechoedSends(records: readonly RecordSlice[]): {
+    id: string;
+    body: string;
+    cancelled: boolean;
+}[];
+type SandboxLogKind = 'step' | 'output' | 'done' | 'failed';
+type SandboxLogLine = {
+    key: string;
+    kind: SandboxLogKind;
+    text: string;
+};
+type SandboxState = {
+    headline: string;
+    done: boolean;
+    readySeconds: number | null;
+    sandboxDone: boolean;
+    configName: string | null;
+    configCommitSha: string | null;
+    log: SandboxLogLine[];
+};
+declare function hookPhrase(step: string): string;
+declare function deriveSandboxState(records: readonly RecordSlice[], minFeedSeq: number): SandboxState | null;
+declare function sandboxSummary(sandbox: SandboxState | null): string;
+declare function lastLines(log: readonly SandboxLogLine[], max: number): SandboxLogLine[];
+
 declare function sandboxOutputStep(payload: Record<string, unknown>): string;
 declare function sandboxOutputLines(payload: Record<string, unknown>): string[];
 declare function sandboxOutputLine(payload: Record<string, unknown>): string | null;
@@ -104,6 +141,12 @@ interface SessionTranscriptSnapshot {
     lastEventAt: number | null;
     conversationOver: boolean;
 }
+declare function seedTranscriptStore(store: SessionTranscriptStore, seed: {
+    session: Session;
+    records: readonly SessionRecord[];
+    messages?: readonly SessionMessage[] | null;
+    earliestFeedSeq?: number | null;
+}): void;
 declare function emptySessionTranscriptSnapshot(): SessionTranscriptSnapshot;
 declare class SessionTranscriptStore {
     private snapshot;
@@ -122,4 +165,4 @@ declare class SessionTranscriptStore {
     ingest: (rawFrame: StreamFrame) => void;
 }
 
-export { type ChatNode, type ChatToolNode, type ChatTurn, type EventToItemsOptions, type ItemKind, type SessionTranscriptSnapshot, SessionTranscriptStore, StreamFrame, type TranscriptItem, cacheTierLabel, clampLines, codexChangedPaths, codexEventToItems, codexMcpToolName, collapseToolRuns, emptySessionTranscriptSnapshot, eventToItems, foldCosts, formatDuration, groupRecordsToChatTurns, isConnectVisibleRecord, isConversationOver, lifecycleText, oneLine, pendingToolCalls, recordToItems, resultCostUsd, sandboxOutputLine, sandboxOutputLines, sandboxOutputStep, sandboxPhaseLabel, statusActivityText, summarizeToolInput, toolResultText };
+export { type ChatNode, type ChatToolNode, type ChatTurn, type EventToItemsOptions, type ItemKind, type RecordSlice, type SandboxLogKind, type SandboxLogLine, type SandboxState, type SessionTranscriptSnapshot, SessionTranscriptStore, StreamFrame, type TranscriptItem, awaitingAgentPhase, cacheTierLabel, clampLines, codexChangedPaths, codexEventToItems, codexMcpToolName, collapseToolRuns, deliveredUnechoedSends, deriveSandboxState, emptySessionTranscriptSnapshot, eventToItems, foldCosts, formatDuration, groupRecordsToChatTurns, hookPhrase, humanDuration, isConnectVisibleRecord, isConversationOver, lastLines, lifecycleText, oneLine, pendingToolCalls, recordSlice, recordToItems, resultCostUsd, sandboxOutputLine, sandboxOutputLines, sandboxOutputStep, sandboxPhaseLabel, sandboxSummary, seedTranscriptStore, sessionLogText, statusActivityText, summarizeToolInput, toolResultText };

package/dist/store/index.js

@@ -1,3 +1,7 @@
+import {
+  SESSION_STREAM_PROTOCOL_VERSION
+} from "../chunk-RMPAMUAE.js";
+
 // src/store/lifecycle.ts
 function sandboxOutputStep(payload) {
   if (typeof payload.step === "string" && payload.step) return payload.step;
@@ -483,7 +487,8 @@ function groupRecordsToChatTurns(records) {
         durationMs: null,
         costUsd: null,
         tokens: null,
-        resumed: pendingResume
+        resumed: pendingResume,
+        isError: false
       });
       pendingResume = false;
       openIdx = turns.length - 1;
@@ -549,16 +554,18 @@ function groupRecordsToChatTurns(records) {
         durationMs: null,
         costUsd: null,
         tokens: null,
-        resumed: false
+        resumed: false,
+        isError: false
       });
       continue;
     }
     if (record.record_format === "codex_jsonl@1") {
       codexEventIntoTurns(record, record.payload, {
         openAgentTurn,
-        closeTurn: (completedAt) => {
+        closeTurn: (completedAt, isError) => {
           if (openIdx >= 0) {
             turns[openIdx].completedAt = completedAt;
+            if (isError) turns[openIdx].isError = true;
             openIdx = -1;
           }
         },
@@ -581,6 +588,7 @@ function groupRecordsToChatTurns(records) {
         if (typeof data.cost_usd === "number") {
           turns[openIdx].costUsd = data.cost_usd;
         }
+        if (data.is_error) turns[openIdx].isError = true;
         openIdx = -1;
       }
       continue;
@@ -592,6 +600,7 @@ function groupRecordsToChatTurns(records) {
           openIdx = -1;
           turns.push({
             resumed: false,
+            isError: false,
             key: nextKey(record.id),
             role: "user",
             nodes: [
@@ -672,7 +681,7 @@ function groupRecordsToChatTurns(records) {
 }
 function codexEventIntoTurns(record, event, ops) {
   if (event.type === "turn.completed" || event.type === "turn.failed") {
-    ops.closeTurn(record.created_at);
+    ops.closeTurn(record.created_at, event.type === "turn.failed");
     return;
   }
   if (event.type === "error") {
@@ -770,6 +779,289 @@ function codexEventIntoTurns(record, event, ops) {
   }
 }
 
+// src/store/derive.ts
+function recordSlice(records) {
+  return records;
+}
+function humanDuration(seconds) {
+  const clamped = Math.max(0, seconds);
+  if (clamped === 0) return "0s";
+  if (clamped < 1) return `${Math.round(clamped * 1e3)}ms`;
+  if (clamped < 5) {
+    const s2 = clamped.toFixed(1);
+    return s2.endsWith(".0") ? `${Math.round(clamped)}s` : `${s2}s`;
+  }
+  const total = Math.round(clamped);
+  const h = Math.floor(total / 3600);
+  const m = Math.floor(total % 3600 / 60);
+  const s = total % 60;
+  const bits = [];
+  if (h > 0) bits.push(`${h}h`);
+  if (m > 0) bits.push(`${m}m`);
+  if (s > 0 || bits.length === 0) bits.push(`${s}s`);
+  return bits.join(" ");
+}
+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 ? "Waking the session\u2026" : null;
+    }
+    case "session_retrying":
+      return typeof p.reason === "string" && p.reason ? `Retrying \xB7 ${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 ? ` \xB7 ${p.reason}` : "";
+      return `Session cancelled${reason}`;
+    }
+    default:
+      return null;
+  }
+}
+function awaitingAgentPhase(records) {
+  let inFlight = false;
+  let sawAgent = false;
+  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") {
+        inFlight = false;
+        sawAgent = false;
+      }
+    }
+  }
+  if (!inFlight) return null;
+  return sawAgent ? "turn" : "boot";
+}
+function deliveredUnechoedSends(records) {
+  const received = /* @__PURE__ */ new Map();
+  const delivered = /* @__PURE__ */ new Map();
+  const failedTurns = /* @__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);
+      continue;
+    }
+    const id = typeof r.payload.message_id === "string" ? r.payload.message_id : null;
+    if (!id) continue;
+    if (r.record_type === "message_received") {
+      if (!received.has(id))
+        received.set(
+          id,
+          typeof r.payload.body === "string" ? r.payload.body : ""
+        );
+    } else if (r.record_type === "message_delivered") {
+      delivered.set(
+        id,
+        typeof r.payload.turn_id === "string" ? r.payload.turn_id : ""
+      );
+    } else if (r.record_type === "message_requeued") delivered.delete(id);
+  }
+  const out = [];
+  for (const [id, body] of received) {
+    const turnId = delivered.get(id);
+    if (turnId === void 0 || echoed.has(id)) continue;
+    out.push({ id, body, cancelled: failedTurns.has(turnId) });
+  }
+  return out;
+}
+function msLabel(ms) {
+  if (typeof ms !== "number" || !isFinite(ms) || ms < 0) return null;
+  return humanDuration(ms / 1e3);
+}
+function imageStepLabel(step) {
+  switch (step) {
+    case "build":
+      return "Building image";
+    case "container":
+      return "Starting container";
+    case "smoke":
+      return "Smoke check";
+    default:
+      return step;
+  }
+}
+function hookPhrase(step) {
+  switch (step) {
+    case "setup":
+    case "image.setup":
+      return "Building image";
+    case "clone":
+      return "Fetching repositories";
+    case "post_start":
+      return "Post-start setup";
+    case "post_clone":
+      return "Post-clone setup";
+    default:
+      return step;
+  }
+}
+function stepLabel(phase, step) {
+  if (step) {
+    if (phase === "hooks") return hookPhrase(step);
+    if (phase === "image") return imageStepLabel(step);
+    return step;
+  }
+  return sandboxPhaseLabel(phase);
+}
+function deriveSandboxState(records, minFeedSeq) {
+  let seen = false;
+  let headline = "Starting cloud agent\u2026";
+  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 };
+    log.push(entry);
+    return entry;
+  };
+  const reset = () => {
+    log = [];
+    open = /* @__PURE__ */ new Map();
+    sandboxDone = false;
+  };
+  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 cloud agent\u2026" : text;
+        done = false;
+        readySeconds = null;
+        reset();
+        break;
+      }
+      case "session_resumed":
+      case "session_idle": {
+        seen = true;
+        done = true;
+        break;
+      }
+      case "sandbox_starting": {
+        seen = true;
+        reset();
+        push(record, "step", "Starting sandbox\u2026");
+        break;
+      }
+      case "sandbox_phase": {
+        seen = true;
+        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;
+        const label = stepLabel(phase, step);
+        if (p.status === "completed" || p.status === "failed") {
+          const detail = p.detail && typeof p.detail === "object" ? p.detail : {};
+          const tier = cacheTierLabel(detail.cache_tier);
+          const dur = msLabel(p.duration_ms);
+          const failed = p.status === "failed";
+          const base = failed ? `${label} failed` : label;
+          const text = [
+            base,
+            ...tier ? [tier] : [],
+            ...dur ? [dur] : []
+          ].join(" \xB7 ");
+          const line = open.get(key);
+          if (line) {
+            line.kind = failed ? "failed" : "done";
+            line.text = text;
+            open.delete(key);
+          } else {
+            push(record, failed ? "failed" : "done", text);
+          }
+        } 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);
+        break;
+      }
+      case "sandbox_ready": {
+        seen = true;
+        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);
+        push(
+          record,
+          "done",
+          [
+            "Sandbox ready",
+            ...tier ? [tier] : [],
+            ...totalSeconds > 0 ? [humanDuration(totalSeconds)] : []
+          ].join(" \xB7 ")
+        );
+        sandboxDone = true;
+        readySeconds = totalSeconds > 0 ? totalSeconds : null;
+        done = true;
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  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 sandboxSummary(sandbox) {
+  const seconds = sandbox?.readySeconds ?? null;
+  return seconds ? `Sandbox ready in ${humanDuration(seconds)}` : "Sandbox started";
+}
+function lastLines(log, max) {
+  return log.length <= max ? [...log] : log.slice(log.length - max);
+}
+
 // src/store/index.ts
 var TERMINAL_SESSION_STATUSES = /* @__PURE__ */ new Set([
   "completed",
@@ -783,6 +1075,18 @@ function isConversationOver(session) {
   }
   return TERMINAL_SESSION_STATUSES.has(session.status);
 }
+function seedTranscriptStore(store, seed) {
+  store.ingest({
+    type: "snapshot",
+    protocol: SESSION_STREAM_PROTOCOL_VERSION,
+    earliest_feed_seq: seed.earliestFeedSeq ?? null,
+    session: seed.session,
+    messages: [...seed.messages ?? []]
+  });
+  const ordered = [...seed.records].sort((a, b) => a.feed_seq - b.feed_seq);
+  if (ordered.length)
+    store.ingest({ type: "records_append", records: ordered });
+}
 var EMPTY_SNAPSHOT = {
   session: null,
   records: [],
@@ -963,28 +1267,38 @@ var SessionTranscriptStore = class {
 };
 export {
   SessionTranscriptStore,
+  awaitingAgentPhase,
   cacheTierLabel,
   clampLines,
   codexChangedPaths,
   codexEventToItems,
   codexMcpToolName,
   collapseToolRuns,
+  deliveredUnechoedSends,
+  deriveSandboxState,
   emptySessionTranscriptSnapshot,
   eventToItems,
   foldCosts,
   formatDuration,
   groupRecordsToChatTurns,
+  hookPhrase,
+  humanDuration,
   isConnectVisibleRecord,
   isConversationOver,
+  lastLines,
   lifecycleText,
   oneLine,
   pendingToolCalls,
+  recordSlice,
   recordToItems,
   resultCostUsd,
   sandboxOutputLine,
   sandboxOutputLines,
   sandboxOutputStep,
   sandboxPhaseLabel,
+  sandboxSummary,
+  seedTranscriptStore,
+  sessionLogText,
   statusActivityText,
   summarizeToolInput,
   toolResultText