@opengeni/react 1.0.1 → 2.3.0-canary.0

package/src/timeline/projection.ts

@@ -1,5 +1,8 @@
 import {
   parseMediaGenerationResult,
+  type HumanInputAnswer,
+  type HumanInputQuestion,
+  type HumanInputResponse,
   type SessionEvent,
   type SessionStatus,
   type TimelineAnnotation,
@@ -18,9 +21,13 @@ import type {
   AuthNeededItem,
   ContextCompactionItem,
   GoalItem,
+  HumanInputAnswerSummary,
+  HumanInputItem,
   MachineInputBatchItem,
   MemoryItem,
   SandboxItem,
+  StartupPhase,
+  StartupPhaseItem,
   SessionStatusItem,
   TimelineGroup,
   TimelineItem,
@@ -124,6 +131,92 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
   const items: TimelineItem[] = [];
   const prescan = prescanTurnAnchors(events);
   const ordered = orderTimelineEvents(events, prescan);
+  const humanInputRequests = humanInputRequestsById(events);
+  const humanInputToolCallIds = new Set(
+    [...humanInputRequests.values()]
+      .map((request) => stringValue(request.toolCallId))
+      .filter(Boolean),
+  );
+  const queuedAtByTurn = new Map<string, string>();
+  const startupRecoveryRevisionByTurn = new Map<string, number>();
+  const startupPhases = new Map<string, readonly [StartupPhaseItem, string | null, number]>();
+  let startupEvent: SessionEvent;
+  let startupTurnId: string | null = null;
+  let startupAttemptId: string | null = null;
+  let startupRecoveryRevision = 0;
+
+  const settleStartupPhase = (
+    phase: StartupPhase,
+    status: StartupPhaseItem["status"],
+    duration: number | null,
+    outcome: StartupPhaseItem["outcome"],
+    mode = 0,
+    explicitStartedAt?: string,
+    explicitId?: string,
+  ): void => {
+    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 : undefined;
+    const replacesPriorAttempt =
+      prior !== undefined &&
+      (comparedByAttempt ? !sameAttempt : startupRecoveryRevision > (priorState?.[2] ?? 0));
+    // A later activity attempt may replay preparation that the logical turn had
+    // already completed before the worker moved. Keep that first successful
+    // landmark; only an abandoned or failed attempt needs replacement.
+    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;
+      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,
+        occurredAt: startedAt,
+      } satisfies Partial<StartupPhaseItem>);
+      startupPhases.set(key, [prior, startupAttemptId, startupRecoveryRevision]);
+      return;
+    }
+    const item: StartupPhaseItem = {
+      kind: "startup-phase",
+      id: explicitId ?? startupEvent.id,
+      turnId: startupTurnId,
+      phase,
+      status,
+      startedAt,
+      completedAt: running ? null : startupEvent.occurredAt,
+      durationMs,
+      outcome,
+      occurredAt: startedAt,
+    };
+    items.push(item);
+    startupPhases.set(key, [item, startupAttemptId, startupRecoveryRevision]);
+  };
 
   const last = (): TimelineItem | undefined => items[items.length - 1];
 
@@ -138,6 +231,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
   const finalizeOpen = (
     turnId?: string | null,
     disposition: "complete" | "failed" | "cancelled" = "complete",
+    completedAt?: string,
   ): void => {
     for (const item of items) {
       if (
@@ -158,12 +252,47 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
       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 = asRecord(event.payload);
     const turnId = event.turnId ?? null;
+    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();
+      settleStartupPhase(
+        setupPhase,
+        setupStatus,
+        numberOrNull(payload.durationMs),
+        event.type === "rig.setup.skipped" ? "skipped" : null,
+      );
+      continue;
+    }
 
     switch (event.type) {
       case "user.message": {
@@ -191,6 +320,9 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         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: {
@@ -209,6 +341,18 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         break;
       }
 
+      case "user.humanInputResponse": {
+        // A structured answer resumes the frozen tool call rather than adding a
+        // synthetic user.message to model history. Keep the original question
+        // and the resolved human choice together as first-class chat history;
+        // neither belongs behind the generic activity fold.
+        const item = humanInputItemFromResponse(event, payload, humanInputRequests);
+        if (!item) break;
+        closeStreamingTail();
+        items.push(item);
+        break;
+      }
+
       case "system.update.delivered": {
         const inputs = machineInputMembers(payload.members);
         if (inputs.length === 0) break;
@@ -253,6 +397,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
 
       case "agent.message.completed": {
         const text = stringValue(payload.text);
+        const phase = assistantMessagePhase(payload.phase);
         // Reconcile the most recent same-turn agent message — even when
         // activity (tool calls, reasoning) landed after its deltas — so the
         // completed text never duplicates the streamed one.
@@ -276,6 +421,9 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
             open.text = text || open.text;
           }
           open.streaming = false;
+          // A phase-less settlement mirror (the worker's final-output receipt)
+          // must not erase the provider-declared phase captured by the SDK item.
+          if (phase) open.phase = phase;
           // Completion time is what the footer shows ("finished at"); keep the
           // first-delta stamp only until this event arrives.
           open.occurredAt = event.occurredAt;
@@ -307,6 +455,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
             id: event.id,
             turnId,
             text,
+            ...(phase ? { phase } : {}),
             streaming: false,
             occurredAt: event.occurredAt,
             annotationSource: {
@@ -349,6 +498,12 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         const callId = typeof payload.id === "string" ? payload.id : null;
         const args = payload.arguments ?? null;
         closeStreamingTail();
+        if (callId && humanInputToolCallIds.has(callId)) {
+          // The matching session.humanInput.requested / response lifecycle owns
+          // the visible chat card. Rendering the raw tool too would hide the
+          // decision behind a duplicate generic "Ask" step.
+          break;
+        }
         if (
           toolMatchesLeaf(name, WORKER_SPAWN_TOOL) ||
           toolMatchesLeaf(name, WORKER_MESSAGE_TOOL)
@@ -452,15 +607,58 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         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) break;
+        const queuedAt = queuedAtByTurn.get(turnId);
+        if (!queuedAt) break;
+        // Recovery starts the same logical turn again. Queue latency belongs to
+        // the first admission only, so consume the queued timestamp after its
+        // first projection instead of manufacturing another queue span.
+        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"
+          ? 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);
+          break;
+        }
         // Routine per-turn platform plumbing that runs before EVERY turn to
         // guarantee box contents survive a re-warm — NOT the agent redoing work:
         //   - repository-clone: idempotent clone check + off-manifest token re-seed;
@@ -480,13 +678,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         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}\n${message}` : message;
@@ -502,12 +694,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
             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,
           });
@@ -515,6 +702,29 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         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": {
         // `chunk` is the canonical wire field; text/output are legacy shapes.
         const text =
@@ -572,7 +782,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
       }
 
       case "session.requiresAction": {
-        finalizeOpen(turnId);
+        finalizeOpen(turnId, "complete", event.occurredAt);
         items.push({
           kind: "notice",
           id: event.id,
@@ -639,6 +849,12 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         // Recovery requests are durable control-plane evidence, not a user
         // message or proof that recovery succeeded. Live state already exposes
         // a genuinely recovering session; keep the raw event in Debug/audit.
+        if (turnId) {
+          startupRecoveryRevisionByTurn.set(
+            turnId,
+            (startupRecoveryRevisionByTurn.get(turnId) ?? 0) + 1,
+          );
+        }
         break;
       }
 
@@ -700,7 +916,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         // adding a generic turn chip would falsely make it look like an
         // extra agent response.
         if (payload.maintenance === "context_compaction") {
-          finalizeOpen(turnId);
+          finalizeOpen(turnId, "complete", event.occurredAt);
           break;
         }
         // Credit exhaustion arrives as a NOMINALLY completed turn (`detail:
@@ -710,7 +926,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         // session looking healthy while every future turn silently dies, so it
         // projects exactly like a failed turn plus an explicit notice.
         if (isCreditExhaustionPayload(payload)) {
-          finalizeOpen(turnId);
+          finalizeOpen(turnId, "complete", event.occurredAt);
           items.push(turnEndItem(event, "failed", CREDIT_EXHAUSTION_MESSAGE));
           items.push({
             kind: "notice",
@@ -721,7 +937,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
           });
           break;
         }
-        finalizeOpen(turnId);
+        finalizeOpen(turnId, "complete", event.occurredAt);
         items.push(turnEndItem(event, "complete", null));
         break;
       }
@@ -738,7 +954,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         // spent once, on the turn-level outcome. Items caught mid-flight read
         // as calm "interrupted" (same as turn.cancelled); an item that itself
         // failed keeps its own failed status from its output event.
-        finalizeOpen(turnId, "cancelled");
+        finalizeOpen(turnId, "cancelled", event.occurredAt);
         items.push(turnEndItem(event, "failed", failureText));
         if (!hadActivity) {
           items.push({
@@ -760,7 +976,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
           break;
         }
         const hadActivity = hasTurnActivity(items, turnId);
-        finalizeOpen(turnId, "cancelled");
+        finalizeOpen(turnId, "cancelled", event.occurredAt);
         items.push(turnEndItem(event, "cancelled", null));
         if (!hadActivity) {
           items.push({
@@ -802,6 +1018,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
       case "goal.paused":
       case "goal.resumed":
       case "goal.cleared":
+      case "goal.held":
       case "goal.continuation": {
         // Agent tool mutations already appear as tool-call rows in the activity
         // cluster. Re-emitting them as GoalRow landmarks splits "N steps" mid-turn.
@@ -812,7 +1029,10 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
           kind: "goal",
           id: event.id,
           action: event.type.slice("goal.".length) as GoalItem["action"],
-          text: goalText(payload),
+          text:
+            event.type === "goal.held" && typeof payload.reason === "string" && payload.reason
+              ? payload.reason
+              : goalText(payload),
           occurredAt: event.occurredAt,
         });
         break;
@@ -849,6 +1069,134 @@ function realtimeVoiceMessage(payload: Record<string, unknown>): {
   return null;
 }
 
+function humanInputRequestsById(events: SessionEvent[]): Map<string, Record<string, unknown>> {
+  const requests = new Map<string, Record<string, unknown>>();
+  for (const event of events) {
+    if (event.type !== "session.humanInput.requested") continue;
+    const request = asRecord(asRecord(event.payload).request);
+    const requestId = stringValue(request.id);
+    if (requestId) requests.set(requestId, request);
+  }
+  return requests;
+}
+
+function humanInputItemFromResponse(
+  event: SessionEvent,
+  payload: Record<string, unknown>,
+  requests: Map<string, Record<string, unknown>>,
+): HumanInputItem | null {
+  const response = asRecord(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: HumanInputResponse =
+    outcome === "answered"
+      ? {
+          outcome,
+          answers: Array.isArray(response.answers)
+            ? response.answers
+                .map(asRecord)
+                .map(humanInputAnswer)
+                .filter((answer): answer is HumanInputAnswer => 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: unknown): HumanInputQuestion[] {
+  if (!Array.isArray(value)) return [];
+  return value.map(asRecord).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(asRecord).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: Record<string, unknown>): HumanInputAnswer | null {
+  const questionId = stringValue(value.questionId);
+  if (!questionId) return null;
+  return {
+    questionId,
+    values: Array.isArray(value.values)
+      ? value.values.filter((answer): answer is string => typeof answer === "string")
+      : [],
+    ...(typeof value.other === "string" && value.other ? { other: value.other } : {}),
+  };
+}
+
+function humanInputAnswerSummary(
+  answer: HumanInputAnswer,
+  question: HumanInputQuestion | undefined,
+): HumanInputAnswerSummary {
+  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: unknown): ToolCallItem["status"] {
   const raw = asRecord(rawValue);
   if (raw.type !== "hosted_tool_call") {
@@ -972,6 +1320,7 @@ function isActivityItem(item: TimelineItem): item is ActivityItem {
     case "tool-call":
     case "worker":
     case "sandbox":
+    case "startup-phase":
     case "memory":
     case "fleet-decision":
       return true;
@@ -1012,6 +1361,8 @@ type TurnAnchorPrescan = {
   queuedTurnByTrigger: Map<string, string>;
   startSeqByTrigger: Map<string, number>;
   cancelledBeforeStartTriggers: Set<string>;
+  directChatSequenceByTrigger: Map<string, number>;
+  explicitQueuedTriggers: Set<string>;
   startedTurnIds: Set<string>;
 };
 
@@ -1020,18 +1371,61 @@ function prescanTurnAnchors(events: SessionEvent[]): TurnAnchorPrescan {
   const queuedTurnByTrigger = new Map<string, string>();
   const startSeqByTrigger = new Map<string, number>();
   const cancelledTurnIds = new Set<string>();
+  const withdrawnTurnIds = new Set<string>();
   const fallbackSeqByTurn = new Map<string, number>();
+  const directChatSequenceByTrigger = new Map<string, number>();
+  const explicitQueuedTriggers = new Set<string>();
+  const queueSteerSequenceByTurn = new Map<string, number>();
   const startedTurnIds = new Set<string>();
+  const userMessageSequenceById = new Map<string, number>();
 
   for (const event of ordered) {
     const payload = asRecord(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;
     }
@@ -1060,6 +1454,10 @@ function prescanTurnAnchors(events: SessionEvent[]): TurnAnchorPrescan {
   }
 
   for (const [triggerEventId, turnId] of queuedTurnByTrigger) {
+    const queueSteerSequence = queueSteerSequenceByTurn.get(turnId);
+    if (queueSteerSequence !== undefined) {
+      directChatSequenceByTrigger.set(triggerEventId, queueSteerSequence);
+    }
     if (!startSeqByTrigger.has(triggerEventId)) {
       const fallbackSeq = fallbackSeqByTurn.get(turnId);
       if (fallbackSeq !== undefined) {
@@ -1071,7 +1469,7 @@ function prescanTurnAnchors(events: SessionEvent[]): TurnAnchorPrescan {
   const cancelledBeforeStartTriggers = new Set<string>();
   for (const [triggerEventId, turnId] of queuedTurnByTrigger) {
     if (
-      cancelledTurnIds.has(turnId) &&
+      (cancelledTurnIds.has(turnId) || withdrawnTurnIds.has(turnId)) &&
       !startSeqByTrigger.has(triggerEventId) &&
       !fallbackSeqByTurn.has(turnId)
     ) {
@@ -1083,6 +1481,8 @@ function prescanTurnAnchors(events: SessionEvent[]): TurnAnchorPrescan {
     queuedTurnByTrigger,
     startSeqByTrigger,
     cancelledBeforeStartTriggers,
+    directChatSequenceByTrigger,
+    explicitQueuedTriggers,
     startedTurnIds,
   };
 }
@@ -1095,8 +1495,22 @@ function orderTimelineEvents(events: SessionEvent[], prescan: TurnAnchorPrescan)
     if (event.type !== "user.message") {
       continue;
     }
+    // Steer is an accepted direction change, not waiting queue copy. Keep it
+    // directly in chat across refresh/reconnect even before its turn starts.
+    const directChatSequence = prescan.directChatSequenceByTrigger.get(event.id);
+    if (directChatSequence !== undefined) {
+      pushInsertion(insertions, directChatSequence, event);
+      continue;
+    }
     const queuedTurnId = prescan.queuedTurnByTrigger.get(event.id);
     if (!queuedTurnId) {
+      if (prescan.explicitQueuedTriggers.has(event.id)) {
+        const startSeq = prescan.startSeqByTrigger.get(event.id);
+        if (startSeq !== undefined) {
+          pushInsertion(insertions, startSeq, event);
+        }
+        continue;
+      }
       pushInsertion(insertions, event.sequence, event);
       continue;
     }
@@ -1160,6 +1574,7 @@ function isTurnExecutionEvidence(type: string): boolean {
     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" ||
@@ -1265,7 +1680,12 @@ function foldSettledTurn(groups: TimelineGroup[], turnEnd: TurnEndItem): void {
   }
 
   const finalMessage = extractFinalAgentMessage(collected, turnEnd);
-  const body = finalMessage ? collected.slice(0, -1) : collected;
+  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;
   }
@@ -1294,7 +1714,7 @@ function foldSettledTurn(groups: TimelineGroup[], turnEnd: TurnEndItem): void {
   groups.splice(
     startIndex,
     collected.length,
-    ...(finalMessage ? [turnGroup, finalMessage] : [turnGroup]),
+    ...(visibleMessage ? [turnGroup, visibleMessage] : [turnGroup]),
   );
 }
 
@@ -1303,6 +1723,7 @@ function isTurnBoundary(group: TimelineGroup | undefined): boolean {
     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.members.some((member) => member.kind === "media_generation_result")) ||
@@ -1350,6 +1771,43 @@ function extractFinalAgentMessage(
   return tail;
 }
 
+function hasOrdinaryFinalAgentMessage(groups: TimelineGroup[], turnEnd: TurnEndItem): boolean {
+  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: TimelineGroup[],
+  turnEnd: TurnEndItem,
+): Extract<TimelineGroup, { kind: "item" }> | null {
+  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: AgentMessageItem, turnId: string | null): boolean {
+  return !message.turnId || !turnId || message.turnId === turnId;
+}
+
 function groupStartedAt(group: TimelineGroup | undefined): string | undefined {
   if (!group) {
     return undefined;
@@ -1372,6 +1830,10 @@ function stringValue(value: unknown): string {
   return typeof value === "string" ? value : "";
 }
 
+function assistantMessagePhase(value: unknown): AgentMessageItem["phase"] {
+  return value === "commentary" || value === "final_answer" ? value : undefined;
+}
+
 function numberOrNull(value: unknown): number | null {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
@@ -1435,6 +1897,11 @@ function machineInputMembers(value: unknown): MachineInputBatchItem["members"] {
     "agent_steer_instruction",
     "child_terminal_result",
     "media_generation_result",
+    "child_requires_action",
+    "child_requires_action_resolved",
+    "child_paused",
+    "child_waiting_capacity",
+    "child_progress",
   ]);
   const classifications = new Set<MachineInputBatchItem["members"][number]["classification"]>([
     "success",
@@ -1639,6 +2106,38 @@ function findOpenSandbox(items: TimelineItem[], name: string): SandboxItem | und
     );
 }
 
+function startupPhaseForSandboxOperation(name: string): StartupPhase | null {
+  return SANDBOX_STARTUP_PHASES[name] ?? null;
+}
+
+function startupPhaseFromPayload(value: unknown): StartupPhase | null {
+  return typeof value === "string" && STARTUP_PHASES.has(value as StartupPhase)
+    ? (value as StartupPhase)
+    : null;
+}
+
+const SANDBOX_STARTUP_PHASES: Record<string, StartupPhase> = {
+  "sandbox.provision": "sandbox",
+  "repository-clone": "repository",
+  "file-resource-download": "files",
+};
+const STARTUP_PHASES = new Set<StartupPhase>([
+  "queue",
+  "sandbox",
+  "rig",
+  "repository",
+  "files",
+  "tools",
+  "model_preparation",
+  "provider_first_byte",
+]);
+
+function elapsedDurationMs(startedAt: string, completedAt: string): number | null {
+  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: Record<string, unknown>): string | null {
   for (const key of ["error", "message"] as const) {
     const value = payload[key];
@@ -1675,7 +2174,12 @@ function shouldSuppressAgentGoalLandmark(type: string, payload: Record<string, u
   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;