@opengeni/react 1.0.1 → 1.0.2-canary.37191796234001

package/dist/{chunk-6KLX2RH5.js → chunk-H2NJQORO.js}

@@ -1,29 +1,20 @@
+import {
+  mcpToolLeaf,
+  toolMatchesLeaf
+} from "./chunk-ERGYJIBB.js";
 import {
   CREDIT_EXHAUSTION_MESSAGE,
-  humanizeFailureReason,
   isCreditExhaustion,
+  presentFailure,
   tryParseJson
-} from "./chunk-LAKLF4PA.js";
-
-// src/timeline/tool-display-name.ts
-function mcpToolLeaf(name) {
-  const boundary = name.indexOf("__");
-  return boundary >= 0 ? name.slice(boundary + 2) : name;
-}
-function toolMatchesLeaf(wireName, leaf) {
-  return wireName === leaf || wireName.endsWith(`__${leaf}`);
-}
-function toolDisplayName(name) {
-  const phrase = mcpToolLeaf(name).replace(/[_-]+/g, " ").trim();
-  if (!phrase) {
-    return name;
-  }
-  return phrase.charAt(0).toUpperCase() + phrase.slice(1);
-}
+} from "./chunk-UTRTG6LH.js";
 
 // src/timeline/projection.ts
 import {
-  parseMediaGenerationResult
+  parseMediaGenerationResult,
+  parseToolDisplayMetadata,
+  EMPTY_FINAL_REPLY_NOTICE,
+  turnCompletedWithEmptyFinalReply
 } from "@opengeni/sdk";
 
 // src/timeline/fleet-decision-projection.ts
@@ -34,6 +25,7 @@ var FLEET_ACTUAL_REASONS = [
   "rotation",
   "active",
   "all_capped",
+  "allocator_disabled",
   "none"
 ];
 var FLEET_SHADOW_OUTCOMES = ["selected", "paced", "none"];
@@ -251,7 +243,7 @@ function fleetComparisonIsConsistent(comparison, actualOutcome, actualCandidateK
   return comparableActualOutcome !== "selected" || actualCandidateKey === shadowCandidateKey;
 }
 function fleetDecisionSemanticsAreConsistent(input) {
-  const actualConsistent = input.actualOutcome === "selected" ? ["lease_reused", "pin", "rotation", "active"].includes(input.actualReason) : input.actualOutcome === "waiting" ? input.actualReason === "all_capped" : input.actualReason === "none";
+  const actualConsistent = input.actualOutcome === "selected" ? ["lease_reused", "pin", "rotation", "active"].includes(input.actualReason) : input.actualOutcome === "waiting" ? ["all_capped", "allocator_disabled"].includes(input.actualReason) : input.actualReason === "none";
   const shadowConsistent = input.shadowOutcome === "selected" ? ["fenced_in_flight", "best_score", "affinity_best", "hysteresis_hold"].includes(
     input.shadowReason
   ) : input.shadowOutcome === "paced" ? input.shadowReason === "admission_paced" : ["fenced_candidate_missing", "no_eligible_candidate", "overlay_isolated_empty"].includes(
@@ -265,6 +257,13 @@ function asRecord(value) {
 }
 
 // src/timeline/projection.ts
+import {
+  allowanceExhaustedMessage,
+  parseAllowanceExhaustedRefusal
+} from "@opengeni/sdk/allowance-refusal";
+function isTimelineUserQuestion(event) {
+  return event.type === "user.message" && workerCompletionPayload(asRecord2(event.payload).childCompletion) === null;
+}
 var WORKER_SPAWN_TOOL = "session_create";
 var WORKER_MESSAGE_TOOL = "session_send_message";
 var WORKER_FAILURE_CODE_MAX_LENGTH = 128;
@@ -306,18 +305,153 @@ function timelineAnnotationToolOutputText(output) {
   const text = (marker >= 0 ? raw.slice(marker + "\nOutput:\n".length) : raw.startsWith("Output:\n") ? raw.slice("Output:\n".length) : raw).replace(TIMELINE_ANNOTATION_ANSI_SEQUENCE, "");
   return text.length > 0 ? text : null;
 }
-function buildTimeline(events) {
+function buildTimeline(events, options = {}) {
   const items = [];
+  const allowanceNotices = /* @__PURE__ */ new Set();
+  const allowanceNotice = (event, turnId) => {
+    const refusal = parseAllowanceExhaustedRefusal(event.payload);
+    if (!refusal) return null;
+    const text = allowanceExhaustedMessage(refusal);
+    const key = JSON.stringify([
+      turnId,
+      event.turnAttemptId,
+      startupRecoveryRevisionByTurn.get(turnId ?? "") ?? 0,
+      refusal.scope,
+      refusal.subjectId,
+      refusal.resetsAt
+    ]);
+    if (!allowanceNotices.has(key)) {
+      allowanceNotices.add(key);
+      items.push({
+        kind: "notice",
+        id: `${event.id}-allowance`,
+        tone: "failed",
+        text,
+        // The canonical sentence replaces upstream prose, so a host renderer
+        // reading `message` never shows a wrapper's private wording.
+        allowance: { ...refusal, message: text },
+        occurredAt: event.occurredAt
+      });
+    }
+    return text;
+  };
   const prescan = prescanTurnAnchors(events);
   const ordered = orderTimelineEvents(events, prescan);
+  let completeHistoryPrefix = options.partialStart !== true;
+  const knownMessagePrefixTurns = /* @__PURE__ */ new Set();
+  const incompleteMessageKeys = /* @__PURE__ */ new Set();
+  const pendingWaitOutcomeByTurn = /* @__PURE__ */ new Map();
+  const latestAgentResponseByTurn = /* @__PURE__ */ new Map();
+  const identifiedMessages = /* @__PURE__ */ new Map();
+  const humanInputRequests = humanInputRequestsById(events);
+  const humanInputToolCallIds = new Set(
+    [...humanInputRequests.values()].map((request) => stringValue(request.toolCallId)).filter(Boolean)
+  );
+  const workerSessions = /* @__PURE__ */ new Set();
+  const pendingWorkerSessions = /* @__PURE__ */ new Set();
+  let openWaitNotice = null;
+  const presentationWaits = /* @__PURE__ */ new Map();
+  const presentationFailures = /* @__PURE__ */ new Map();
+  let presentationTurnId = null;
+  const rememberPresentationWait = (item, turnId) => {
+    const key = turnId ?? presentationTurnId;
+    const waits = presentationWaits.get(key) ?? [];
+    waits.push(item);
+    presentationWaits.set(key, waits);
+    items.push(item);
+  };
+  const resolvePresentationWait = (event, turnId) => {
+    if (event.duplicateOfEventId || event.turnAssociation && event.turnAssociation !== "current")
+      return;
+    const key = turnId ?? presentationTurnId;
+    for (const item of presentationWaits.get(key) ?? []) item.resolvedAt = event.occurredAt;
+    presentationWaits.delete(key);
+  };
+  const queuedAtByTurn = /* @__PURE__ */ new Map();
+  const startupRecoveryRevisionByTurn = /* @__PURE__ */ new Map();
+  const startupPhases = /* @__PURE__ */ new Map();
+  let startupEvent;
+  let startupTurnId = null;
+  let startupAttemptId = null;
+  let startupRecoveryRevision = 0;
+  const settleStartupPhase = (phase, status, duration, outcome, mode = 0, explicitStartedAt, explicitId, blockedReason) => {
+    const key = `${startupTurnId}:${phase}`;
+    const priorState = startupPhases.get(key);
+    const prior = priorState?.[0];
+    const comparedByAttempt = priorState?.[1] && startupAttemptId;
+    const sameAttempt = comparedByAttempt ? priorState[1] === startupAttemptId : (priorState?.[2] ?? 0) === startupRecoveryRevision;
+    const open = prior?.status === "running" && sameAttempt ? prior : void 0;
+    const replacesPriorAttempt = prior !== void 0 && (comparedByAttempt ? !sameAttempt : startupRecoveryRevision > (priorState?.[2] ?? 0));
+    if (replacesPriorAttempt && prior.status === "complete") return;
+    if (mode === 2 && prior && !replacesPriorAttempt) return;
+    if (mode === 1 && !open) return;
+    if (!replacesPriorAttempt && status !== "running" && open) {
+      open.status = status;
+      open.completedAt = startupEvent.occurredAt;
+      open.durationMs = duration === null ? elapsedDurationMs(open.startedAt, startupEvent.occurredAt) : Math.max(0, duration);
+      open.outcome = outcome ?? open.outcome;
+      open.blockedReason = blockedReason;
+      return;
+    }
+    const running = status === "running";
+    const durationMs = running || duration === null ? null : Math.max(0, duration);
+    const completedEpoch = Date.parse(startupEvent.occurredAt);
+    const startedAt = explicitStartedAt ?? (!running && durationMs !== null && Number.isFinite(completedEpoch) ? new Date(completedEpoch - durationMs).toISOString() : startupEvent.occurredAt);
+    if (replacesPriorAttempt) {
+      Object.assign(prior, {
+        id: explicitId ?? startupEvent.id,
+        status,
+        startedAt,
+        completedAt: running ? null : startupEvent.occurredAt,
+        durationMs,
+        outcome,
+        blockedReason,
+        occurredAt: startedAt
+      });
+      startupPhases.set(key, [prior, startupAttemptId, startupRecoveryRevision]);
+      return;
+    }
+    const item = {
+      kind: "startup-phase",
+      id: explicitId ?? startupEvent.id,
+      turnId: startupTurnId,
+      phase,
+      status,
+      startedAt,
+      completedAt: running ? null : startupEvent.occurredAt,
+      durationMs,
+      outcome,
+      blockedReason,
+      occurredAt: startedAt
+    };
+    items.push(item);
+    startupPhases.set(key, [item, startupAttemptId, startupRecoveryRevision]);
+  };
   const last = () => items[items.length - 1];
+  const rememberAgentResponse = (turnId, item, completed) => {
+    latestAgentResponseByTurn.set(turnId, { item, completed });
+  };
+  const takePendingWaitOutcome = (turnId) => {
+    const outcome = pendingWaitOutcomeByTurn.get(turnId);
+    pendingWaitOutcomeByTurn.delete(turnId);
+    return outcome;
+  };
+  const takeAgentResponse = (turnId) => {
+    const response = latestAgentResponseByTurn.get(turnId);
+    latestAgentResponseByTurn.delete(turnId);
+    return response;
+  };
+  const clearUnscopedTerminalTracking = () => {
+    latestAgentResponseByTurn.delete(null);
+    pendingWaitOutcomeByTurn.delete(null);
+  };
   const closeStreamingTail = () => {
     const open = last();
     if ((open?.kind === "agent-message" || open?.kind === "reasoning") && open.streaming) {
       open.streaming = false;
     }
   };
-  const finalizeOpen = (turnId, disposition = "complete") => {
+  const finalizeOpen = (turnId, disposition = "complete", completedAt) => {
     for (const item of items) {
       if (turnId !== void 0 && "turnId" in item && item.turnId && turnId && item.turnId !== turnId) {
         continue;
@@ -331,16 +465,67 @@ function buildTimeline(events) {
       if (item.kind === "sandbox" && item.status === "running") {
         item.status = disposition;
       }
+      if (item.kind === "startup-phase" && item.status === "running") {
+        item.status = disposition;
+        if (completedAt) {
+          item.completedAt = completedAt;
+          item.durationMs = elapsedDurationMs(item.startedAt, completedAt);
+        }
+      }
     }
   };
   for (const event of ordered) {
     const payload = asRecord2(event.payload);
     const turnId = event.turnId ?? null;
+    if (turnId && (event.type === "turn.started" || presentationTurnId === null && isAgentActivityEvent(event.type))) {
+      presentationTurnId = turnId;
+    }
+    if (openWaitNotice && (event.type === "user.message" || event.type === "system.update.delivered" || event.type === "turn.started" || event.type === "session.control.paused" || event.type === "session.status.changed" && (payload.status === "cancelled" || payload.status === "failed"))) {
+      openWaitNotice.waitEndedAt = event.occurredAt;
+      openWaitNotice = null;
+    }
+    if (event.type === "session.created") {
+      completeHistoryPrefix = true;
+    } else if (event.type === "turn.started" || event.type === "user.message" && payload.delivery !== "steer" && payload.routing !== "accepted_for_steering") {
+      knownMessagePrefixTurns.add(turnId);
+    }
+    startupEvent = event;
+    startupTurnId = turnId;
+    startupAttemptId = (typeof event.turnAttemptId === "string" ? event.turnAttemptId : null) ?? stringValue(payload.attemptId);
+    startupRecoveryRevision = turnId ? startupRecoveryRevisionByTurn.get(turnId) ?? 0 : 0;
+    const setupPhase = event.type.startsWith("rig.setup.") ? "rig" : event.type.startsWith("turn.startup.phase.") ? startupPhaseFromPayload(payload.phase) : null;
+    const setupStatus = event.type.endsWith(".started") ? "running" : event.type.endsWith(".failed") ? "failed" : event.type.endsWith(".completed") || event.type === "rig.setup.skipped" ? "complete" : null;
+    if (setupPhase && setupStatus) {
+      closeStreamingTail();
+      let blockedReason;
+      if (setupPhase === "model_preparation" && setupStatus === "failed") {
+        blockedReason = startupLifecycleWaitReason(payload);
+        const sandbox = startupPhases.get(`${startupTurnId}:sandbox`);
+        const sameAttempt = sandbox?.[1] || startupAttemptId ? Boolean(startupAttemptId && sandbox?.[1] === startupAttemptId) : sandbox?.[2] === startupRecoveryRevision;
+        if (!blockedReason && payload.expectedTransition === void 0 && payload.failureCode === void 0 && payload.failureStage === void 0 && payload.failureCategory === void 0 && payload.error === void 0 && startupTurnId && sameAttempt && sandbox?.[0].status === "cancelled") {
+          blockedReason = sandbox[0].blockedReason;
+        }
+      }
+      settleStartupPhase(
+        setupPhase,
+        blockedReason ? "cancelled" : setupStatus,
+        numberOrNull(payload.durationMs),
+        event.type === "rig.setup.skipped" ? "skipped" : null,
+        0,
+        void 0,
+        void 0,
+        blockedReason
+      );
+      continue;
+    }
     switch (event.type) {
       case "user.message": {
+        clearUnscopedTerminalTracking();
         closeStreamingTail();
         const childCompletion = workerCompletionPayload(payload.childCompletion);
         if (childCompletion) {
+          workerSessions.add(childCompletion.childSessionId);
+          pendingWorkerSessions.delete(childCompletion.childSessionId);
           items.push({
             kind: "worker-completion",
             id: event.id,
@@ -360,6 +545,7 @@ function buildTimeline(events) {
         items.push({
           kind: "user-message",
           id: event.id,
+          ...event.clientEventId ? { reconciliationKey: `user-message:${event.clientEventId}` } : {},
           text: voiceMessage?.text ?? stringValue(payload.text),
           annotations: timelineAnnotations(payload.annotations),
           annotationSource: {
@@ -377,10 +563,26 @@ function buildTimeline(events) {
         });
         break;
       }
+      case "user.humanInputResponse": {
+        const item = humanInputItemFromResponse(event, payload, humanInputRequests);
+        if (!item) break;
+        closeStreamingTail();
+        items.push(item);
+        break;
+      }
       case "system.update.delivered": {
         const inputs = machineInputMembers(payload.members);
+        for (const input of inputs) {
+          if (input.kind === "child_terminal_result") {
+            workerSessions.add(input.sourceId);
+            pendingWorkerSessions.delete(input.sourceId);
+          }
+        }
         if (inputs.length === 0) break;
-        if (inputs.every((member) => member.kind === "goal_continuation")) {
+        const visibleInputs = inputs.filter(
+          (member) => member.kind !== "background_command_result"
+        );
+        if (visibleInputs.length === 0 || visibleInputs.every((member) => member.kind === "goal_continuation")) {
           break;
         }
         closeStreamingTail();
@@ -388,7 +590,7 @@ function buildTimeline(events) {
           kind: "machine-input-batch",
           id: event.id,
           turnId,
-          members: inputs,
+          members: visibleInputs,
           occurredAt: event.occurredAt
         });
         break;
@@ -398,26 +600,61 @@ function buildTimeline(events) {
         if (!text) {
           break;
         }
+        const messageId = stringValue(payload.messageId);
+        const messageKey = messageId ? JSON.stringify([turnId, messageId]) : null;
+        const phase = assistantMessagePhase(payload.phase);
+        if (!completeHistoryPrefix && !knownMessagePrefixTurns.has(turnId) || messageKey && incompleteMessageKeys.has(messageKey)) {
+          if (messageKey) incompleteMessageKeys.add(messageKey);
+          break;
+        }
+        const identified = messageKey ? identifiedMessages.get(messageKey) : void 0;
+        if (identified) {
+          if (identified.annotationSource?.eventType !== "agent.message.completed") {
+            identified.text += text;
+            if (phase && !identified.phase) identified.phase = phase;
+            rememberAgentResponse(turnId, identified, false);
+          }
+          break;
+        }
         const open = last();
-        if (open?.kind === "agent-message" && open.streaming && open.turnId === turnId) {
+        if (!messageKey && open?.kind === "tool-call" && open.status === "running") {
+          const previous = latestAgentResponseByTurn.get(turnId);
+          const previousIndex = previous ? items.indexOf(previous.item) : -1;
+          if (previous && !previous.completed && previousIndex >= 0 && items.slice(previousIndex + 1).every(
+            (item2) => item2.kind === "tool-call" && item2.turnId === turnId && item2.status === "running"
+          )) {
+            previous.item.text += text;
+            break;
+          }
+        }
+        if (!messageKey && open?.kind === "agent-message" && open.streaming && open.turnId === turnId) {
           open.text += text;
+          rememberAgentResponse(turnId, open, false);
           break;
         }
         closeStreamingTail();
-        items.push({
+        const item = {
           kind: "agent-message",
           id: event.id,
           turnId,
           text,
+          ...phase ? { phase } : {},
           streaming: true,
           occurredAt: event.occurredAt
-        });
+        };
+        items.push(item);
+        if (messageKey) identifiedMessages.set(messageKey, item);
+        rememberAgentResponse(turnId, item, false);
         break;
       }
       case "agent.message.completed": {
+        knownMessagePrefixTurns.add(turnId);
         const text = stringValue(payload.text);
-        let openIndex = -1;
-        for (let index = items.length - 1; index >= 0; index -= 1) {
+        const messageId = stringValue(payload.messageId);
+        const messageKey = messageId ? JSON.stringify([turnId, messageId]) : null;
+        const phase = assistantMessagePhase(payload.phase);
+        let openIndex = messageKey ? items.indexOf(identifiedMessages.get(messageKey)) : -1;
+        for (let index = messageKey ? -1 : items.length - 1; index >= 0; index -= 1) {
           const candidate2 = items[index];
           if (candidate2?.kind === "agent-message" && candidate2.turnId === turnId) {
             openIndex = index;
@@ -426,10 +663,14 @@ function buildTimeline(events) {
         }
         const candidate = openIndex >= 0 ? items[openIndex] : void 0;
         const open = candidate?.kind === "agent-message" ? candidate : void 0;
-        if (open && (open.streaming || !open.text || text === open.text || text.startsWith(open.text))) {
-          if (!open.text || text && text.startsWith(open.text)) {
+        if (open && (messageKey || open.streaming || !open.text || text === open.text || text.startsWith(open.text))) {
+          if (!open.text || text && (messageKey || text.startsWith(open.text))) {
             open.text = text || open.text;
           }
+          if (phase) open.phase = phase;
+          if (open.startedAt === void 0 && open.occurredAt !== event.occurredAt) {
+            open.startedAt = open.occurredAt;
+          }
           open.streaming = false;
           open.occurredAt = event.occurredAt;
           open.annotationSource = text && open.text === text ? {
@@ -444,14 +685,16 @@ function buildTimeline(events) {
             items.splice(openIndex, 1);
             items.push(open);
           }
+          rememberAgentResponse(turnId, open, true);
           break;
         }
         if (text) {
-          items.push({
+          const item = {
             kind: "agent-message",
             id: event.id,
             turnId,
             text,
+            ...phase ? { phase } : {},
             streaming: false,
             occurredAt: event.occurredAt,
             annotationSource: {
@@ -462,7 +705,10 @@ function buildTimeline(events) {
               turnId,
               text
             }
-          });
+          };
+          items.push(item);
+          if (messageKey) identifiedMessages.set(messageKey, item);
+          rememberAgentResponse(turnId, item, true);
         }
         break;
       }
@@ -489,9 +735,13 @@ function buildTimeline(events) {
       }
       case "agent.toolCall.created": {
         const name = typeof payload.name === "string" ? payload.name : "tool";
+        const display = parseToolDisplayMetadata(payload.display);
         const callId = typeof payload.id === "string" ? payload.id : null;
         const args = payload.arguments ?? null;
         closeStreamingTail();
+        if (callId && humanInputToolCallIds.has(callId)) {
+          break;
+        }
         if (toolMatchesLeaf(name, WORKER_SPAWN_TOOL) || toolMatchesLeaf(name, WORKER_MESSAGE_TOOL)) {
           items.push({
             kind: "worker",
@@ -515,6 +765,7 @@ function buildTimeline(events) {
             (item) => item.kind === "tool-call" && item.callId === callId
           );
           if (existing) {
+            if (display) existing.display = display;
             if (args != null) {
               existing.arguments = args;
             }
@@ -531,6 +782,7 @@ function buildTimeline(events) {
           turnId,
           callId,
           name,
+          ...display ? { display } : {},
           arguments: args,
           output: void 0,
           truncation: null,
@@ -548,10 +800,17 @@ function buildTimeline(events) {
         if (!target) {
           break;
         }
+        resolvePresentationWait(event, turnId ?? target.turnId);
         if (target.kind === "worker") {
           target.status = isErrorOutput(payload) ? "failed" : "complete";
           target.workerSessionId = target.workerSessionId ?? extractSessionRef(payload.output);
           target.failure = target.status === "failed" ? workerFailure(payload.output) : null;
+          if (target.status === "complete" && target.workerSessionId) {
+            if (target.action === "spawn") workerSessions.add(target.workerSessionId);
+            if (workerSessions.has(target.workerSessionId)) {
+              pendingWorkerSessions.add(target.workerSessionId);
+            }
+          }
           break;
         }
         const truncation = toolCallTruncation(payload);
@@ -574,20 +833,59 @@ function buildTimeline(events) {
         }
         break;
       }
+      case "turn.queued": {
+        const queuedTurnId = turnId ?? (typeof payload.turnId === "string" ? payload.turnId : null);
+        if (queuedTurnId) {
+          queuedAtByTurn.set(queuedTurnId, event.occurredAt);
+        }
+        break;
+      }
+      case "turn.started": {
+        if (turnId) clearUnscopedTerminalTracking();
+        if (!turnId) break;
+        const queuedAt = queuedAtByTurn.get(turnId);
+        if (!queuedAt) break;
+        queuedAtByTurn.delete(turnId);
+        closeStreamingTail();
+        settleStartupPhase(
+          "queue",
+          "complete",
+          elapsedDurationMs(queuedAt, event.occurredAt),
+          null,
+          0,
+          queuedAt,
+          `${event.id}-queue`
+        );
+        break;
+      }
       case "sandbox.operation.started":
       case "sandbox.operation.completed":
       case "sandbox.operation.failed": {
         const name = typeof payload.name === "string" ? payload.name : "sandbox";
-        const status = event.type.endsWith(".failed") ? "failed" : event.type.endsWith(".completed") ? "complete" : "running";
-        if ((name === "repository-clone" || name === "file-resource-download") && status !== "failed") {
+        const status = event.type.endsWith(".failed") ? payload.expectedTransition === true ? "cancelled" : "failed" : event.type.endsWith(".completed") ? "complete" : "running";
+        const origin = payload.origin === "created" || payload.origin === "restored" || payload.origin === "resumed" ? payload.origin : null;
+        const startupPhase = startupPhaseForSandboxOperation(name);
+        if (startupPhase) {
+          closeStreamingTail();
+          settleStartupPhase(
+            startupPhase,
+            status,
+            numberOrNull(payload.durationMs),
+            origin,
+            0,
+            void 0,
+            void 0,
+            status === "cancelled" ? startupLifecycleWaitReason(payload) ?? (payload.failureCode === "rotation_in_progress" ? "rotation_in_progress" : void 0) : void 0
+          );
+          break;
+        }
+        if ((name === "repository-clone" || name === "file-resource-download" || name === "optional-repository-access") && status !== "failed") {
           break;
         }
         const existing = findOpenSandbox(items, name);
         if (existing && status !== "running") {
           existing.status = status;
-          if (payload.origin === "created" || payload.origin === "restored" || payload.origin === "resumed") {
-            existing.origin = payload.origin;
-          }
+          if (origin) existing.origin = origin;
           const message = failureMessage(payload);
           if (message) {
             existing.output = existing.output ? `${existing.output}
@@ -604,13 +902,28 @@ ${message}` : message;
             name,
             command: typeof payload.command === "string" ? payload.command : null,
             output: failureMessage(payload) ?? "",
-            origin: payload.origin === "created" || payload.origin === "restored" || payload.origin === "resumed" ? payload.origin : null,
+            origin,
             status,
             occurredAt: event.occurredAt
           });
         }
         break;
       }
+      case "agent.model.request": {
+        const requestPhase = typeof payload.phase === "string" ? payload.phase : null;
+        const status = requestPhase === "started" ? "running" : requestPhase === "first_byte" || requestPhase === "first_event" ? "complete" : requestPhase === "failed" || requestPhase === "timed_out" ? "failed" : null;
+        if (status) {
+          if (status === "running") closeStreamingTail();
+          settleStartupPhase(
+            "provider_first_byte",
+            status,
+            status === "running" ? null : numberOrNull(payload.durationMs),
+            null,
+            status === "running" ? 2 : 1
+          );
+        }
+        break;
+      }
       case "sandbox.command.output.delta": {
         const text = typeof payload.chunk === "string" ? payload.chunk : typeof payload.text === "string" ? payload.text : typeof payload.output === "string" ? payload.output : "";
         if (!text) {
@@ -629,32 +942,56 @@ ${message}` : message;
         if (!isSessionStatus(status)) {
           break;
         }
+        if (status === "running") resolvePresentationWait(event, turnId);
         if (!ATTENTION_STATUSES.has(status)) {
           break;
         }
-        const previous = [...items].reverse().find((item) => item.kind === "session-status");
-        if (previous?.status === status) {
+        const previous = [...items].reverse().find((item2) => item2.kind === "session-status");
+        if (previous?.status === status && !previous.resolvedAt) {
           break;
         }
-        items.push({
+        const item = {
           kind: "session-status",
           id: event.id,
           status,
           occurredAt: event.occurredAt
-        });
+        };
+        if (status === "requires_action") rememberPresentationWait(item, turnId);
+        else {
+          items.push(item);
+          if (status === "failed") {
+            const key = turnId ?? presentationTurnId;
+            const failures = presentationFailures.get(key) ?? [];
+            failures.push(item);
+            presentationFailures.set(key, failures);
+          }
+        }
         break;
       }
-      case "session.requiresAction": {
-        finalizeOpen(turnId);
+      case "codex.capacity.waiting": {
         items.push({
           kind: "notice",
           id: event.id,
           tone: "waiting",
-          text: "Approval needed \u2014 the turn is paused until someone decides.",
+          text: stringValue(payload.detail) ?? stringValue(payload.error) ?? "Waiting for Codex capacity.",
           occurredAt: event.occurredAt
         });
         break;
       }
+      case "session.requiresAction": {
+        finalizeOpen(turnId, "complete", event.occurredAt);
+        rememberPresentationWait(
+          {
+            kind: "notice",
+            id: event.id,
+            tone: "waiting",
+            text: "Approval needed \u2014 the turn is paused until someone decides.",
+            occurredAt: event.occurredAt
+          },
+          turnId
+        );
+        break;
+      }
       case "session.context.compaction.requested":
       case "session.context.compaction.started": {
         closeStreamingTail();
@@ -666,6 +1003,7 @@ ${message}` : message;
           estimatedTokensBefore: numberOrNull(payload.estimatedTokensBefore),
           estimatedTokensAfter: null,
           skipReason: null,
+          providerRejection: null,
           implementation: typeof payload.implementation === "string" ? payload.implementation : null,
           occurredAt: event.occurredAt
         });
@@ -681,6 +1019,7 @@ ${message}` : message;
           estimatedTokensBefore: numberOrNull(payload.estimatedTokensBefore),
           estimatedTokensAfter: numberOrNull(payload.estimatedTokensAfter),
           skipReason: null,
+          providerRejection: null,
           implementation: typeof payload.implementation === "string" ? payload.implementation : null,
           occurredAt: event.occurredAt
         });
@@ -696,12 +1035,30 @@ ${message}` : message;
           estimatedTokensBefore: numberOrNull(payload.estimatedTokensBefore),
           estimatedTokensAfter: null,
           skipReason: typeof payload.reason === "string" ? payload.reason : null,
+          providerRejection: compactionProviderRejection(payload),
           implementation: typeof payload.implementation === "string" ? payload.implementation : null,
           occurredAt: event.occurredAt
         });
         break;
       }
       case "turn.recovery.requested": {
+        if (turnId) {
+          startupRecoveryRevisionByTurn.set(
+            turnId,
+            (startupRecoveryRevisionByTurn.get(turnId) ?? 0) + 1
+          );
+          if (!event.duplicateOfEventId && (!event.turnAssociation || event.turnAssociation === "current")) {
+            for (const item of items) {
+              if (item.kind === "turn-end" && item.turnId === turnId && item.outcome === "failed") {
+                item.resumedAt ??= event.occurredAt;
+              }
+            }
+            for (const item of presentationFailures.get(turnId) ?? []) {
+              item.resolvedAt = event.occurredAt;
+            }
+            presentationFailures.delete(turnId);
+          }
+        }
         break;
       }
       case "turn.event.rejected_late": {
@@ -710,6 +1067,7 @@ ${message}` : message;
       case "tool.auth_needed":
       case "credential.auth_needed": {
         const capability = capabilityAuthorizationRequest(payload.capability);
+        const setupRequest = customMcpSetupRequest(payload.setupRequest);
         if (event.type === "tool.auth_needed" && !stringValue(payload.toolName) && stringValue(payload.serverId) !== "codex_apps") {
           break;
         }
@@ -719,26 +1077,49 @@ ${message}` : message;
           id: event.id,
           turnId,
           serverId: typeof payload.serverId === "string" ? payload.serverId : null,
-          source: capability ? "capability" : event.type === "tool.auth_needed" ? "tool" : "credential",
+          canonicalServerId: typeof payload.canonicalServerId === "string" ? payload.canonicalServerId : null,
+          connectionSubjectScope: payload.connectionSubjectScope === "subject" || payload.connectionSubjectScope === "workspace" ? payload.connectionSubjectScope : null,
+          source: capability || setupRequest ? "capability" : event.type === "tool.auth_needed" ? "tool" : "credential",
           providerDomain: stringValue(payload.providerDomain),
           connectionId: typeof payload.connectionId === "string" ? payload.connectionId : null,
-          reason: authNeededReason(payload.reason),
+          authoritySource: payload.authoritySource === "host" ? "host" : null,
+          reason: authNeededReason(
+            payload.authoritySource === "host" && typeof payload.authorizationUrl === "string" ? payload.hostReason ?? payload.reason : payload.reason
+          ),
           scopes: stringList(payload.scopes),
           resource: typeof payload.resource === "string" ? payload.resource : null,
           toolName: typeof payload.toolName === "string" ? payload.toolName : null,
           authorizationUrl: typeof payload.authorizationUrl === "string" ? payload.authorizationUrl : null,
           capability,
+          setupRequest,
           occurredAt: event.occurredAt
         });
         break;
       }
+      case "usage.exhausted": {
+        allowanceNotice(event, turnId);
+        break;
+      }
       case "turn.completed": {
         if (payload.maintenance === "context_compaction") {
-          finalizeOpen(turnId);
+          finalizeOpen(turnId, "complete", event.occurredAt);
+          takeAgentResponse(turnId);
+          takePendingWaitOutcome(turnId);
+          break;
+        }
+        const allowance = parseAllowanceExhaustedRefusal(payload);
+        if (allowance) {
+          finalizeOpen(turnId, "complete", event.occurredAt);
+          takeAgentResponse(turnId);
+          takePendingWaitOutcome(turnId);
+          items.push(turnEndItem(event, "failed", ALLOWANCE_TURN_END_TEXT));
+          allowanceNotice(event, turnId);
           break;
         }
         if (isCreditExhaustionPayload(payload)) {
-          finalizeOpen(turnId);
+          finalizeOpen(turnId, "complete", event.occurredAt);
+          takeAgentResponse(turnId);
+          takePendingWaitOutcome(turnId);
           items.push(turnEndItem(event, "failed", CREDIT_EXHAUSTION_MESSAGE));
           items.push({
             kind: "notice",
@@ -749,16 +1130,82 @@ ${message}` : message;
           });
           break;
         }
-        finalizeOpen(turnId);
-        items.push(turnEndItem(event, "complete", null));
+        const latestAgentResponse = takeAgentResponse(turnId);
+        const finalOutput = stringValue(payload.output);
+        const visibleFinalOutput = stripOpaqueCitationTokens(finalOutput).trim();
+        const visibleTrackedResponse = stripOpaqueCitationTokens(
+          latestAgentResponse?.item.text ?? ""
+        ).trim();
+        const finalOutputMirrorsCommentary = latestAgentResponse?.item.phase === "commentary" && visibleTrackedResponse === visibleFinalOutput;
+        const hasAuthoritativeFinalOutput = Boolean(visibleFinalOutput) && !finalOutputMirrorsCommentary;
+        const pendingWaitOutcome = takePendingWaitOutcome(turnId);
+        if (hasAuthoritativeFinalOutput) {
+          if (latestAgentResponse && !latestAgentResponse.completed && finalOutput.startsWith(latestAgentResponse.item.text)) {
+            latestAgentResponse.item.text = finalOutput;
+            latestAgentResponse.item.streaming = false;
+            if (latestAgentResponse.item.startedAt === void 0 && latestAgentResponse.item.occurredAt !== event.occurredAt) {
+              latestAgentResponse.item.startedAt = latestAgentResponse.item.occurredAt;
+            }
+            latestAgentResponse.item.occurredAt = event.occurredAt;
+            const responseIndex = items.indexOf(latestAgentResponse.item);
+            if (responseIndex >= 0 && responseIndex < items.length - 1) {
+              items.splice(responseIndex, 1);
+              items.push(latestAgentResponse.item);
+            }
+          } else if (visibleTrackedResponse !== visibleFinalOutput) {
+            items.push({
+              kind: "agent-message",
+              id: `${event.id}-output-message`,
+              turnId,
+              text: finalOutput,
+              streaming: false,
+              occurredAt: event.occurredAt
+            });
+          }
+        }
+        finalizeOpen(turnId, "complete", event.occurredAt);
+        const completedTurn = turnEndItem(event, "complete", null);
+        items.push(completedTurn);
+        if (turnCompletedWithEmptyFinalReply(payload)) {
+          items.push({
+            kind: "notice",
+            id: `${event.id}-empty-final-reply`,
+            tone: "input",
+            text: EMPTY_FINAL_REPLY_NOTICE,
+            recordedOutcome: true,
+            occurredAt: event.occurredAt
+          });
+        }
+        const hasCompletedFinalResponse = latestAgentResponse?.completed === true && latestAgentResponse.item.phase !== "commentary" && Boolean(visibleTrackedResponse);
+        if (!hasAuthoritativeFinalOutput && pendingWaitOutcome) {
+          completedTurn.preserveWaitResponse = true;
+        }
+        if (!hasAuthoritativeFinalOutput && !hasCompletedFinalResponse && pendingWaitOutcome) {
+          const notice = {
+            kind: "notice",
+            id: `${pendingWaitOutcome.id}-visible-outcome`,
+            tone: "waiting",
+            text: waitingOutcomeText(pendingWaitOutcome.reason),
+            recordedOutcome: true,
+            ...pendingWorkerSessions.size > 0 ? { waitingAgents: pendingWorkerSessions.size } : {},
+            occurredAt: pendingWaitOutcome.occurredAt
+          };
+          items.push(notice);
+          openWaitNotice = notice;
+        }
         break;
       }
       case "turn.failed": {
+        takeAgentResponse(turnId);
+        takePendingWaitOutcome(turnId);
         const hadActivity = hasTurnActivity(items, turnId);
-        const failureText = isCreditExhaustionPayload(payload) ? CREDIT_EXHAUSTION_MESSAGE : failureMessage(payload);
-        finalizeOpen(turnId, "cancelled");
+        const allowance = parseAllowanceExhaustedRefusal(payload);
+        const failureText = allowance ? ALLOWANCE_TURN_END_TEXT : isCreditExhaustionPayload(payload) ? CREDIT_EXHAUSTION_MESSAGE : failureMessage(payload);
+        finalizeOpen(turnId, "cancelled", event.occurredAt);
         items.push(turnEndItem(event, "failed", failureText));
-        if (!hadActivity) {
+        if (allowance) {
+          allowanceNotice(event, turnId);
+        } else if (!hadActivity) {
           items.push({
             kind: "notice",
             id: event.id,
@@ -769,12 +1216,15 @@ ${message}` : message;
         }
         break;
       }
+      case "turn.superseded":
       case "turn.cancelled": {
-        if (turnId && !prescan.startedTurnIds.has(turnId)) {
+        if (event.type === "turn.cancelled" && turnId && !prescan.startedTurnIds.has(turnId)) {
           break;
         }
+        takeAgentResponse(turnId);
+        takePendingWaitOutcome(turnId);
         const hadActivity = hasTurnActivity(items, turnId);
-        finalizeOpen(turnId, "cancelled");
+        finalizeOpen(turnId, "cancelled", event.occurredAt);
         items.push(turnEndItem(event, "cancelled", null));
         if (!hadActivity) {
           items.push({
@@ -787,6 +1237,40 @@ ${message}` : message;
         }
         break;
       }
+      case "instruction.confirmation.recovered": {
+        const receipt = asRecord2(payload.receipt);
+        if (receipt.outcome !== "published") break;
+        closeStreamingTail();
+        items.push({
+          kind: "notice",
+          id: event.id,
+          tone: "input",
+          text: "Your previously approved workspace instruction was saved.",
+          occurredAt: event.occurredAt
+        });
+        break;
+      }
+      case "knowledge.confirmation.recovered":
+      case "knowledge.source.prepared":
+      case "knowledge.source.failed": {
+        const receipt = asRecord2(payload.receipt);
+        const outcome = event.type === "knowledge.source.failed" ? "failed" : receipt.outcome;
+        if (event.type !== "knowledge.confirmation.recovered" && typeof payload.fileId !== "string" || !["published", "pending", "rejected", "archived", "failed"].includes(String(outcome)))
+          break;
+        closeStreamingTail();
+        items.push({
+          kind: "knowledge",
+          id: event.id,
+          turnId,
+          fileId: typeof payload.fileId === "string" ? payload.fileId : void 0,
+          filename: typeof payload.filename === "string" ? payload.filename : void 0,
+          entryId: typeof receipt.entryId === "string" ? receipt.entryId : void 0,
+          status: outcome === "failed" ? "failed" : "complete",
+          outcome,
+          occurredAt: event.occurredAt
+        });
+        break;
+      }
       case "memory.saved":
       case "memory.corrected": {
         const memory = memoryItem(event.id, event.type, turnId, payload, event.occurredAt);
@@ -810,7 +1294,11 @@ ${message}` : message;
       case "goal.paused":
       case "goal.resumed":
       case "goal.cleared":
+      case "goal.held":
       case "goal.continuation": {
+        if (event.type === "goal.held" && payload.actor === "agent") {
+          rememberPendingWaitOutcome(pendingWaitOutcomeByTurn, event, payload, turnId);
+        }
         if (shouldSuppressAgentGoalLandmark(event.type, payload)) {
           break;
         }
@@ -818,16 +1306,29 @@ ${message}` : message;
           kind: "goal",
           id: event.id,
           action: event.type.slice("goal.".length),
-          text: goalText(payload),
+          text: event.type === "goal.held" && typeof payload.reason === "string" && payload.reason ? payload.reason : goalText(payload),
           occurredAt: event.occurredAt
         });
         break;
       }
+      case "session.wait.started": {
+        if (payload.actor === "agent") {
+          rememberPendingWaitOutcome(pendingWaitOutcomeByTurn, event, payload, turnId);
+        }
+        break;
+      }
       default:
         break;
     }
   }
+  const sourceEventsById = new Map(events.map((event) => [event.id, event]));
   for (const item of items) {
+    const source = sourceEventsById.get(item.id);
+    const canonical = "annotationSource" in item ? item.annotationSource : void 0;
+    item.sourceEvents = [
+      ...source ? [{ eventId: source.id, sequence: source.sequence }] : [],
+      ...canonical && canonical.eventId !== source?.id ? [{ eventId: canonical.eventId, sequence: canonical.sequence }] : []
+    ];
     if (item.kind === "agent-message") {
       item.text = stripOpaqueCitationTokens(item.text);
     }
@@ -843,6 +1344,93 @@ function realtimeVoiceMessage(payload) {
   }
   return null;
 }
+function humanInputRequestsById(events) {
+  const requests = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.type !== "session.humanInput.requested") continue;
+    const request = asRecord2(asRecord2(event.payload).request);
+    const requestId = stringValue(request.id);
+    if (requestId) requests.set(requestId, request);
+  }
+  return requests;
+}
+function humanInputItemFromResponse(event, payload, requests) {
+  const response = asRecord2(payload.response);
+  const outcome = response.outcome;
+  if (outcome !== "answered" && outcome !== "skipped" && outcome !== "expired" && outcome !== "cancelled") {
+    return null;
+  }
+  const requestId = stringValue(payload.requestId);
+  const request = requests.get(requestId);
+  const questions = humanInputQuestions(request?.questions);
+  const normalizedResponse = outcome === "answered" ? {
+    outcome,
+    answers: Array.isArray(response.answers) ? response.answers.map(asRecord2).map(humanInputAnswer).filter((answer) => answer !== null) : []
+  } : { outcome };
+  const questionsById = new Map(questions.map((question) => [question.id, question]));
+  const answers = normalizedResponse.outcome === "answered" ? normalizedResponse.answers.map(
+    (answer) => humanInputAnswerSummary(answer, questionsById.get(answer.questionId))
+  ) : [];
+  return {
+    kind: "human-input",
+    id: event.id,
+    turnId: event.turnId ?? null,
+    requestId,
+    questions,
+    response: normalizedResponse,
+    answers,
+    occurredAt: event.occurredAt
+  };
+}
+function humanInputQuestions(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map(asRecord2).flatMap((question) => {
+    const id = stringValue(question.id);
+    const prompt = stringValue(question.prompt);
+    const kind = question.kind;
+    if (!id || !prompt || kind !== "text" && kind !== "single_select" && kind !== "multi_select") {
+      return [];
+    }
+    const options = Array.isArray(question.options) ? question.options.map(asRecord2).flatMap((option) => {
+      const optionId = stringValue(option.id);
+      const label = stringValue(option.label);
+      return optionId && label ? [{ id: optionId, label, description: stringValue(option.description) || null }] : [];
+    }) : [];
+    return [
+      {
+        id,
+        kind,
+        prompt,
+        label: stringValue(question.label) || null,
+        helpText: stringValue(question.helpText) || null,
+        options,
+        required: question.required === true,
+        allowOther: question.allowOther === true
+      }
+    ];
+  });
+}
+function humanInputAnswer(value) {
+  const questionId = stringValue(value.questionId);
+  if (!questionId) return null;
+  return {
+    questionId,
+    values: Array.isArray(value.values) ? value.values.filter((answer) => typeof answer === "string") : [],
+    ...typeof value.other === "string" && value.other ? { other: value.other } : {}
+  };
+}
+function humanInputAnswerSummary(answer, question) {
+  const optionLabels = new Map(question?.options.map((option) => [option.id, option.label]) ?? []);
+  const values = answer.values.map((value) => optionLabels.get(value) || value);
+  if (answer.other) values.push(answer.other);
+  const fallbackLabel = answer.questionId.replace(/[_-]+/g, " ").replace(/\b\w/g, (character) => character.toUpperCase());
+  return {
+    questionId: answer.questionId,
+    label: question?.label || question?.prompt || fallbackLabel,
+    prompt: question?.prompt || fallbackLabel,
+    values
+  };
+}
 function providerNativeToolStatus(rawValue) {
   const raw = asRecord2(rawValue);
   if (raw.type !== "hosted_tool_call") {
@@ -884,7 +1472,9 @@ function mergeToolCallRaw(existingValue, nextValue) {
 function stripOpaqueCitationTokens(text) {
   return text.replace(/\s*cite(?:[^]+)+/gu, "");
 }
+var ALLOWANCE_TURN_END_TEXT = "Usage limit reached";
 function isCreditExhaustionPayload(payload) {
+  if (payload.code === "allowance_exhausted") return false;
   return isCreditExhaustion({
     error: typeof payload.error === "string" ? payload.error : null,
     detail: typeof payload.detail === "string" ? payload.detail : null,
@@ -921,14 +1511,17 @@ function isActivityItem(item) {
     case "tool-call":
     case "worker":
     case "sandbox":
+    case "startup-phase":
     case "memory":
+    case "knowledge":
     case "fleet-decision":
       return true;
     default:
       return false;
   }
 }
-function groupTimeline(items) {
+function groupTimeline(items, options = {}) {
+  if (options.readableTurns || options.foldExchanges) return groupReadableTurns(items);
   const groups = [];
   for (const item of items) {
     if (isActivityItem(item)) {
@@ -953,21 +1546,287 @@ function groupTimeline(items) {
   }
   return groups;
 }
+function groupReadableTurns(items) {
+  let groups = [];
+  const turns = /* @__PURE__ */ new Map();
+  const seenTurns = /* @__PURE__ */ new Set();
+  const settlements = /* @__PURE__ */ new Map();
+  const compactionTurns = /* @__PURE__ */ new Map();
+  const messages = /* @__PURE__ */ new Map();
+  const inputs = /* @__PURE__ */ new Map();
+  const itemOrder = new Map(items.map((item, index) => [item.id, index]));
+  let legacyTurn = "start";
+  let currentTurn = legacyTurn;
+  for (const item of items) {
+    if (item.kind === "user-message") legacyTurn = item.id;
+    const key = "turnId" in item && item.turnId || legacyTurn;
+    if ("turnId" in item && item.turnId || isActivityItem(item) || item.kind === "agent-message" && item.text.trim()) {
+      if (key !== currentTurn && !seenTurns.has(key)) {
+        const previous = turns.get(currentTurn);
+        if (!settlements.has(currentTurn)) {
+          settlements.set(currentTurn, { endedAt: item.occurredAt });
+        }
+        if (previous?.work && !previous.work.endedAt) previous.work.endedAt = item.occurredAt;
+        currentTurn = key;
+      }
+      seenTurns.add(key);
+    }
+    const workForTurn = () => {
+      let group = turns.get(key);
+      const firstMessage = messages.get(key)?.[0];
+      const messageStart = firstMessage?.startedAt ?? firstMessage?.occurredAt;
+      const startedAt = messageStart && Date.parse(messageStart) < Date.parse(item.occurredAt) ? messageStart : item.occurredAt;
+      if (!group) {
+        const settlement = settlements.get(key);
+        group = {
+          kind: "activity",
+          id: `work-${key}`,
+          items: [],
+          work: { startedAt, details: [] }
+        };
+        if (settlement) {
+          group.work.endedAt = settlement.endedAt;
+          if (settlement.outcome) group.outcome = settlement.outcome;
+          if (settlement.failureText) group.failureText = settlement.failureText;
+        }
+        turns.set(key, group);
+        const firstMessageIndex = settlement && firstMessage ? groups.findIndex((entry) => entry.kind === "item" && entry.item === firstMessage) : -1;
+        if (firstMessageIndex >= 0) groups.splice(firstMessageIndex, 0, group);
+        else groups.push(group);
+      } else if (Date.parse(startedAt) < Date.parse(group.work.startedAt)) {
+        group.work.startedAt = startedAt;
+      }
+      return group;
+    };
+    if (isActivityItem(item)) {
+      const group = workForTurn();
+      group.items.push(item);
+      const previous = group.work.details.at(-1);
+      const preparing = (entry) => entry.kind === "startup-phase" || entry.kind === "reasoning" && !entry.text.trim();
+      if (preparing(item) && previous?.kind === "activity" && previous.items.every(preparing) && previous.items.at(-1) === items[(itemOrder.get(item.id) ?? 0) - 1])
+        previous.items.push(item);
+      else
+        group.work.details.push({ kind: "activity", id: `work-item-${item.id}`, items: [item] });
+      delete group.work.waiting;
+    } else if (item.kind === "turn-end") {
+      if (!item.resumedAt) {
+        settlements.set(key, {
+          endedAt: item.occurredAt,
+          outcome: item.outcome,
+          ...item.failureText ? { failureText: item.failureText } : {}
+        });
+      }
+      const group = turns.get(key);
+      if (group?.work) {
+        if (item.resumedAt) {
+          group.work.details.push({
+            kind: "item",
+            item: {
+              kind: "notice",
+              id: item.id,
+              tone: "failed",
+              text: item.failureText ?? "The turn failed before retrying.",
+              occurredAt: item.occurredAt
+            }
+          });
+          continue;
+        }
+        group.outcome = item.outcome;
+        if (item.failureText) group.failureText = item.failureText;
+        group.work.endedAt = item.occurredAt;
+      }
+    } else if (item.kind === "context-compaction" && item.phase === "compacted") {
+      compactionTurns.set(item, key);
+      groups.push({ kind: "item", item });
+    } else if (item.kind === "machine-input-batch" && item.members.every((member) => ROUTINE_MACHINE_INPUT_KINDS.has(member.kind))) {
+      const previous = inputs.get(key);
+      if (previous) {
+        previous.members.push(
+          ...item.members.filter((member) => !previous.members.some((old) => old.id === member.id))
+        );
+        previous.sourceEvents = [...previous.sourceEvents ?? [], ...item.sourceEvents ?? []];
+      } else {
+        const batch = { ...item, compact: true, members: [...item.members] };
+        inputs.set(key, batch);
+        groups.push({ kind: "item", item: batch });
+      }
+    } else if (item.kind === "worker-completion" || item.kind === "goal" && item.action === "continuation") {
+      const group = turns.get(currentTurn);
+      if (group?.work) group.work.details.push({ kind: "item", item });
+      else groups.push({ kind: "item", item });
+    } else {
+      const current = turns.get(currentTurn)?.work;
+      const liveApprovalWait = item.kind === "notice" && item.tone === "waiting" && !item.recordedOutcome && !item.resolvedAt && item.text.startsWith("Approval needed") && current !== void 0 && !current.endedAt;
+      const liveStatusWait = item.kind === "session-status" && item.status === "requires_action" && !item.resolvedAt && current !== void 0 && !current.endedAt;
+      if (!liveApprovalWait && !liveStatusWait) groups.push({ kind: "item", item });
+      if (current && !current.endedAt) {
+        if (item.kind === "notice" && item.tone === "waiting" && !item.recordedOutcome && !item.resolvedAt) {
+          current.waiting = {
+            label: item.text.startsWith("Approval needed") ? "Waiting for you" : "Waiting",
+            since: item.occurredAt
+          };
+        } else if (item.kind === "session-status" && item.status === "requires_action" && !item.resolvedAt) {
+          current.waiting = { label: "Waiting for you", since: item.occurredAt };
+        } else if (item.kind === "session-status" && ["paused", "cancelled", "failed"].includes(item.status) && !item.resolvedAt) {
+          current.endedAt = item.occurredAt;
+          delete current.waiting;
+        }
+      }
+      if (item.kind === "agent-message" && item.text.trim()) {
+        const prose = messages.get(key) ?? [];
+        prose.push(item);
+        messages.set(key, prose);
+        if ((item.phase !== "final_answer" || prose.length > 1) && (turns.has(key) || !settlements.has(key)))
+          workForTurn();
+      }
+    }
+  }
+  groups = groups.filter((entry) => {
+    if (entry.kind !== "item" || entry.item.kind !== "context-compaction") return true;
+    const key = compactionTurns.get(entry.item);
+    const work = key === void 0 ? void 0 : turns.get(key)?.work;
+    if (!work) return true;
+    work.details.push(entry);
+    return false;
+  });
+  const beforeRows = /* @__PURE__ */ new Map();
+  const afterRows = /* @__PURE__ */ new Map();
+  const movedRows = /* @__PURE__ */ new Set();
+  const foldedProse = /* @__PURE__ */ new Set();
+  const positions = /* @__PURE__ */ new Map();
+  const nextBoundary = /* @__PURE__ */ new Map();
+  let boundary = groups.length;
+  for (let index = groups.length - 1; index >= 0; index -= 1) {
+    const entry = groups[index];
+    positions.set(entry.kind === "item" ? entry.item : entry, index);
+    if (entry.kind === "activity" && entry.work) {
+      nextBoundary.set(entry, boundary);
+      boundary = index;
+    } else if (entry.kind === "item" && (entry.item.kind === "user-message" || entry.item.kind === "machine-input-batch")) {
+      boundary = index;
+    }
+  }
+  for (const [key, group] of turns) {
+    const prose = messages.get(key) ?? [];
+    const settledAt = group.work.endedAt;
+    const responseCandidates = settledAt ? prose.filter(
+      (message) => Date.parse(message.startedAt ?? message.occurredAt) <= Date.parse(settledAt)
+    ) : prose;
+    const response = responseCandidates.filter((message) => message.phase === "final_answer").at(-1) ?? (settledAt ? responseCandidates.at(-1) ?? prose.filter((message) => message.phase === "final_answer").at(-1) : void 0);
+    if (settledAt) {
+      for (const message of responseCandidates) {
+        if (message === response || message.text.includes("![")) continue;
+        foldedProse.add(message);
+        group.work.details.push({ kind: "item", item: message });
+      }
+    }
+    group.work.details.sort((a, b) => {
+      const first = (entry) => entry.kind === "item" ? entry.item.id : entry.kind === "activity" ? entry.items[0]?.id : void 0;
+      return (itemOrder.get(first(a) ?? "") ?? 0) - (itemOrder.get(first(b) ?? "") ?? 0);
+    });
+    if (response) {
+      const responseAt = response.startedAt ?? response.occurredAt;
+      group.work.responseStartedAt = settledAt && Date.parse(responseAt) > Date.parse(settledAt) ? settledAt : responseAt;
+      if (settledAt && (positions.get(response) ?? groups.length) < (nextBoundary.get(group) ?? groups.length)) {
+        beforeRows.set(groups[positions.get(response)], group);
+        movedRows.add(group);
+      }
+    }
+    if (!settledAt) {
+      const lastProseIndex = Math.max(...prose.map((message) => positions.get(message) ?? -1));
+      let tailIndex = groups.length - 1;
+      for (let index = (positions.get(group) ?? 0) + 1; index <= tailIndex; index += 1) {
+        const entry = groups[index];
+        if (entry.kind === "activity" && entry.work || entry.kind === "item" && ("turnId" in entry.item && entry.item.turnId && entry.item.turnId !== key || index > lastProseIndex && (entry.item.kind === "user-message" || entry.item.kind === "machine-input-batch"))) {
+          tailIndex = index - 1;
+          break;
+        }
+      }
+      const tail = groups[tailIndex];
+      if (tail && tail !== group) {
+        afterRows.set(tail, group);
+        movedRows.add(group);
+      }
+    }
+  }
+  return groups.flatMap((group) => {
+    if (group.kind === "activity" && movedRows.has(group)) return [];
+    const hidden = group.kind === "item" && group.item.kind === "agent-message" && foldedProse.has(group.item);
+    const before = beforeRows.get(group);
+    const after = afterRows.get(group);
+    return [...before ? [before] : [], ...hidden ? [] : [group], ...after ? [after] : []];
+  });
+}
+var ROUTINE_MACHINE_INPUT_KINDS = /* @__PURE__ */ new Set([
+  "goal_continuation",
+  "background_command_result",
+  "session_wait_timeout",
+  "agent_message",
+  "agent_steer_instruction",
+  "child_terminal_result",
+  "child_requires_action_resolved",
+  "child_paused",
+  "child_waiting_capacity",
+  "child_progress"
+]);
+function timelineQuestionPlacement(question, evidence) {
+  const anchors = prescanTurnAnchors([question, ...evidence]);
+  const direct = anchors.directChatSequenceByTrigger.get(question.id);
+  if (direct !== void 0) return { kind: "visible", sequence: direct };
+  if (anchors.cancelledBeforeStartTriggers.has(question.id)) return { kind: "withdrawn" };
+  const start = anchors.startSeqByTrigger.get(question.id);
+  if (start !== void 0) return { kind: "visible", sequence: start };
+  if (anchors.queuedTurnByTrigger.has(question.id) || anchors.explicitQueuedTriggers.has(question.id))
+    return { kind: "pending" };
+  return { kind: "visible", sequence: question.sequence };
+}
 function prescanTurnAnchors(events) {
   const ordered = [...events].sort((a, b) => a.sequence - b.sequence);
   const queuedTurnByTrigger = /* @__PURE__ */ new Map();
   const startSeqByTrigger = /* @__PURE__ */ new Map();
   const cancelledTurnIds = /* @__PURE__ */ new Set();
+  const withdrawnTurnIds = /* @__PURE__ */ new Set();
   const fallbackSeqByTurn = /* @__PURE__ */ new Map();
+  const directChatSequenceByTrigger = /* @__PURE__ */ new Map();
+  const explicitQueuedTriggers = /* @__PURE__ */ new Set();
+  const queueSteerSequenceByTurn = /* @__PURE__ */ new Map();
   const startedTurnIds = /* @__PURE__ */ new Set();
+  const userMessageSequenceById = /* @__PURE__ */ new Map();
   for (const event of ordered) {
     const payload = asRecord2(event.payload);
     const turnId = event.turnId ?? null;
+    if (event.type === "user.message") {
+      userMessageSequenceById.set(event.id, event.sequence);
+      if (payload.routing === "queued_for_execution") {
+        explicitQueuedTriggers.add(event.id);
+      } else if (payload.routing === "accepted_for_execution" || payload.routing === "accepted_for_steering") {
+        directChatSequenceByTrigger.set(event.id, event.sequence);
+      }
+    }
+    if (event.type === "user.message" && payload.delivery === "steer") {
+      directChatSequenceByTrigger.set(event.id, event.sequence);
+    }
+    if (event.type === "session.control.steer_requested") {
+      const targetTurnId = typeof payload.targetTurnId === "string" ? payload.targetTurnId : null;
+      if (targetTurnId && !queueSteerSequenceByTurn.has(targetTurnId)) {
+        queueSteerSequenceByTurn.set(targetTurnId, event.sequence);
+      }
+    }
+    if (event.type === "session.queue.changed" && (payload.operation === "edit" || payload.operation === "delete")) {
+      const withdrawnTurnId = typeof payload.turnId === "string" ? payload.turnId : turnId ?? null;
+      if (withdrawnTurnId) withdrawnTurnIds.add(withdrawnTurnId);
+    }
     if (event.type === "turn.queued") {
       const triggerEventId = typeof payload.triggerEventId === "string" ? payload.triggerEventId : null;
       const queuedTurnId = typeof payload.turnId === "string" ? payload.turnId : turnId;
       if (triggerEventId && queuedTurnId) {
         queuedTurnByTrigger.set(triggerEventId, queuedTurnId);
+        if ((payload.routing === "accepted_for_execution" || payload.routing === "accepted_for_steering") && !directChatSequenceByTrigger.has(triggerEventId)) {
+          directChatSequenceByTrigger.set(
+            triggerEventId,
+            userMessageSequenceById.get(triggerEventId) ?? event.sequence
+          );
+        }
       }
       continue;
     }
@@ -993,6 +1852,10 @@ function prescanTurnAnchors(events) {
     }
   }
   for (const [triggerEventId, turnId] of queuedTurnByTrigger) {
+    const queueSteerSequence = queueSteerSequenceByTurn.get(turnId);
+    if (queueSteerSequence !== void 0) {
+      directChatSequenceByTrigger.set(triggerEventId, queueSteerSequence);
+    }
     if (!startSeqByTrigger.has(triggerEventId)) {
       const fallbackSeq = fallbackSeqByTurn.get(turnId);
       if (fallbackSeq !== void 0) {
@@ -1002,7 +1865,7 @@ function prescanTurnAnchors(events) {
   }
   const cancelledBeforeStartTriggers = /* @__PURE__ */ new Set();
   for (const [triggerEventId, turnId] of queuedTurnByTrigger) {
-    if (cancelledTurnIds.has(turnId) && !startSeqByTrigger.has(triggerEventId) && !fallbackSeqByTurn.has(turnId)) {
+    if ((cancelledTurnIds.has(turnId) || withdrawnTurnIds.has(turnId)) && !startSeqByTrigger.has(triggerEventId) && !fallbackSeqByTurn.has(turnId)) {
       cancelledBeforeStartTriggers.add(triggerEventId);
     }
   }
@@ -1010,6 +1873,8 @@ function prescanTurnAnchors(events) {
     queuedTurnByTrigger,
     startSeqByTrigger,
     cancelledBeforeStartTriggers,
+    directChatSequenceByTrigger,
+    explicitQueuedTriggers,
     startedTurnIds
   };
 }
@@ -1020,8 +1885,20 @@ function orderTimelineEvents(events, prescan) {
     if (event.type !== "user.message") {
       continue;
     }
+    const directChatSequence = prescan.directChatSequenceByTrigger.get(event.id);
+    if (directChatSequence !== void 0) {
+      pushInsertion(insertions, directChatSequence, event);
+      continue;
+    }
     const queuedTurnId = prescan.queuedTurnByTrigger.get(event.id);
     if (!queuedTurnId) {
+      if (prescan.explicitQueuedTriggers.has(event.id)) {
+        const startSeq2 = prescan.startSeqByTrigger.get(event.id);
+        if (startSeq2 !== void 0) {
+          pushInsertion(insertions, startSeq2, event);
+        }
+        continue;
+      }
       pushInsertion(insertions, event.sequence, event);
       continue;
     }
@@ -1058,7 +1935,9 @@ function isAgentActivityEvent(type) {
   return type.startsWith("agent.") || type.startsWith("sandbox.");
 }
 function isTurnExecutionEvidence(type) {
-  return isAgentActivityEvent(type) || type === "turn.completed" || type === "turn.failed" || type === "turn.recovery.requested" || type === "turn.capacity_waiting" || type === "session.requiresAction" || type === "tool.auth_needed" || type === "credential.auth_needed" || type.startsWith("rig.setup.") || type === "codex.capacity.waiting" || type === "codex.capacity.resumed" || type === "codex.fleet.decision";
+  return isAgentActivityEvent(type) || type === "turn.completed" || type === "turn.failed" || // An admission refusal can settle a queued turn before it ever starts:
+  // its prompt still belongs above the "usage limit reached" row.
+  type === "usage.exhausted" || type === "turn.superseded" || type === "turn.recovery.requested" || type === "turn.capacity_waiting" || type === "session.requiresAction" || type === "tool.auth_needed" || type === "credential.auth_needed" || type.startsWith("turn.startup.phase.") || type.startsWith("rig.setup.") || type === "codex.capacity.waiting" || type === "codex.capacity.resumed" || type === "codex.fleet.decision";
 }
 function turnEndItem(event, outcome, failureText) {
   return {
@@ -1139,8 +2018,17 @@ function foldSettledTurn(groups, turnEnd) {
   if (collected.length === 0) {
     return;
   }
-  const finalMessage = extractFinalAgentMessage(collected, turnEnd);
-  const body = finalMessage ? collected.slice(0, -1) : collected;
+  const collectedLength = collected.length;
+  const waitMessages = turnEnd.preserveWaitResponse ? collected.filter(
+    (group) => group.kind === "item" && group.item.kind === "agent-message" && !group.item.streaming && group.item.text.trim().length > 0 && belongsToTurn(group.item, turnEnd.turnId)
+  ) : [];
+  const waitResponse = waitMessages.slice().reverse().find(
+    (group) => group.item.kind === "agent-message" && group.item.phase !== "commentary" && group.item.annotationSource?.eventType === "agent.message.completed"
+  ) ?? waitMessages.at(-1);
+  const finalMessage = waitResponse ?? extractFinalAgentMessage(collected, turnEnd);
+  const fallbackMessage = finalMessage || hasOrdinaryFinalAgentMessage(collected, turnEnd) ? null : extractLatestCompletedCommentary(collected, turnEnd);
+  const visibleMessage = finalMessage ?? fallbackMessage;
+  const body = visibleMessage ? collected.filter((group) => group !== visibleMessage) : collected;
   if (body.length === 0) {
     return;
   }
@@ -1161,12 +2049,12 @@ function foldSettledTurn(groups, turnEnd) {
   }
   groups.splice(
     startIndex,
-    collected.length,
-    ...finalMessage ? [turnGroup, finalMessage] : [turnGroup]
+    collectedLength,
+    ...visibleMessage ? [turnGroup, visibleMessage] : [turnGroup]
   );
 }
 function isTurnBoundary(group) {
-  return group?.kind === "turn" || group?.kind === "item" && (group.item.kind === "user-message" || group.item.kind === "context-compaction" || group.item.kind === "machine-input-batch" && group.item.members.some((member) => member.kind === "media_generation_result") || group.item.kind === "notice" && group.item.tone === "input");
+  return group?.kind === "turn" || group?.kind === "item" && (group.item.kind === "user-message" || group.item.kind === "human-input" || group.item.kind === "context-compaction" || group.item.kind === "machine-input-batch" || group.item.kind === "notice" && group.item.tone === "input");
 }
 function belongsToDifferentTurn(group, turnId) {
   if (!group || !turnId) {
@@ -1190,6 +2078,27 @@ function extractFinalAgentMessage(groups, turnEnd) {
   }
   return tail;
 }
+function hasOrdinaryFinalAgentMessage(groups, turnEnd) {
+  return groups.some((group) => {
+    if (group.kind !== "item" || group.item.kind !== "agent-message") return false;
+    const message = group.item;
+    return !message.streaming && message.phase !== "commentary" && message.text.trim().length > 0 && belongsToTurn(message, turnEnd.turnId);
+  });
+}
+function extractLatestCompletedCommentary(groups, turnEnd) {
+  for (let index = groups.length - 1; index >= 0; index -= 1) {
+    const group = groups[index];
+    if (group?.kind !== "item" || group.item.kind !== "agent-message") continue;
+    const message = group.item;
+    if (!message.streaming && message.phase === "commentary" && message.text.trim().length > 0 && belongsToTurn(message, turnEnd.turnId)) {
+      return group;
+    }
+  }
+  return null;
+}
+function belongsToTurn(message, turnId) {
+  return !message.turnId || !turnId || message.turnId === turnId;
+}
 function groupStartedAt(group) {
   if (!group) {
     return void 0;
@@ -1209,9 +2118,26 @@ function asRecord2(value) {
 function stringValue(value) {
   return typeof value === "string" ? value : "";
 }
+function assistantMessagePhase(value) {
+  return value === "commentary" || value === "final_answer" ? value : void 0;
+}
 function numberOrNull(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
+function compactionProviderRejection(payload) {
+  const record = asRecord2(payload.providerRejection);
+  if (typeof record.httpStatus !== "number" || !Number.isFinite(record.httpStatus)) {
+    return null;
+  }
+  const text = (value) => typeof value === "string" && value.trim() ? value : null;
+  return {
+    httpStatus: record.httpStatus,
+    type: text(record.type),
+    code: text(record.code),
+    param: text(record.param),
+    requestId: text(record.requestId)
+  };
+}
 function compactionTrigger(payload) {
   const trigger = payload.trigger;
   return trigger === "auto" || trigger === "operator" || trigger === "proactive" || trigger === "overflow" ? trigger : null;
@@ -1252,10 +2178,17 @@ function machineInputMembers(value) {
   const kinds = /* @__PURE__ */ new Set([
     "scheduled_occurrence",
     "goal_continuation",
+    "background_command_result",
+    "session_wait_timeout",
     "agent_message",
     "agent_steer_instruction",
     "child_terminal_result",
-    "media_generation_result"
+    "media_generation_result",
+    "child_requires_action",
+    "child_requires_action_resolved",
+    "child_paused",
+    "child_waiting_capacity",
+    "child_progress"
   ]);
   const classifications = /* @__PURE__ */ new Set([
     "success",
@@ -1288,6 +2221,8 @@ var SESSION_STATUSES = [
   "running",
   "idle",
   "requires_action",
+  "recovering",
+  "waiting_capacity",
   "failed",
   "cancelled"
 ];
@@ -1381,6 +2316,7 @@ function findOpenCall(items, callId) {
     if (byId) {
       return byId;
     }
+    return void 0;
   }
   return reversed.find(
     (item) => isCall(item) && item.status === "running"
@@ -1391,14 +2327,41 @@ function findOpenSandbox(items, name) {
     (item) => item.kind === "sandbox" && item.name === name && item.status === "running"
   );
 }
-function failureMessage(payload) {
-  for (const key of ["error", "message"]) {
-    const value = payload[key];
-    if (typeof value === "string" && value.trim().length > 0) {
-      return humanizeFailureReason(value);
-    }
+function startupPhaseForSandboxOperation(name) {
+  return SANDBOX_STARTUP_PHASES[name] ?? null;
+}
+function startupPhaseFromPayload(value) {
+  return typeof value === "string" && STARTUP_PHASES.has(value) ? value : null;
+}
+function startupLifecycleWaitReason(payload) {
+  if (payload.expectedTransition !== true || payload.failureStage !== "lifecycle_wait" || payload.failureCategory !== "drain_capture_wait") {
+    return void 0;
   }
-  return null;
+  const code = payload.failureCode;
+  return code === "capture_in_progress" || code === "rotation_in_progress" || code === "provider_recovery_in_progress" ? code : void 0;
+}
+var SANDBOX_STARTUP_PHASES = {
+  "sandbox.provision": "sandbox",
+  "repository-clone": "repository",
+  "file-resource-download": "files"
+};
+var STARTUP_PHASES = /* @__PURE__ */ new Set([
+  "queue",
+  "sandbox",
+  "rig",
+  "repository",
+  "files",
+  "tools",
+  "model_preparation",
+  "provider_first_byte"
+]);
+function elapsedDurationMs(startedAt, completedAt) {
+  const start = Date.parse(startedAt);
+  const end = Date.parse(completedAt);
+  return Number.isFinite(start) && Number.isFinite(end) ? Math.max(0, end - start) : null;
+}
+function failureMessage(payload) {
+  return presentFailure(payload).reason;
 }
 function goalText(payload) {
   if (typeof payload.text === "string" && payload.text) {
@@ -1413,11 +2376,20 @@ function goalText(payload) {
   }
   return null;
 }
+function rememberPendingWaitOutcome(pending, event, payload, eventTurnId) {
+  const reason = stringValue(payload.reason).trim();
+  if (!reason) return;
+  const turnId = eventTurnId || stringValue(payload.waitTurnId) || stringValue(payload.turnId) || null;
+  pending.set(turnId, { id: event.id, reason, occurredAt: event.occurredAt });
+}
+function waitingOutcomeText(reason) {
+  return /^waiting\b/i.test(reason) ? reason : `Waiting: ${reason}`;
+}
 function shouldSuppressAgentGoalLandmark(type, payload) {
   if (type === "goal.completed") {
     return true;
   }
-  if (type === "goal.set" || type === "goal.updated" || type === "goal.paused") {
+  if (type === "goal.set" || type === "goal.updated" || type === "goal.paused" || type === "goal.held") {
     return payload.actor === "agent";
   }
   return false;
@@ -1463,7 +2435,7 @@ function capabilityAuthorizationRequest(value) {
   const kind = record.kind;
   const source = record.source;
   const action = record.action;
-  if (typeof record.id !== "string" || typeof record.name !== "string" || !["pack", "mcp", "api", "skill", "plugin"].includes(String(kind)) || !["built_in", "library", "configured", "public_registry", "registry", "manual"].includes(
+  if (typeof record.id !== "string" || typeof record.name !== "string" || !["mcp", "api", "skill", "plugin"].includes(String(kind)) || !["built_in", "library", "configured", "public_registry", "registry", "manual"].includes(
     String(source)
   ) || !["connect", "add_credentials", "enable"].includes(String(action)) || typeof record.rationale !== "string") {
     return null;
@@ -1478,6 +2450,23 @@ function capabilityAuthorizationRequest(value) {
     requiredVariables: stringList(record.requiredVariables)
   };
 }
+function customMcpSetupRequest(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const input = value;
+  if (input.kind !== "mcp" || typeof input.name !== "string" || typeof input.rationale !== "string" || typeof input.endpointUrl !== "string")
+    return null;
+  try {
+    if (new URL(input.endpointUrl).protocol !== "https:") return null;
+  } catch {
+    return null;
+  }
+  return {
+    kind: "mcp",
+    name: input.name,
+    endpointUrl: input.endpointUrl,
+    rationale: input.rationale
+  };
+}
 function stringList(value) {
   return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [];
 }
@@ -1596,12 +2585,13 @@ function looksLikeId(value) {
 }
 
 export {
-  mcpToolLeaf,
-  toolDisplayName,
+  isTimelineUserQuestion,
   buildTimeline,
   creditExhaustedFromEvents,
   sessionStatusFromEvents,
   groupTimeline,
+  timelineQuestionPlacement,
+  isTurnExecutionEvidence,
   extractSessionRef
 };
-//# sourceMappingURL=chunk-6KLX2RH5.js.map
+//# sourceMappingURL=chunk-H2NJQORO.js.map