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

package/src/hooks/use-codex-accounts.ts

@@ -15,7 +15,16 @@ import {
 
 /** Events that change which Codex account a session runs on (or just ran). */
 export function isCodexAccountEvent(event: Pick<SessionEvent, "type">): boolean {
-  return event.type === "codex.account.switched";
+  return [
+    "codex.account.switched",
+    "codex.account.selection.changed",
+    "codex.capacity.waiting",
+    "codex.capacity.resumed",
+    "codex.capacity.superseded",
+    "turn.completed",
+    "turn.failed",
+    "turn.cancelled",
+  ].includes(event.type);
 }
 
 /**
@@ -30,12 +39,16 @@ export type CodexAccountsClientLike = {
   getSession?: (
     workspaceId: string,
     sessionId: string,
-  ) => Promise<{ codexPinnedCredentialId?: string | null; codexLastCredentialId?: string | null }>;
+  ) => Promise<{
+    codexPinnedCredentialId?: string | null;
+    codexLastCredentialId?: string | null;
+    codexCurrentSelection?: { credentialId: string | null; waiting: boolean } | null;
+  }>;
   pinSessionCodexAccount?: (
     workspaceId: string,
     sessionId: string,
     target: string,
-  ) => Promise<{ pinned: string }>;
+  ) => Promise<{ pinned: string; appliedTo?: "waiting_turn" | "next_turn" }>;
   /** Optional (absent ⇒ the card hides live refresh): batched live /wham/usage refresh. */
   refreshCodexUsage?: (workspaceId: string) => Promise<{ usage: Record<string, unknown> }>;
 };
@@ -55,8 +68,10 @@ export type UseCodexAccountsResult = {
   activeAccountId: string | null;
   /** The session's PINNED account (null ⇒ following workspace active). */
   pinnedAccountId: string | null;
-  /** The account the next turn will run on: pin > workspace active. */
+  /** Current preference only; automatic allocation can choose another account. */
   effectiveAccountId: string | null;
+  currentSelection: { credentialId: string | null; waiting: boolean } | null;
+  switchAppliedTo: "waiting_turn" | "next_turn" | null;
   /** The account the session's last turn ACTUALLY ran on (the "Running on:" source). */
   lastAccountId: string | null;
   settings: CodexRotationSettings;
@@ -85,6 +100,7 @@ const EMPTY_SETTINGS: CodexRotationSettings = {
 };
 
 type CodexAccountsState = {
+  currentSelection: { credentialId: string | null; waiting: boolean } | null;
   accounts: CodexAccount[];
   activeAccountId: string | null;
   settings: CodexRotationSettings;
@@ -93,6 +109,7 @@ type CodexAccountsState = {
 };
 
 const EMPTY_STATE: CodexAccountsState = {
+  currentSelection: null,
   accounts: [],
   activeAccountId: null,
   settings: EMPTY_SETTINGS,
@@ -121,6 +138,7 @@ export function useCodexAccounts(options: UseCodexAccountsOptions = {}): UseCode
         : Promise.resolve(null);
     const [acc, session] = await Promise.all([accountsP, sessionP]);
     return {
+      currentSelection: session?.codexCurrentSelection ?? null,
       accounts: acc.accounts,
       activeAccountId: acc.activeAccountId,
       settings: acc.settings,
@@ -140,6 +158,10 @@ export function useCodexAccounts(options: UseCodexAccountsOptions = {}): UseCode
   const { run: runMutation, mutating: pinning, mutationError } = useMutationRunner();
   const { run: runUsageMutation, mutating: refreshingUsage } = useMutationRunner();
   const [pinningTarget, setPinningTarget] = useState<string | null>(null);
+  const [switchReceipt, setSwitchReceipt] = useState<{
+    sessionId: string;
+    appliedTo: "waiting_turn" | "next_turn";
+  } | null>(null);
 
   // Refresh only after the durable post-selection event. `turn.started` is
   // emitted before account selection settles and races this authoritative read.
@@ -161,8 +183,10 @@ export function useCodexAccounts(options: UseCodexAccountsOptions = {}): UseCode
         return false;
       }
       setPinningTarget(target);
+      setSwitchReceipt(null);
       const result = await runMutation(async () => {
-        await codexClient.pinSessionCodexAccount!(workspaceId, sessionId, target);
+        const receipt = await codexClient.pinSessionCodexAccount!(workspaceId, sessionId, target);
+        setSwitchReceipt({ sessionId, appliedTo: receipt.appliedTo ?? "next_turn" });
         return true;
       });
       setPinningTarget(null);
@@ -191,6 +215,9 @@ export function useCodexAccounts(options: UseCodexAccountsOptions = {}): UseCode
   const effectiveAccountId = data.pinnedAccountId ?? data.activeAccountId;
 
   return {
+    currentSelection: data.currentSelection,
+    switchAppliedTo:
+      switchReceipt?.sessionId === sessionId ? (switchReceipt?.appliedTo ?? null) : null,
     accounts: data.accounts,
     activeAccountId: data.activeAccountId,
     pinnedAccountId: data.pinnedAccountId,

package/src/hooks/use-composer.ts

@@ -424,6 +424,8 @@ export type ComposerState = {
   /** Newly captured annotation the review surface should focus. */
   annotationReviewTargetId?: string | null | undefined;
   clearAnnotationReviewTarget?: (() => void) | undefined;
+  /** Focus an annotation, or the first incomplete note when omitted. */
+  requestAnnotationReview?: ((id?: string) => void) | undefined;
   /** Read the current draft synchronously before a destructive replacement. */
   hasDraftContent: () => boolean;
   /** Append the draft behind prompts already visible in the queue. */
@@ -2458,6 +2460,20 @@ export function useComposer(
     setAnnotationReviewTargetId(null);
   }, []);
 
+  const requestAnnotationReview = useCallback((id?: string) => {
+    const current = annotationsRef.current;
+    if (current.length === 0) {
+      setAnnotationReviewTargetId(null);
+      return;
+    }
+    if (id && current.some((annotation) => annotation.id === id)) {
+      setAnnotationReviewTargetId(id);
+      return;
+    }
+    const incomplete = current.find((annotation) => annotation.note.trim().length === 0);
+    setAnnotationReviewTargetId(incomplete?.id ?? current[0]!.id);
+  }, []);
+
   const updatePolicy = useCallback(
     (next: ComposerPolicy): void => {
       if (targetKeyRef.current !== targetKey) return;
@@ -2643,6 +2659,7 @@ export function useComposer(
     removeAnnotation,
     annotationReviewTargetId: identityMatches ? annotationReviewTargetId : null,
     clearAnnotationReviewTarget,
+    requestAnnotationReview,
     hasDraftContent,
     send,
     optimisticMessages: visibleOptimisticMessages,

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."