@opengeni/react 3.8.0-canary.1 → 4.0.1-canary.1

package/src/hooks/use-session-events.ts

@@ -102,34 +102,8 @@ const FOREGROUND_COMPACT_CATCHUP_MAX_GROUPS = 16;
 const FOREGROUND_COMPACT_CATCHUP_MAX_BYTES = 512 * 1024;
 const EMPTY_EVENTS: SessionEvent[] = [];
 const encoder = new TextEncoder();
-const decoder = new TextDecoder();
-
-const BROWSER_EVENT_TYPE_MAX_BYTES = 256;
-const BROWSER_EVENT_ID_MAX_BYTES = 256;
-const BROWSER_EVENT_CLIENT_ID_MAX_BYTES = 4 * 1024;
-const BROWSER_EVENT_DUPLICATE_REASON_MAX_BYTES = 4 * 1024;
-const BROWSER_EVENT_PAYLOAD_PREVIEW_MAX_BYTES = 48 * 1024;
-const BROWSER_EVENT_PAYLOAD_IDENTITY_FIELDS = [
-  "id",
-  "callId",
-  "call_id",
-  "name",
-  "toolName",
-  "status",
-  "code",
-  "isError",
-  "stream",
-  "commandId",
-  "sequence",
-  "coalescedUntil",
-  "coalescedCount",
-  "firstSequence",
-  "lastSequence",
-] as const;
-
 export const SESSION_EVENT_BROWSER_MAX_BYTES = 8 * 1024 * 1024;
 export const SESSION_EVENT_BROWSER_MAX_COUNT = 10_000;
-export const SESSION_EVENT_BROWSER_SINGLE_EVENT_MAX_BYTES = 96 * 1024;
 export const SESSION_EVENT_BROWSER_PENDING_MAX_BYTES = 1024 * 1024;
 export const SESSION_EVENT_BROWSER_PENDING_MAX_COUNT = 256;
 
@@ -482,7 +456,7 @@ export function useSessionEvents(
         });
         for await (const event of stream) {
           if (!isCurrent()) break;
-          const boundedEvent = boundBrowserLegacyEvent(event);
+          const boundedEvent = event;
           const boundedEventBytes = browserJsonBytes(boundedEvent);
           const separatorBytes = pending.length === 0 ? 0 : 1;
           if (
@@ -556,7 +530,7 @@ export function useSessionEvents(
 
   const loadOlder = useCallback(
     (): OlderHistoryLoadReceipt =>
-      createOlderHistoryLoadReceipt(async (markCommitted) => {
+      createOlderHistoryLoadReceipt(async (markCommitted, preserveTail, markTailPreserved) => {
         if (!sessionId || navigationBusy() || !hasOlderRef.current) {
           return false;
         }
@@ -592,11 +566,17 @@ export function useSessionEvents(
           // Freeze the live iterator before replacing its in-memory window. Rows
           // pending in the aborted iterator were never cursor-committed and will
           // be replayed from the retained high-water mark below.
-          streamAbortRef.current?.abort();
-          const status = observeSessionStatus(window.events, sessionStatusRef);
           const next = boundBrowserSessionEventWindow([...window.events, ...current.events], {
             direction: "oldest",
           });
+          if (preserveTail && maxResumeSequence(next.events) < maxResumeSequence(current.events)) {
+            // Automatic viewport filling must not navigate away from the
+            // reader's retained tail. Explicit history navigation may do so.
+            markTailPreserved();
+            return false;
+          }
+          streamAbortRef.current?.abort();
+          const status = observeSessionStatus(window.events, sessionStatusRef);
           const retained = {
             ...next,
             truncated: current.truncated || next.truncated,
@@ -904,7 +884,8 @@ export function useSessionEvents(
  * deliberately separate from durable history and transport paging: when a
  * backward page evicts the live tail, the hook enters bounded history mode and
  * preserves the highest-ever-observed sequence separately for forward paging.
- * The source event remains durable in PostgreSQL throughout.
+ * The source event remains durable in PostgreSQL throughout. An event larger
+ * than the byte target is retained alone, never replaced by a lossy preview.
  */
 export function boundBrowserSessionEventWindow(
   events: readonly SessionEvent[],
@@ -916,7 +897,7 @@ export function boundBrowserSessionEventWindow(
 ): BrowserSessionEventWindow {
   const maxBytes = Math.max(1024, options.maxBytes ?? SESSION_EVENT_BROWSER_MAX_BYTES);
   const maxCount = Math.max(1, Math.floor(options.maxCount ?? SESSION_EVENT_BROWSER_MAX_COUNT));
-  const safe = events.map(boundBrowserLegacyEvent);
+  const safe = events;
   const selected: SessionEvent[] = [];
   let bytes = 2; // []
   const direction = options.direction ?? "newest";
@@ -927,7 +908,7 @@ export function boundBrowserSessionEventWindow(
     const event = safe[index]!;
     const eventBytes = browserJsonBytes(event);
     const separator = selected.length === 0 ? 0 : 1;
-    if (bytes + separator + eventBytes > maxBytes) break;
+    if (selected.length > 0 && bytes + separator + eventBytes > maxBytes) break;
     selected.push(event);
     bytes += separator + eventBytes;
   }
@@ -939,248 +920,8 @@ export function boundBrowserSessionEventWindow(
   };
 }
 
-function boundBrowserLegacyEvent(event: SessionEvent): SessionEvent {
-  // The server-side canonical projection lives in @opengeni/contracts. The
-  // publishable React package may depend only on the zero-runtime-dependency
-  // SDK, so this is intentionally a last-resort client guard rather than a
-  // second durable representation. Reconstructing the SDK wire shape prevents
-  // legacy/malformed extra properties from bypassing the browser byte cap.
-  const serialized = browserSerialize(event);
-  const originalBytes = serialized.serializable
-    ? encoder.encode(serialized.value).byteLength
-    : null;
-  const typeIsSafe =
-    browserUtf8Bytes(event.type) <= BROWSER_EVENT_TYPE_MAX_BYTES &&
-    !event.type.includes("\n") &&
-    !event.type.includes("\r");
-  const clientEventId = boundBrowserOptionalText(
-    event.clientEventId,
-    BROWSER_EVENT_CLIENT_ID_MAX_BYTES,
-  );
-  const duplicateReason = boundBrowserOptionalText(
-    event.duplicateReason,
-    BROWSER_EVENT_DUPLICATE_REASON_MAX_BYTES,
-  );
-
-  if (
-    serialized.serializable &&
-    originalBytes !== null &&
-    originalBytes <= SESSION_EVENT_BROWSER_SINGLE_EVENT_MAX_BYTES &&
-    typeIsSafe &&
-    clientEventId === event.clientEventId &&
-    duplicateReason === event.duplicateReason
-  ) {
-    return event;
-  }
-
-  const envelopeProjection = [
-    !typeIsSafe
-      ? browserEnvelopeFieldProjection("type", event.type, "session.event.envelope_omitted")
-      : null,
-    clientEventId !== event.clientEventId
-      ? browserEnvelopeFieldProjection("clientEventId", event.clientEventId, clientEventId)
-      : null,
-    duplicateReason !== event.duplicateReason
-      ? browserEnvelopeFieldProjection("duplicateReason", event.duplicateReason, duplicateReason)
-      : null,
-  ].filter((field) => field !== null);
-  const payloadSerialization = browserSerialize(event.payload);
-  const payloadBytes = payloadSerialization.serializable
-    ? encoder.encode(payloadSerialization.value).byteLength
-    : null;
-  const preview = truncateBrowserUtf8Middle(
-    payloadSerialization.value,
-    BROWSER_EVENT_PAYLOAD_PREVIEW_MAX_BYTES,
-  );
-  const truncation = {
-    truncated: true as const,
-    surface: "browser_legacy_guard" as const,
-    reason: serialized.serializable ? "event_envelope_bytes_exceeded" : "event_not_serializable",
-    originalBytes,
-    deliveredBytes: 0,
-    omittedBytes: originalBytes,
-    estimatedOriginalTokens: originalBytes === null ? null : Math.ceil(originalBytes / 4),
-    estimatedDeliveredTokens: 0,
-    fullEvidence: { available: false as const, reason: "not_retained" as const },
-    details: [
-      {
-        path: "$.payload",
-        kind: "payload_preview",
-        originalBytes: payloadBytes,
-        deliveredBytes: browserUtf8Bytes(preview),
-      },
-    ],
-  };
-  const payload: Record<string, unknown> = {
-    ...browserPayloadIdentity(event.payload),
-    preview,
-    ...(envelopeProjection.length > 0
-      ? {
-          originalType: boundBrowserText(event.type, BROWSER_EVENT_TYPE_MAX_BYTES),
-          envelopeProjection: {
-            truncated: true,
-            surface: "browser_legacy_guard",
-            fields: envelopeProjection,
-          },
-        }
-      : {}),
-    truncation,
-  };
-  const bounded: SessionEvent = {
-    id: boundBrowserText(event.id, BROWSER_EVENT_ID_MAX_BYTES),
-    workspaceId: boundBrowserText(event.workspaceId, BROWSER_EVENT_ID_MAX_BYTES),
-    sessionId: boundBrowserText(event.sessionId, BROWSER_EVENT_ID_MAX_BYTES),
-    sequence: event.sequence,
-    type: typeIsSafe ? event.type : "session.event.envelope_omitted",
-    payload,
-    occurredAt: boundBrowserText(event.occurredAt, BROWSER_EVENT_ID_MAX_BYTES),
-    clientEventId,
-    turnId: boundBrowserOptionalText(event.turnId, BROWSER_EVENT_ID_MAX_BYTES),
-    turnGeneration: event.turnGeneration,
-    turnAttemptId: boundBrowserOptionalText(event.turnAttemptId, BROWSER_EVENT_ID_MAX_BYTES),
-    turnAssociation: event.turnAssociation,
-    duplicateOfEventId: boundBrowserOptionalText(
-      event.duplicateOfEventId,
-      BROWSER_EVENT_ID_MAX_BYTES,
-    ),
-    duplicateReason,
-  };
-
-  settleBrowserEventTruncation(bounded, truncation);
-  if (browserJsonBytes(bounded) > SESSION_EVENT_BROWSER_SINGLE_EVENT_MAX_BYTES) {
-    payload.preview = truncateBrowserUtf8Middle(String(payload.preview), 4 * 1024);
-    truncation.details = truncation.details.slice(0, 1);
-    settleBrowserEventTruncation(bounded, truncation);
-  }
-  if (browserJsonBytes(bounded) > SESSION_EVENT_BROWSER_SINGLE_EVENT_MAX_BYTES) {
-    bounded.clientEventId = null;
-    bounded.duplicateReason = null;
-    payload.preview = "[legacy event omitted at the browser byte boundary]";
-    settleBrowserEventTruncation(bounded, truncation);
-  }
-  return bounded;
-}
-
 function browserJsonBytes(value: unknown): number {
-  return encoder.encode(browserSerialize(value).value).byteLength;
-}
-
-function browserSerialize(value: unknown): { value: string; serializable: boolean } {
-  try {
-    const serialized = JSON.stringify(value);
-    return { value: serialized === undefined ? "null" : serialized, serializable: true };
-  } catch {
-    return {
-      value: '"[unserializable event payload omitted at browser boundary]"',
-      serializable: false,
-    };
-  }
-}
-
-function browserPayloadIdentity(payload: unknown): Record<string, unknown> {
-  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return {};
-  const record = payload as Record<string, unknown>;
-  const identity: Record<string, unknown> = {};
-  for (const field of BROWSER_EVENT_PAYLOAD_IDENTITY_FIELDS) {
-    const value = record[field];
-    if (typeof value === "string") {
-      identity[field] = boundBrowserText(value, BROWSER_EVENT_ID_MAX_BYTES);
-    } else if (typeof value === "number" || typeof value === "boolean" || value === null) {
-      identity[field] = value;
-    }
-  }
-  return identity;
-}
-
-function browserEnvelopeFieldProjection(
-  field: string,
-  original: string | null | undefined,
-  delivered: string | null | undefined,
-): { field: string; originalBytes: number; deliveredBytes: number } {
-  return {
-    field,
-    originalBytes: typeof original === "string" ? browserUtf8Bytes(original) : 0,
-    deliveredBytes: typeof delivered === "string" ? browserUtf8Bytes(delivered) : 0,
-  };
-}
-
-function boundBrowserOptionalText<T extends string | null | undefined>(
-  value: T,
-  maxBytes: number,
-): T {
-  return (typeof value === "string" ? boundBrowserText(value, maxBytes) : value) as T;
-}
-
-function boundBrowserText(value: string, maxBytes: number): string {
-  const bytes = encoder.encode(value);
-  if (bytes.byteLength <= maxBytes) return value;
-  const marker = "…[truncated]";
-  const prefixBudget = Math.max(0, maxBytes - browserUtf8Bytes(marker));
-  let prefixEnd = Math.min(prefixBudget, bytes.byteLength);
-  while (
-    prefixEnd > 0 &&
-    prefixEnd < bytes.byteLength &&
-    isBrowserUtf8Continuation(bytes[prefixEnd]!)
-  ) {
-    prefixEnd -= 1;
-  }
-  return `${decoder.decode(bytes.subarray(0, prefixEnd))}${marker}`;
-}
-
-function truncateBrowserUtf8Middle(value: string, maxBytes: number): string {
-  const bytes = encoder.encode(value);
-  if (bytes.byteLength <= maxBytes) return value;
-  const marker = `…[${bytes.byteLength - maxBytes} bytes omitted]…`;
-  const contentBudget = Math.max(0, maxBytes - browserUtf8Bytes(marker));
-  const leftBudget = Math.floor(contentBudget / 2);
-  const rightBudget = contentBudget - leftBudget;
-  let leftEnd = Math.min(leftBudget, bytes.byteLength);
-  while (leftEnd > 0 && leftEnd < bytes.byteLength && isBrowserUtf8Continuation(bytes[leftEnd]!)) {
-    leftEnd -= 1;
-  }
-  let rightStart = Math.max(0, bytes.byteLength - rightBudget);
-  while (rightStart < bytes.byteLength && isBrowserUtf8Continuation(bytes[rightStart]!)) {
-    rightStart += 1;
-  }
-  return `${decoder.decode(bytes.subarray(0, leftEnd))}${marker}${decoder.decode(bytes.subarray(rightStart))}`;
-}
-
-function settleBrowserEventTruncation(
-  event: SessionEvent,
-  truncation: {
-    originalBytes: number | null;
-    deliveredBytes: number;
-    omittedBytes: number | null;
-    estimatedDeliveredTokens: number;
-  },
-): void {
-  for (let attempt = 0; attempt < 16; attempt += 1) {
-    const deliveredBytes = browserJsonBytes(event);
-    const omittedBytes =
-      truncation.originalBytes === null
-        ? null
-        : Math.max(0, truncation.originalBytes - deliveredBytes);
-    const estimatedDeliveredTokens = Math.ceil(deliveredBytes / 4);
-    if (
-      truncation.deliveredBytes === deliveredBytes &&
-      truncation.omittedBytes === omittedBytes &&
-      truncation.estimatedDeliveredTokens === estimatedDeliveredTokens
-    ) {
-      return;
-    }
-    truncation.deliveredBytes = deliveredBytes;
-    truncation.omittedBytes = omittedBytes;
-    truncation.estimatedDeliveredTokens = estimatedDeliveredTokens;
-  }
-  throw new RangeError("Browser event byte accounting did not converge");
-}
-
-function browserUtf8Bytes(value: string): number {
-  return encoder.encode(value).byteLength;
-}
-
-function isBrowserUtf8Continuation(value: number): boolean {
-  return (value & 0xc0) === 0x80;
+  return encoder.encode(JSON.stringify(value)).byteLength;
 }
 
 function observeSessionStatus(
@@ -1240,9 +981,7 @@ async function planForegroundCatchup(
     pageSize: rawGap,
     ...(options.signal ? { signal: options.signal } : {}),
   });
-  const events = page
-    .filter((event) => eventResumeSequence(event) > cursor)
-    .map(boundBrowserLegacyEvent);
+  const events = page.filter((event) => eventResumeSequence(event) > cursor);
   if (events.length === 0) {
     return { kind: "reload" };
   }

package/src/index.ts

@@ -48,7 +48,6 @@ export {
   SESSION_EVENT_BROWSER_MAX_COUNT,
   SESSION_EVENT_BROWSER_PENDING_MAX_BYTES,
   SESSION_EVENT_BROWSER_PENDING_MAX_COUNT,
-  SESSION_EVENT_BROWSER_SINGLE_EVENT_MAX_BYTES,
   boundBrowserSessionEventWindow,
   useSessionEvents,
 } from "./hooks/use-session-events";

package/src/older-history.ts

@@ -8,6 +8,7 @@
  */
 export type OlderHistoryLoadReceipt = Promise<boolean> & {
   readonly committed: boolean;
+  readonly tailPreserved?: boolean;
 };
 
 /**
@@ -22,23 +23,29 @@ export type OlderHistoryLoader = () => unknown;
 
 type MutableOlderHistoryLoadReceipt = Promise<boolean> & {
   committed: boolean;
+  tailPreserved: boolean;
 };
 
 type OlderHistoryReceiptCapture = (receipt: OlderHistoryLoadReceipt) => void;
 
 let activeReceiptCapture: OlderHistoryReceiptCapture | undefined;
+let preserveTailForAutomaticLoad = false;
 
 /** Bind a receipt before a synchronous forwarding stack can publish state. */
 export function invokeOlderHistoryLoaderWithReceiptCapture(
   load: OlderHistoryLoader,
   capture: OlderHistoryReceiptCapture,
+  preserveTail = false,
 ): unknown {
   const previousCapture = activeReceiptCapture;
+  const previousPreserveTail = preserveTailForAutomaticLoad;
   activeReceiptCapture = capture;
+  preserveTailForAutomaticLoad = preserveTail;
   try {
     return load();
   } finally {
     activeReceiptCapture = previousCapture;
+    preserveTailForAutomaticLoad = previousPreserveTail;
   }
 }
 
@@ -47,7 +54,11 @@ export function invokeOlderHistoryLoaderWithReceiptCapture(
  * Call `markCommitted` immediately before publishing an accepted older window.
  */
 export function createOlderHistoryLoadReceipt(
-  load: (markCommitted: () => void) => boolean | Promise<boolean>,
+  load: (
+    markCommitted: () => void,
+    preserveTail: boolean,
+    markTailPreserved: () => void,
+  ) => boolean | Promise<boolean>,
 ): OlderHistoryLoadReceipt {
   let resolveResult!: (value: boolean | PromiseLike<boolean>) => void;
   let rejectResult!: (reason?: unknown) => void;
@@ -56,11 +67,18 @@ export function createOlderHistoryLoadReceipt(
     rejectResult = reject;
   }) as MutableOlderHistoryLoadReceipt;
   result.committed = false;
+  result.tailPreserved = false;
   activeReceiptCapture?.(result);
   try {
-    const loaded = load(() => {
-      result.committed = true;
-    });
+    const loaded = load(
+      () => {
+        result.committed = true;
+      },
+      preserveTailForAutomaticLoad,
+      () => {
+        result.tailPreserved = true;
+      },
+    );
     Promise.resolve(loaded).then(resolveResult, rejectResult);
   } catch (error) {
     rejectResult(error);

package/src/timeline/platform-activity-row.tsx

@@ -65,7 +65,10 @@ export default function PlatformActivityRow({
   return j(ActivityDisclosure, {
     icon: j(BotIcon, { className: "size-3.5" }),
     iconTone: failed ? "failed" : running ? "running" : "muted",
-    title: startupPhaseTitle(item.phase, item.status, item.outcome),
+    title:
+      item.blockedReason === "rotation_in_progress"
+        ? "Waiting for sandbox rotation"
+        : startupPhaseTitle(item.phase, item.status, item.outcome),
     preview:
       item.phase === "model_preparation"
         ? "Includes overlapping sandbox, rig, repository, and runtime setup shown below."

package/src/timeline/projection.ts

@@ -135,6 +135,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
   const ordered = orderTimelineEvents(events, prescan);
   const pendingWaitOutcomeByTurn = new Map<string | null, PendingWaitOutcome>();
   const latestAgentResponseByTurn = new Map<string | null, TrackedAgentResponse>();
+  const identifiedMessages = new Map<string, AgentMessageItem>();
   const humanInputRequests = humanInputRequestsById(events);
   const humanInputToolCallIds = new Set(
     [...humanInputRequests.values()]
@@ -157,6 +158,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
     mode = 0,
     explicitStartedAt?: string,
     explicitId?: string,
+    blockedReason?: StartupPhaseItem["blockedReason"],
   ): void => {
     const key = `${startupTurnId}:${phase}`;
     const priorState = startupPhases.get(key);
@@ -183,6 +185,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
           ? elapsedDurationMs(open.startedAt, startupEvent.occurredAt)
           : Math.max(0, duration);
       open.outcome = outcome ?? open.outcome;
+      open.blockedReason = blockedReason;
       return;
     }
     const running = status === "running";
@@ -201,6 +204,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         completedAt: running ? null : startupEvent.occurredAt,
         durationMs,
         outcome,
+        blockedReason,
         occurredAt: startedAt,
       } satisfies Partial<StartupPhaseItem>);
       startupPhases.set(key, [prior, startupAttemptId, startupRecoveryRevision]);
@@ -216,6 +220,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
       completedAt: running ? null : startupEvent.occurredAt,
       durationMs,
       outcome,
+      blockedReason,
       occurredAt: startedAt,
     };
     items.push(item);
@@ -408,8 +413,43 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         if (!text) {
           break;
         }
+        const messageId = stringValue(payload.messageId);
+        const messageKey = messageId ? JSON.stringify([turnId, messageId]) : null;
+        const identified = messageKey ? identifiedMessages.get(messageKey) : undefined;
+        if (identified) {
+          if (identified.annotationSource?.eventType !== "agent.message.completed") {
+            identified.text += text;
+            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(
+                (item) =>
+                  item.kind === "tool-call" && item.turnId === turnId && item.status === "running",
+              )
+          ) {
+            // Legacy deltas have no provider message identity. Tool creation
+            // alone is not a text boundary; completed output still is.
+            previous.item.text += text;
+            break;
+          }
+        }
+        if (
+          !messageKey &&
+          open?.kind === "agent-message" &&
+          open.streaming &&
+          open.turnId === turnId
+        ) {
           open.text += text;
           rememberAgentResponse(turnId, open, false);
           break;
@@ -424,18 +464,21 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
           occurredAt: event.occurredAt,
         };
         items.push(item);
+        if (messageKey) identifiedMessages.set(messageKey, item);
         rememberAgentResponse(turnId, item, false);
         break;
       }
 
       case "agent.message.completed": {
         const text = stringValue(payload.text);
+        const messageId = stringValue(payload.messageId);
+        const messageKey = messageId ? JSON.stringify([turnId, messageId]) : null;
         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.
-        let openIndex = -1;
-        for (let index = items.length - 1; index >= 0; index -= 1) {
+        let openIndex = messageKey ? items.indexOf(identifiedMessages.get(messageKey)!) : -1;
+        for (let index = messageKey ? -1 : items.length - 1; index >= 0; index -= 1) {
           const candidate = items[index];
           if (candidate?.kind === "agent-message" && candidate.turnId === turnId) {
             openIndex = index;
@@ -447,10 +490,15 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
           candidate?.kind === "agent-message" ? candidate : undefined;
         if (
           open &&
-          (open.streaming || !open.text || text === open.text || text.startsWith(open.text))
+          (messageKey ||
+            open.streaming ||
+            !open.text ||
+            text === open.text ||
+            text.startsWith(open.text))
         ) {
-          // The completed text is authoritative when it extends what streamed.
-          if (!open.text || (text && text.startsWith(open.text))) {
+          // Identity makes the final text authoritative even if it corrects the
+          // draft; legacy receipts still require an extension match.
+          if (!open.text || (text && (messageKey || text.startsWith(open.text)))) {
             open.text = text || open.text;
           }
           open.streaming = false;
@@ -502,6 +550,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
             },
           };
           items.push(item);
+          if (messageKey) identifiedMessages.set(messageKey, item);
           rememberAgentResponse(turnId, item, true);
         }
         break;
@@ -693,7 +742,18 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         const startupPhase = startupPhaseForSandboxOperation(name);
         if (startupPhase) {
           closeStreamingTail();
-          settleStartupPhase(startupPhase, status, numberOrNull(payload.durationMs), origin);
+          settleStartupPhase(
+            startupPhase,
+            status,
+            numberOrNull(payload.durationMs),
+            origin,
+            0,
+            undefined,
+            undefined,
+            status === "cancelled" && payload.failureCode === "rotation_in_progress"
+              ? "rotation_in_progress"
+              : undefined,
+          );
           break;
         }
         // Routine per-turn platform plumbing that runs before EVERY turn to
@@ -1039,11 +1099,17 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
           }
         }
         finalizeOpen(turnId, "complete", event.occurredAt);
-        items.push(turnEndItem(event, "complete", null));
+        const completedTurn = turnEndItem(event, "complete", null);
+        items.push(completedTurn);
         const hasCompletedFinalResponse =
           latestAgentResponse?.completed === true &&
           latestAgentResponse.item.phase !== "commentary" &&
           Boolean(visibleTrackedResponse);
+        if (!hasAuthoritativeFinalOutput && pendingWaitOutcome) {
+          // Preserve existing prose, including delta-only streams, when a
+          // trailing wait yields without a terminal output receipt.
+          completedTurn.preserveWaitResponse = true;
+        }
         if (!hasAuthoritativeFinalOutput && !hasCompletedFinalResponse && pendingWaitOutcome) {
           items.push({
             kind: "notice",
@@ -1808,7 +1874,31 @@ function foldSettledTurn(groups: TimelineGroup[], turnEnd: TurnEndItem): void {
     return;
   }
 
-  const finalMessage = extractFinalAgentMessage(collected, turnEnd);
+  // Resolve only inside this turn's collected suffix. A user/machine-input
+  // boundary or an interleaved foreign turn must never donate its answer.
+  const waitMessages = turnEnd.preserveWaitResponse
+    ? collected.filter(
+        (group): group is Extract<TimelineGroup, { kind: "item" }> =>
+          group.kind === "item" &&
+          group.item.kind === "agent-message" &&
+          !group.item.streaming &&
+          group.item.text.trim().length > 0 &&
+          belongsToTurn(group.item, turnEnd.turnId),
+      )
+    : [];
+  // A completed answer outranks later commentary. Otherwise use the latest
+  // visible existing prose, ignoring whitespace and opaque-only stream tails.
+  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

package/src/timeline/types.ts

@@ -215,6 +215,7 @@ export type StartupPhaseItem = {
   durationMs: number | null;
   /** Sandbox origin and rig marker outcomes refine the settled label only. */
   outcome: "created" | "restored" | "resumed" | "skipped" | null;
+  blockedReason?: "rotation_in_progress" | undefined;
   occurredAt: string;
 };
 
@@ -451,6 +452,8 @@ export type TurnOutcome = "complete" | "failed" | "cancelled";
 
 export type TurnEndItem = {
   kind: "turn-end";
+  /** Keep an existing answer visible when a recorded input wait ends without final output. */
+  preserveWaitResponse?: true;
   id: string;
   turnId: string | null;
   outcome: TurnOutcome;