@opengeni/react 0.57.0 → 1.0.2-canary.37191796234001

package/dist/{chunk-B6WPZSTT.js → chunk-SJZDKVW2.js}

@@ -2,111 +2,120 @@ import {
   buildTimeline,
   groupTimeline,
   sessionStatusFromEvents
-} from "./chunk-6KLX2RH5.js";
+} from "./chunk-H2NJQORO.js";
 import {
   useDebouncedCallback,
   useMutationRunner,
   usePageLiveActivity,
   usePolledValue,
   useSessionEventTrigger
-} from "./chunk-KZ73RL76.js";
+} from "./chunk-YQEAA6LT.js";
+import {
+  normalizeError,
+  useErrorMessage
+} from "./chunk-UGLEYEMP.js";
 import {
   useEmbeddedFileAttachments,
-  useEmbeddedGoal,
   useEmbeddedHumanInputSession,
   useEmbeddedSession,
-  useEmbeddedSessionLineage,
-  useEmbeddedSessionMcpApprovalPolicy,
   useEmbeddedSessionRead
-} from "./chunk-C5ZPSSS5.js";
+} from "./chunk-NEXLLTP4.js";
 
-// src/hooks/use-session.ts
-import { useCallback, useEffect, useMemo, useState } from "react";
-function isTitleEvent(event) {
-  return event.type === "session.title_set";
+// src/human-input.ts
+function isActionableHumanInputRequest(request, nowMs = Date.now()) {
+  if (request.status !== "pending") return false;
+  if (!request.expiresAt) return true;
+  const deadline = Date.parse(request.expiresAt);
+  return Number.isFinite(deadline) && deadline > nowMs;
 }
-function useSession(sessionId, options = {}) {
-  const { client, workspaceId, workspaceControlEvent, registerSessionReconciler } = useEmbeddedSessionRead(options);
-  const enabled = (options.enabled ?? true) && Boolean(sessionId);
-  const [override, setOverride] = useState(null);
-  const { run, mutating, mutationError, clearMutationError } = useMutationRunner();
-  const load = useCallback(async () => {
-    if (!sessionId) {
-      return null;
+function humanInputRequestFromEvent(event) {
+  if (event.type !== "session.humanInput.requested" || !isRecord(event.payload)) return null;
+  const request = event.payload.request;
+  if (!isRecord(request) || typeof request.id !== "string" || !Array.isArray(request.questions)) {
+    return null;
+  }
+  return {
+    id: request.id,
+    turnId: event.turnId ?? null,
+    questions: request.questions,
+    allowSkip: request.allowSkip === true,
+    expiresAt: typeof request.expiresAt === "string" ? request.expiresAt : null
+  };
+}
+function projectPendingHumanInputRequests(events) {
+  const pending = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const requested = humanInputRequestFromEvent(event);
+    if (requested) {
+      pending.set(requested.id, requested);
+      continue;
     }
-    const fetched = await client.getSession(workspaceId, sessionId);
-    setOverride(null);
-    return fetched;
-  }, [client, workspaceId, sessionId]);
-  const { data, loading, error, refresh } = usePolledValue(load, {
-    pollIntervalMs: options.pollIntervalMs,
-    enabled
-  });
-  useEffect(() => {
-    if (enabled && workspaceControlEvent) void refresh();
-  }, [enabled, refresh, workspaceControlEvent]);
-  useEffect(() => {
-    if (!sessionId || !enabled) return;
-    return registerSessionReconciler(sessionId, "session", refresh);
-  }, [enabled, refresh, registerSessionReconciler, sessionId]);
-  const base = data ?? null;
-  const session = useMemo(
-    () => base && override && override.id === base.id ? { ...base, title: override.title, titleSource: override.titleSource } : base,
-    [base, override]
-  );
-  const onTitleEvent = useCallback(
-    (event) => {
-      const payload = event.payload ?? {};
-      const title = payload.title;
-      if (typeof title !== "string") {
-        return;
-      }
-      const source = payload.source === "user" || payload.source === "agent" ? payload.source : null;
-      setOverride((current) => {
-        const next = current ?? base;
-        if (!next) {
-          return current;
+    if (event.type === "user.humanInputResponse" && isRecord(event.payload)) {
+      if (typeof event.payload.requestId === "string") pending.delete(event.payload.requestId);
+      continue;
+    }
+    if (event.type === "turn.completed" || event.type === "turn.failed" || event.type === "turn.cancelled") {
+      for (const [id, request] of pending) {
+        if (request.turnId === null || event.turnId === null || event.turnId === void 0 || request.turnId === event.turnId) {
+          pending.delete(id);
         }
-        return { ...next, title, titleSource: source };
-      });
-    },
-    [base]
-  );
-  useSessionEventTrigger(client, workspaceId, sessionId, isTitleEvent, onTitleEvent, {
-    enabled,
-    ...options.events !== void 0 ? { events: options.events } : {}
-  });
-  const updateTitle = useCallback(
-    async (title) => {
-      if (!sessionId) {
-        return null;
       }
-      const result = await run(() => client.updateSession(workspaceId, sessionId, { title }));
-      if (result) {
-        setOverride(result);
+    }
+  }
+  return [...pending.values()];
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/older-history.ts
+var activeReceiptCapture;
+var preserveTailForAutomaticLoad = false;
+function invokeOlderHistoryLoaderWithReceiptCapture(load, capture, preserveTail = false) {
+  const previousCapture = activeReceiptCapture;
+  const previousPreserveTail = preserveTailForAutomaticLoad;
+  activeReceiptCapture = capture;
+  preserveTailForAutomaticLoad = preserveTail;
+  try {
+    return load();
+  } finally {
+    activeReceiptCapture = previousCapture;
+    preserveTailForAutomaticLoad = previousPreserveTail;
+  }
+}
+function createOlderHistoryLoadReceipt(load) {
+  let resolveResult;
+  let rejectResult;
+  const result = new Promise((resolve, reject) => {
+    resolveResult = resolve;
+    rejectResult = reject;
+  });
+  result.committed = false;
+  result.tailPreserved = false;
+  activeReceiptCapture?.(result);
+  try {
+    const loaded = load(
+      () => {
+        result.committed = true;
+      },
+      preserveTailForAutomaticLoad,
+      () => {
+        result.tailPreserved = true;
       }
-      return result;
-    },
-    [client, workspaceId, sessionId, run]
-  );
-  return {
-    session,
-    loading,
-    error,
-    refresh,
-    updateTitle,
-    updating: mutating,
-    mutationError,
-    clearMutationError
-  };
+    );
+    Promise.resolve(loaded).then(resolveResult, rejectResult);
+  } catch (error) {
+    rejectResult(error);
+  }
+  return result;
 }
 
 // src/hooks/use-session-events.ts
-import { useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo2, useRef, useState as useState2 } from "react";
-var INITIAL_TAIL_PAGE_SIZE = 1e3;
-var OLDER_PAGE_SIZE = 5e3;
-var NEWER_PAGE_SIZE = 5e3;
-var OLDEST_PAGE_SIZE = 1e3;
+import {
+  sessionEventStreamCoveredThrough
+} from "@opengeni/sdk";
+import { startTransition, useCallback, useEffect, useMemo, useRef, useState } from "react";
+var SESSION_HISTORY_PAGE_SIZE = 1e3;
 var INITIAL_FETCH_CAP = 1;
 var OLDER_GROUP_TARGET = 32;
 var OLDER_FETCH_CAP = 2;
@@ -114,35 +123,16 @@ var NEWER_GROUP_TARGET = 32;
 var NEWER_FETCH_CAP = 2;
 var OLDEST_GROUP_TARGET = 32;
 var OLDEST_FETCH_CAP = 2;
-var BOUNDARY_PAGE_CAP = 4;
+var BOUNDARY_PAGE_CAP = 1;
+var FOREGROUND_DIRECT_REPLAY_MAX_SEQUENCES = 16;
+var FOREGROUND_COMPACT_PROBE_MAX_SEQUENCES = SESSION_HISTORY_PAGE_SIZE;
+var FOREGROUND_COMPACT_CATCHUP_MAX_EVENTS = 128;
+var FOREGROUND_COMPACT_CATCHUP_MAX_GROUPS = 16;
+var FOREGROUND_COMPACT_CATCHUP_MAX_BYTES = 512 * 1024;
 var EMPTY_EVENTS = [];
 var encoder = new TextEncoder();
-var decoder = new TextDecoder();
-var BROWSER_EVENT_TYPE_MAX_BYTES = 256;
-var BROWSER_EVENT_ID_MAX_BYTES = 256;
-var BROWSER_EVENT_CLIENT_ID_MAX_BYTES = 4 * 1024;
-var BROWSER_EVENT_DUPLICATE_REASON_MAX_BYTES = 4 * 1024;
-var BROWSER_EVENT_PAYLOAD_PREVIEW_MAX_BYTES = 48 * 1024;
-var BROWSER_EVENT_PAYLOAD_IDENTITY_FIELDS = [
-  "id",
-  "callId",
-  "call_id",
-  "name",
-  "toolName",
-  "status",
-  "code",
-  "isError",
-  "stream",
-  "commandId",
-  "sequence",
-  "coalescedUntil",
-  "coalescedCount",
-  "firstSequence",
-  "lastSequence"
-];
-var SESSION_EVENT_BROWSER_MAX_BYTES = 8 * 1024 * 1024;
-var SESSION_EVENT_BROWSER_MAX_COUNT = 1e4;
-var SESSION_EVENT_BROWSER_SINGLE_EVENT_MAX_BYTES = 96 * 1024;
+var SESSION_EVENT_BROWSER_MAX_BYTES = 16 * 1024 * 1024;
+var SESSION_EVENT_BROWSER_MAX_COUNT = 2e4;
 var SESSION_EVENT_BROWSER_PENDING_MAX_BYTES = 1024 * 1024;
 var SESSION_EVENT_BROWSER_PENDING_MAX_COUNT = 256;
 var EMPTY_EVENT_WINDOW = {
@@ -159,21 +149,35 @@ function useSessionEvents(sessionId, options = {}) {
   const replay = options.replay ?? "windowed";
   const fullReplay = replay === "full" || after !== 0;
   const streamKey = `${workspaceId}\0${sessionId ?? ""}\0${after}\0${fullReplay ? "full" : "windowed"}`;
-  const [eventWindow, setEventWindow] = useState2(EMPTY_EVENT_WINDOW);
-  const [connectionState, setConnectionState] = useState2("idle");
-  const [error, setError] = useState2(null);
-  const [hasOlder, setHasOlder] = useState2(false);
-  const [hasNewer, setHasNewer] = useState2(false);
-  const [sessionStatusProjection, setSessionStatusProjection] = useState2(
+  const navigationIdentityRef = useRef({ client, streamKey, enabled });
+  if (navigationIdentityRef.current.client !== client || navigationIdentityRef.current.streamKey !== streamKey || navigationIdentityRef.current.enabled !== enabled) {
+    navigationIdentityRef.current = { client, streamKey, enabled };
+  }
+  const navigationIdentity = navigationIdentityRef.current;
+  const ownsNavigation = useCallback(
+    () => navigationIdentityRef.current === navigationIdentity,
+    [navigationIdentity]
+  );
+  const [eventWindow, setEventWindow] = useState(EMPTY_EVENT_WINDOW);
+  const [questionEvidence, setQuestionEvidence] = useState(null);
+  const [connectionState, setConnectionState] = useState("idle");
+  const [error, setError] = useState(null);
+  const [newerError, setNewerError] = useState(null);
+  const [hasOlder, setHasOlder] = useState(false);
+  const [hasNewer, setHasNewer] = useState(false);
+  const [sessionStatusProjection, setSessionStatusProjection] = useState(
     null
   );
-  const [initialLoading, setInitialLoading] = useState2(true);
-  const [loadingOlder, setLoadingOlder] = useState2(false);
-  const [loadingNewer, setLoadingNewer] = useState2(false);
-  const [loadingOldest, setLoadingOldest] = useState2(false);
-  const [loadingLatest, setLoadingLatest] = useState2(false);
-  const [streamEpoch, setStreamEpoch] = useState2(0);
-  const [viewMode, setViewMode] = useState2("live");
+  const [initialLoading, setInitialLoading] = useState(true);
+  const [initialHistoryReady, setInitialHistoryReady] = useState(false);
+  const [loadingOlder, setLoadingOlder] = useState(false);
+  const [loadingNewer, setLoadingNewer] = useState(false);
+  const [loadingOldest, setLoadingOldest] = useState(false);
+  const [loadingLatest, setLoadingLatest] = useState(false);
+  const [loadingTarget, setLoadingTarget] = useState(false);
+  const loadingTargetRef = useRef(false);
+  const [streamEpoch, setStreamEpoch] = useState(0);
+  const [viewMode, setViewMode] = useState("live");
   const lastSequenceRef = useRef(after);
   const streamResumeSequenceRef = useRef(after);
   const oldestSequenceRef = useRef(null);
@@ -186,16 +190,34 @@ function useSessionEvents(sessionId, options = {}) {
   const loadingLatestRef = useRef(false);
   const viewModeRef = useRef("live");
   const initialWindowLoadedRef = useRef(false);
+  const reconcileAfterPageResumeRef = useRef(false);
   const streamAbortRef = useRef(null);
   const streamKeyRef = useRef(null);
   const generationRef = useRef(0);
+  const navigationGenerationRef = useRef(0);
   const eventWindowRef = useRef(EMPTY_EVENT_WINDOW);
   const sessionStatusRef = useRef({
     sequence: after,
     status: null
   });
-  const [stateStreamKey, setStateStreamKey] = useState2(streamKey);
-  useEffect2(() => {
+  const [stateStreamKey, setStateStreamKey] = useState(streamKey);
+  useEffect(() => {
+    navigationGenerationRef.current += 1;
+    setNewerError(null);
+    loadingOlderRef.current = false;
+    loadingNewerRef.current = false;
+    loadingOldestRef.current = false;
+    loadingTargetRef.current = false;
+    setQuestionEvidence(null);
+    setLoadingTarget(false);
+    setLoadingOlder(false);
+    setLoadingNewer(false);
+    setLoadingOldest(false);
+    return () => {
+      navigationGenerationRef.current += 1;
+    };
+  }, [client, workspaceId, sessionId, after, enabled, fullReplay]);
+  useEffect(() => {
     if (streamKeyRef.current !== streamKey) {
       streamKeyRef.current = streamKey;
       setStateStreamKey(streamKey);
@@ -211,6 +233,7 @@ function useSessionEvents(sessionId, options = {}) {
       setLoadingOldest(false);
       setLoadingLatest(false);
       setInitialLoading(true);
+      setInitialHistoryReady(false);
       lastSequenceRef.current = after;
       streamResumeSequenceRef.current = after;
       oldestSequenceRef.current = null;
@@ -224,24 +247,27 @@ function useSessionEvents(sessionId, options = {}) {
       viewModeRef.current = "live";
       setViewMode("live");
       initialWindowLoadedRef.current = false;
+      reconcileAfterPageResumeRef.current = false;
     }
     const generation = generationRef.current + 1;
     generationRef.current = generation;
-    if (loadingOlderRef.current) {
-      loadingOlderRef.current = false;
-      setLoadingOlder(false);
-    }
     if (!sessionId || !streamEnabled) {
+      if (sessionId && enabled && !pageLive && !fullReplay && viewModeRef.current === "live" && initialWindowLoadedRef.current) {
+        reconcileAfterPageResumeRef.current = true;
+      }
       setConnectionState("idle");
       return;
     }
     if (viewMode === "history") {
+      reconcileAfterPageResumeRef.current = false;
       setConnectionState("idle");
       setInitialLoading(false);
       return;
     }
+    const reconcileForegroundResume = reconcileAfterPageResumeRef.current && !fullReplay;
+    reconcileAfterPageResumeRef.current = false;
     const controller = new AbortController();
-    const isCurrent = () => generationRef.current === generation && !controller.signal.aborted;
+    const isCurrent = () => generationRef.current === generation && !controller.signal.aborted && navigationIdentityRef.current.client === client && navigationIdentityRef.current.streamKey === streamKey && navigationIdentityRef.current.enabled === enabled;
     streamAbortRef.current = controller;
     let pending = [];
     let pendingBytes = 2;
@@ -271,9 +297,12 @@ function useSessionEvents(sessionId, options = {}) {
           batchResumeSequence
         );
       }
-      observeSessionStatus(batch, sessionStatusRef, setSessionStatusProjection);
+      const status = observeSessionStatus(batch, sessionStatusRef);
+      if (status !== void 0) {
+        setSessionStatusProjection(status);
+      }
       const current = eventWindowRef.current;
-      const next = boundBrowserSessionEventWindow([...current.events, ...batch]);
+      const next = appendBrowserSessionEventWindow(current, batch);
       const retained = {
         ...next,
         truncated: current.truncated || next.truncated
@@ -281,7 +310,7 @@ function useSessionEvents(sessionId, options = {}) {
       eventWindowRef.current = retained;
       setEventWindow(retained);
       oldestSequenceRef.current = retained.events[0]?.sequence ?? null;
-      newestSequenceRef.current = retained.events.at(-1)?.sequence ?? null;
+      newestSequenceRef.current = maxResumeSequenceOrNull(retained.events);
       if (retained.truncated) {
         hasOlderRef.current = true;
         setHasOlder(true);
@@ -293,29 +322,85 @@ function useSessionEvents(sessionId, options = {}) {
     };
     void (async () => {
       try {
+        if (reconcileForegroundResume) {
+          setConnectionState("connecting");
+          const cursor = streamResumeSequenceRef.current;
+          let plan = { kind: "resume" };
+          try {
+            plan = await planForegroundCatchup(client, workspaceId, sessionId, cursor, {
+              signal: controller.signal
+            });
+          } catch {
+            if (controller.signal.aborted) return;
+            plan = { kind: "resume" };
+          }
+          if (!isCurrent()) return;
+          if (plan.kind === "append") {
+            const current = eventWindowRef.current;
+            assertAppendOrder(current.events, plan.events);
+            const status = observeSessionStatus(plan.events, sessionStatusRef);
+            const next = appendBrowserSessionEventWindow(current, plan.events);
+            const retained = {
+              ...next,
+              truncated: current.truncated || next.truncated
+            };
+            eventWindowRef.current = retained;
+            oldestSequenceRef.current = retained.events[0]?.sequence ?? null;
+            newestSequenceRef.current = maxResumeSequenceOrNull(retained.events);
+            lastSequenceRef.current = Math.max(lastSequenceRef.current, plan.resumeSequence);
+            streamResumeSequenceRef.current = Math.max(
+              streamResumeSequenceRef.current,
+              plan.resumeSequence
+            );
+            if (status !== void 0) {
+              setSessionStatusProjection(status);
+            }
+            setEventWindow(retained);
+            if (retained.truncated) {
+              hasOlderRef.current = true;
+              setHasOlder(true);
+            }
+          } else if (plan.kind === "reload") {
+            initialWindowLoadedRef.current = false;
+            setError(null);
+          }
+        }
         if (!fullReplay && !initialWindowLoadedRef.current) {
           setConnectionState("connecting");
           const window = await loadEventWindow(client, workspaceId, sessionId, {
             before: Number.MAX_SAFE_INTEGER,
-            pageSize: INITIAL_TAIL_PAGE_SIZE,
+            pageSize: SESSION_HISTORY_PAGE_SIZE,
             targetGroups: Number.POSITIVE_INFINITY,
             maxFetches: INITIAL_FETCH_CAP,
+            boundaryPageCap: BOUNDARY_PAGE_CAP,
             signal: controller.signal
           });
           if (!isCurrent()) {
             return;
           }
-          observeSessionStatus(window.events, sessionStatusRef, setSessionStatusProjection);
+          const status = observeSessionStatus(window.events, sessionStatusRef);
           const retained = boundBrowserSessionEventWindow(window.events);
+          navigationGenerationRef.current += 1;
+          loadingOlderRef.current = false;
+          loadingNewerRef.current = false;
+          loadingOldestRef.current = false;
+          setLoadingOlder(false);
+          setLoadingNewer(false);
+          setLoadingOldest(false);
           eventWindowRef.current = retained;
-          setEventWindow(retained);
           oldestSequenceRef.current = retained.events[0]?.sequence ?? window.oldestSequence;
-          newestSequenceRef.current = retained.events.at(-1)?.sequence ?? window.newestSequence;
+          newestSequenceRef.current = maxResumeSequenceOrNull(retained.events) ?? window.newestSequence;
           hasOlderRef.current = window.hasOlder || retained.truncated;
           hasNewerRef.current = false;
           lastSequenceRef.current = window.newestSequence;
           streamResumeSequenceRef.current = window.newestSequence;
           initialWindowLoadedRef.current = true;
+          setInitialHistoryReady(true);
+          setError(null);
+          if (status !== void 0) {
+            setSessionStatusProjection(status);
+          }
+          setEventWindow(retained);
           setHasOlder(window.hasOlder || retained.truncated);
           setHasNewer(false);
           setInitialLoading(false);
@@ -329,7 +414,7 @@ function useSessionEvents(sessionId, options = {}) {
           onOpen: () => {
             void Promise.resolve().then(() => reconcileSession(sessionId)).catch((cause) => {
               if (isCurrent()) {
-                setError(cause instanceof Error ? cause : new Error(String(cause)));
+                setError(normalizeError(cause));
               }
             });
           },
@@ -341,7 +426,7 @@ function useSessionEvents(sessionId, options = {}) {
         });
         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 (pending.length > 0 && (pending.length >= SESSION_EVENT_BROWSER_PENDING_MAX_COUNT || pendingBytes + separatorBytes + boundedEventBytes > SESSION_EVENT_BROWSER_PENDING_MAX_BYTES)) {
@@ -362,8 +447,9 @@ function useSessionEvents(sessionId, options = {}) {
       } catch (cause) {
         if (isCurrent()) {
           flush();
-          setError(cause instanceof Error ? cause : new Error(String(cause)));
+          setError(normalizeError(cause));
           setConnectionState("error");
+          setInitialLoading(false);
         }
       }
     })();
@@ -384,6 +470,8 @@ function useSessionEvents(sessionId, options = {}) {
     workspaceId,
     sessionId,
     after,
+    enabled,
+    pageLive,
     streamEnabled,
     fullReplay,
     streamKey,
@@ -391,89 +479,134 @@ function useSessionEvents(sessionId, options = {}) {
     viewMode,
     reconcileSession
   ]);
-  const navigationBusy = () => loadingOlderRef.current || loadingNewerRef.current || loadingOldestRef.current || loadingLatestRef.current;
-  const loadOlder = useCallback2(async () => {
-    if (!sessionId || navigationBusy() || !hasOlderRef.current) {
-      return false;
-    }
-    const before = oldestSequenceRef.current;
-    if (before === null) {
-      hasOlderRef.current = false;
-      setHasOlder(false);
-      return false;
-    }
-    const generation = generationRef.current;
-    loadingOlderRef.current = true;
-    setLoadingOlder(true);
-    try {
-      const window = await loadEventWindow(client, workspaceId, sessionId, {
-        before,
-        pageSize: OLDER_PAGE_SIZE,
-        targetGroups: OLDER_GROUP_TARGET,
-        maxFetches: OLDER_FETCH_CAP
-      });
-      if (generationRef.current !== generation) {
+  const navigationBusy = () => loadingTargetRef.current || loadingOlderRef.current || loadingNewerRef.current || loadingOldestRef.current || loadingLatestRef.current;
+  const loadOlder = useCallback(
+    () => createOlderHistoryLoadReceipt(async (markCommitted, preserveTail, markTailPreserved) => {
+      if (!ownsNavigation() || !sessionId || navigationBusy() || !hasOlderRef.current) {
         return false;
       }
-      if (window.events.length === 0) {
+      const before = oldestSequenceRef.current;
+      if (before === null) {
         oldestSequenceRef.current = null;
         hasOlderRef.current = false;
         setHasOlder(false);
         return false;
       }
-      const current = eventWindowRef.current;
-      assertPrependOrder(current.events, window.events);
-      streamAbortRef.current?.abort();
-      observeSessionStatus(window.events, sessionStatusRef, setSessionStatusProjection);
-      const next = boundBrowserSessionEventWindow([...window.events, ...current.events], {
-        direction: "oldest"
-      });
-      const retained = {
-        ...next,
-        truncated: current.truncated || next.truncated
-      };
-      const retainedOldest = retained.events[0]?.sequence ?? null;
-      if (retainedOldest === null || retainedOldest >= before) {
-        throw new Error("@opengeni/react: loadOlder made no durable sequence progress");
-      }
-      const retainedNewest = retained.events.at(-1)?.sequence ?? null;
-      eventWindowRef.current = retained;
-      setEventWindow(retained);
-      oldestSequenceRef.current = retainedOldest;
-      newestSequenceRef.current = retainedNewest;
-      streamResumeSequenceRef.current = maxResumeSequence(retained.events);
-      const olderStillAvailable = window.hasOlder;
-      hasOlderRef.current = olderStillAvailable;
-      setHasOlder(olderStillAvailable);
-      if (viewModeRef.current === "history") {
-        const highWater = lastSequenceRef.current;
-        const newer = retainedNewest !== null && (retainedNewest < highWater || retained.truncated);
-        hasNewerRef.current = newer;
-        setHasNewer(newer);
-      } else {
-        setStreamEpoch((epoch) => epoch + 1);
+      const generation = navigationGenerationRef.current;
+      const isCurrent = () => ownsNavigation() && navigationGenerationRef.current === generation;
+      loadingOlderRef.current = true;
+      setLoadingOlder(true);
+      let published = false;
+      try {
+        const window = await loadEventWindow(client, workspaceId, sessionId, {
+          before,
+          pageSize: SESSION_HISTORY_PAGE_SIZE,
+          targetGroups: OLDER_GROUP_TARGET,
+          maxFetches: OLDER_FETCH_CAP,
+          isCurrent
+        });
+        if (!isCurrent()) {
+          return false;
+        }
+        if (window.events.length === 0) {
+          oldestSequenceRef.current = null;
+          hasOlderRef.current = false;
+          setHasOlder(false);
+          return false;
+        }
+        const current = eventWindowRef.current;
+        assertPrependOrder(current.events, window.events);
+        const next = boundBrowserSessionEventWindow([...window.events, ...current.events], {
+          direction: "oldest"
+        });
+        if (preserveTail && maxResumeSequence(next.events) < maxResumeSequence(current.events)) {
+          markTailPreserved();
+          return false;
+        }
+        streamAbortRef.current?.abort();
+        const status = observeSessionStatus(window.events, sessionStatusRef);
+        const retained = {
+          ...next,
+          truncated: current.truncated || next.truncated
+        };
+        const retainedOldest = retained.events[0]?.sequence ?? null;
+        if (retainedOldest === null || retainedOldest >= before) {
+          throw new Error("@opengeni/react: loadOlder made no durable sequence progress");
+        }
+        const retainedNewest = maxResumeSequenceOrNull(retained.events);
+        const previousNewest = maxResumeSequenceOrNull(current.events);
+        eventWindowRef.current = retained;
+        markCommitted();
+        oldestSequenceRef.current = retainedOldest;
+        newestSequenceRef.current = retainedNewest;
+        streamResumeSequenceRef.current = maxResumeSequence(retained.events);
+        const olderStillAvailable = window.hasOlder;
+        hasOlderRef.current = olderStillAvailable;
+        const evictedLiveTail = previousNewest !== null && retainedNewest !== null && retainedNewest < previousNewest;
+        let newer = null;
+        let enterHistory = false;
+        let reconnectLive = false;
+        if (viewModeRef.current === "history" || evictedLiveTail) {
+          const highWater = lastSequenceRef.current;
+          newer = retainedNewest !== null && (retainedNewest < highWater || retained.truncated);
+          hasNewerRef.current = newer;
+          if (evictedLiveTail) {
+            viewModeRef.current = "history";
+            enterHistory = true;
+          }
+        } else {
+          reconnectLive = true;
+        }
+        loadingOlderRef.current = false;
+        startTransition(() => {
+          if (status !== void 0) {
+            setSessionStatusProjection(status);
+          }
+          setEventWindow(retained);
+          setHasOlder(olderStillAvailable);
+          if (newer !== null) {
+            setHasNewer(newer);
+          }
+          if (enterHistory) {
+            setViewMode("history");
+          } else if (reconnectLive) {
+            setStreamEpoch((epoch) => epoch + 1);
+          }
+          setLoadingOlder(false);
+        });
+        published = true;
+        return olderStillAvailable;
+      } catch (reason) {
+        if (!isCurrent()) return false;
+        throw reason;
+      } finally {
+        if (!published && isCurrent()) {
+          loadingOlderRef.current = false;
+          setLoadingOlder(false);
+        }
       }
-      return olderStillAvailable;
-    } finally {
-      loadingOlderRef.current = false;
-      setLoadingOlder(false);
-    }
-  }, [client, workspaceId, sessionId]);
-  const loadOldest = useCallback2(async () => {
-    if (!sessionId || navigationBusy() || !hasOlderRef.current) {
+    }),
+    [client, workspaceId, sessionId, ownsNavigation]
+  );
+  const loadOldest = useCallback(async () => {
+    if (!ownsNavigation() || !sessionId || navigationBusy() || !hasOlderRef.current) {
       return false;
     }
-    const generation = generationRef.current;
+    const generation = ++navigationGenerationRef.current;
+    const isCurrent = () => ownsNavigation() && navigationGenerationRef.current === generation;
+    setQuestionEvidence(null);
     loadingOldestRef.current = true;
     setLoadingOldest(true);
+    let published = false;
     try {
       const window = await loadForwardEventWindow(client, workspaceId, sessionId, {
         after: 0,
-        pageSize: OLDEST_PAGE_SIZE,
+        pageSize: SESSION_HISTORY_PAGE_SIZE,
         targetGroups: OLDEST_GROUP_TARGET,
-        maxFetches: OLDEST_FETCH_CAP
+        maxFetches: OLDEST_FETCH_CAP,
+        isCurrent
       });
-      if (generationRef.current !== generation) {
+      if (!isCurrent()) {
         return false;
       }
       if (window.events.length === 0) {
@@ -482,32 +615,48 @@ function useSessionEvents(sessionId, options = {}) {
         return false;
       }
       streamAbortRef.current?.abort();
-      observeSessionStatus(window.events, sessionStatusRef, setSessionStatusProjection);
+      const status = observeSessionStatus(window.events, sessionStatusRef);
       const retained = boundBrowserSessionEventWindow(window.events, { direction: "oldest" });
       const retainedOldest = retained.events[0]?.sequence ?? null;
-      const retainedNewest = retained.events.at(-1)?.sequence ?? null;
+      const retainedNewest = maxResumeSequenceOrNull(retained.events);
       eventWindowRef.current = retained;
-      setEventWindow(retained);
       oldestSequenceRef.current = retainedOldest;
       newestSequenceRef.current = retainedNewest;
       hasOlderRef.current = false;
-      setHasOlder(false);
       const highWater = Math.max(lastSequenceRef.current, retainedNewest ?? 0);
       lastSequenceRef.current = highWater;
       const newer = window.hasNewer || retained.truncated || retainedNewest !== null && retainedNewest < highWater;
       hasNewerRef.current = newer;
-      setHasNewer(newer);
       initialWindowLoadedRef.current = true;
+      setInitialHistoryReady(true);
+      setError(null);
       viewModeRef.current = "history";
-      setViewMode("history");
+      loadingOldestRef.current = false;
+      setNewerError(null);
+      startTransition(() => {
+        if (status !== void 0) {
+          setSessionStatusProjection(status);
+        }
+        setEventWindow(retained);
+        setHasOlder(false);
+        setHasNewer(newer);
+        setViewMode("history");
+        setLoadingOldest(false);
+      });
+      published = true;
       return newer;
+    } catch (reason) {
+      if (!isCurrent()) return false;
+      throw reason;
     } finally {
-      loadingOldestRef.current = false;
-      setLoadingOldest(false);
+      if (!published && isCurrent()) {
+        loadingOldestRef.current = false;
+        setLoadingOldest(false);
+      }
     }
-  }, [client, workspaceId, sessionId]);
-  const loadNewer = useCallback2(async () => {
-    if (!sessionId || navigationBusy() || !hasNewerRef.current) {
+  }, [client, workspaceId, sessionId, ownsNavigation]);
+  const loadNewer = useCallback(async () => {
+    if (!ownsNavigation() || !sessionId || navigationBusy() || !hasNewerRef.current) {
       return false;
     }
     const afterSequence = newestSequenceRef.current;
@@ -516,20 +665,24 @@ function useSessionEvents(sessionId, options = {}) {
       setHasNewer(false);
       return false;
     }
-    const generation = generationRef.current;
+    const generation = navigationGenerationRef.current;
+    const isCurrent = () => ownsNavigation() && navigationGenerationRef.current === generation;
     loadingNewerRef.current = true;
     setLoadingNewer(true);
+    let published = false;
     try {
       const window = await loadForwardEventWindow(client, workspaceId, sessionId, {
         after: afterSequence,
-        pageSize: NEWER_PAGE_SIZE,
+        pageSize: SESSION_HISTORY_PAGE_SIZE,
         targetGroups: NEWER_GROUP_TARGET,
-        maxFetches: NEWER_FETCH_CAP
+        maxFetches: NEWER_FETCH_CAP,
+        isCurrent
       });
-      if (generationRef.current !== generation) {
+      if (!isCurrent()) {
         return false;
       }
       if (window.events.length === 0) {
+        setNewerError(null);
         hasNewerRef.current = false;
         setHasNewer(false);
         streamResumeSequenceRef.current = afterSequence;
@@ -540,85 +693,246 @@ function useSessionEvents(sessionId, options = {}) {
       }
       const current = eventWindowRef.current;
       assertAppendOrder(current.events, window.events);
-      observeSessionStatus(window.events, sessionStatusRef, setSessionStatusProjection);
+      const status = observeSessionStatus(window.events, sessionStatusRef);
       const previousOldest = current.events[0]?.sequence ?? null;
-      const next = boundBrowserSessionEventWindow([...current.events, ...window.events], {
-        direction: "newest"
-      });
+      const next = appendBrowserSessionEventWindow(current, window.events);
       const retained = {
         ...next,
         truncated: current.truncated || next.truncated || window.hasNewer
       };
       const retainedOldest = retained.events[0]?.sequence ?? null;
-      const retainedNewest = retained.events.at(-1)?.sequence ?? null;
+      const retainedNewest = maxResumeSequenceOrNull(retained.events);
       if (retainedNewest === null || retainedNewest <= afterSequence) {
         throw new Error("@opengeni/react: loadNewer made no durable sequence progress");
       }
       eventWindowRef.current = retained;
-      setEventWindow(retained);
       oldestSequenceRef.current = retainedOldest;
       newestSequenceRef.current = retainedNewest;
       if (retainedOldest !== null && (previousOldest === null || retainedOldest > previousOldest || retained.truncated && retained.events[0]?.type !== "session.created" && retainedOldest > 1)) {
         hasOlderRef.current = true;
-        setHasOlder(true);
       }
+      const rearmedOlder = hasOlderRef.current;
       const highWater = Math.max(lastSequenceRef.current, retainedNewest);
       lastSequenceRef.current = highWater;
       const newer = window.hasNewer || retainedNewest < highWater;
       hasNewerRef.current = newer;
-      setHasNewer(newer);
+      let resumeLive = false;
       if (!newer) {
         streamResumeSequenceRef.current = retainedNewest;
         viewModeRef.current = "live";
-        setViewMode("live");
-        setStreamEpoch((epoch) => epoch + 1);
+        resumeLive = true;
       }
+      loadingNewerRef.current = false;
+      setNewerError(null);
+      startTransition(() => {
+        if (status !== void 0) {
+          setSessionStatusProjection(status);
+        }
+        setEventWindow(retained);
+        setHasOlder(rearmedOlder);
+        setHasNewer(newer);
+        if (resumeLive) {
+          setViewMode("live");
+          setStreamEpoch((epoch) => epoch + 1);
+        }
+        setLoadingNewer(false);
+      });
+      published = true;
       return newer;
+    } catch (reason) {
+      if (!isCurrent()) {
+        return false;
+      }
+      setNewerError(normalizeError(reason));
+      throw reason;
     } finally {
-      loadingNewerRef.current = false;
+      if (!published && isCurrent()) {
+        loadingNewerRef.current = false;
+        setLoadingNewer(false);
+      }
+    }
+  }, [client, workspaceId, sessionId, ownsNavigation]);
+  const jumpToSequence = useCallback(
+    async (sequence, navigationOptions) => {
+      const signal = navigationOptions?.signal;
+      if (!ownsNavigation() || !sessionId || !Number.isSafeInteger(sequence) || sequence < 1)
+        return false;
+      if (signal?.aborted) return false;
+      const generation = ++navigationGenerationRef.current;
+      setQuestionEvidence(null);
+      const current = () => generation === navigationGenerationRef.current && ownsNavigation();
+      const previousMode = viewModeRef.current;
+      streamAbortRef.current?.abort();
+      generationRef.current += 1;
+      viewModeRef.current = "history";
+      setViewMode("history");
+      loadingOlderRef.current = loadingNewerRef.current = loadingOldestRef.current = false;
+      setLoadingOlder(false);
       setLoadingNewer(false);
+      setLoadingOldest(false);
+      loadingTargetRef.current = true;
+      setLoadingTarget(true);
+      let published = false;
+      try {
+        const [before, following] = await Promise.all([
+          loadPreviousPage(client, workspaceId, sessionId, sequence + 1, { pageSize: 128 }),
+          loadNextPage(client, workspaceId, sessionId, sequence, { pageSize: 128 })
+        ]);
+        if (signal?.aborted) return false;
+        if (!current()) return false;
+        if (!before.some((event) => event.sequence === sequence)) return false;
+        const prefix = boundBrowserSessionEventWindow(before, {
+          direction: "newest",
+          maxBytes: SESSION_EVENT_BROWSER_MAX_BYTES / 2
+        });
+        const retained = boundBrowserSessionEventWindow([...prefix.events, ...following], {
+          direction: "oldest"
+        });
+        if (!retained.events.some((event) => event.sequence === sequence)) return false;
+        streamAbortRef.current?.abort();
+        generationRef.current += 1;
+        const status = observeSessionStatus(retained.events, sessionStatusRef);
+        eventWindowRef.current = retained;
+        oldestSequenceRef.current = retained.events[0].sequence;
+        newestSequenceRef.current = maxResumeSequenceOrNull(retained.events);
+        lastSequenceRef.current = Math.max(lastSequenceRef.current, newestSequenceRef.current ?? 0);
+        hasOlderRef.current = !isLogStart(retained.events[0]);
+        hasNewerRef.current = following.length > 0 || retained.truncated || (newestSequenceRef.current ?? 0) < lastSequenceRef.current;
+        initialWindowLoadedRef.current = true;
+        setInitialHistoryReady(true);
+        setError(null);
+        viewModeRef.current = "history";
+        setEventWindow(retained);
+        setHasOlder(hasOlderRef.current);
+        setHasNewer(hasNewerRef.current);
+        setInitialLoading(false);
+        setViewMode("history");
+        setNewerError(null);
+        if (status !== void 0) setSessionStatusProjection(status);
+        published = true;
+        return true;
+      } catch (reason) {
+        if (!current() || signal?.aborted) return false;
+        throw reason;
+      } finally {
+        if (current()) {
+          loadingTargetRef.current = false;
+          setLoadingTarget(false);
+          if (!published && previousMode === "live") {
+            viewModeRef.current = "live";
+            setViewMode("live");
+            setStreamEpoch((epoch) => epoch + 1);
+          }
+        }
+      }
+    },
+    [client, workspaceId, sessionId, ownsNavigation]
+  );
+  const jumpToLatestQuestion = useCallback(
+    async (questionOptions) => {
+      if (!sessionId || !ownsNavigation()) return null;
+      let generation = navigationGenerationRef.current;
+      const current = () => ownsNavigation() && generation === navigationGenerationRef.current;
+      try {
+        const { resolveLatestQuestion } = await import("./latest-question-755OW5DS.js");
+        if (!current()) return null;
+        const destination = await resolveLatestQuestion({
+          client,
+          workspaceId,
+          sessionId,
+          isCurrent: current,
+          resumeSequence: maxResumeSequence,
+          options: questionOptions
+        });
+        if (!destination || !current()) return null;
+        if (!eventWindowRef.current.events.some((event) => event.sequence === destination.anchor)) {
+          const navigation = jumpToSequence(destination.anchor);
+          generation = navigationGenerationRef.current;
+          if (!await navigation || !current()) return null;
+        }
+        setQuestionEvidence({
+          client,
+          streamKey,
+          anchor: destination.anchor,
+          events: destination.events
+        });
+        return destination.questionSequence;
+      } catch (reason) {
+        if (!current()) return null;
+        throw reason;
+      }
+    },
+    [client, workspaceId, sessionId, streamKey, ownsNavigation, jumpToSequence]
+  );
+  const jumpToLatest = useCallback(async () => {
+    if (!ownsNavigation()) return;
+    if (loadingTargetRef.current) {
+      navigationGenerationRef.current += 1;
+      loadingTargetRef.current = false;
+      setLoadingTarget(false);
     }
-  }, [client, workspaceId, sessionId]);
-  const jumpToLatest = useCallback2(async () => {
     if (!sessionId || navigationBusy()) {
       return;
     }
+    navigationGenerationRef.current += 1;
+    setQuestionEvidence(null);
     loadingLatestRef.current = true;
     setLoadingLatest(true);
+    setNewerError(null);
+    setError(null);
+    let published = false;
     try {
       streamAbortRef.current?.abort();
       hasNewerRef.current = false;
-      setHasNewer(false);
       hasOlderRef.current = false;
-      setHasOlder(false);
       newestSequenceRef.current = null;
       oldestSequenceRef.current = null;
       eventWindowRef.current = EMPTY_EVENT_WINDOW;
-      setEventWindow(EMPTY_EVENT_WINDOW);
       initialWindowLoadedRef.current = false;
       streamResumeSequenceRef.current = after;
-      setInitialLoading(true);
       viewModeRef.current = "live";
-      setViewMode("live");
-      setStreamEpoch((epoch) => epoch + 1);
+      loadingLatestRef.current = false;
+      startTransition(() => {
+        setHasNewer(false);
+        setHasOlder(false);
+        setEventWindow(EMPTY_EVENT_WINDOW);
+        setInitialLoading(true);
+        setViewMode("live");
+        setStreamEpoch((epoch) => epoch + 1);
+        setLoadingLatest(false);
+      });
+      published = true;
       await Promise.resolve();
     } finally {
-      loadingLatestRef.current = false;
-      setLoadingLatest(false);
+      if (!published) {
+        loadingLatestRef.current = false;
+        setLoadingLatest(false);
+      }
     }
-  }, [after, sessionId]);
+  }, [after, sessionId, ownsNavigation]);
   const identityMatches = stateStreamKey === streamKey;
   const visibleEvents = identityMatches ? eventWindow.events : EMPTY_EVENTS;
-  const timeline = useMemo2(() => buildTimeline(visibleEvents), [visibleEvents]);
+  const timeline = useMemo(() => {
+    const witness = questionEvidence?.client === client && questionEvidence.streamKey === streamKey && visibleEvents.some((event) => event.sequence === questionEvidence.anchor) ? questionEvidence.events : EMPTY_EVENTS;
+    const timelineOptions = { partialStart: hasOlder || eventWindow.truncated || after > 0 };
+    if (witness.length === 0) return buildTimeline(visibleEvents, timelineOptions);
+    const ids = new Set(visibleEvents.map((event) => event.id));
+    return buildTimeline(
+      [...visibleEvents, ...witness.filter((event) => !ids.has(event.id))],
+      timelineOptions
+    );
+  }, [visibleEvents, hasOlder, eventWindow.truncated, after, questionEvidence, client, streamKey]);
   return {
     events: visibleEvents,
     timeline,
     sessionStatus: identityMatches ? sessionStatusProjection : null,
+    sessionStatusSequence: identityMatches ? sessionStatusRef.current.sequence : 0,
     connectionState: identityMatches ? connectionState : "idle",
     lastSequence: identityMatches ? lastSequenceRef.current : after,
     windowBytes: identityMatches ? eventWindow.bytes : 2,
     windowTruncated: identityMatches ? eventWindow.truncated : false,
     initialLoading: fullReplay ? false : identityMatches ? initialLoading : true,
+    initialHistoryReady: identityMatches && initialHistoryReady,
     hasOlder: !identityMatches ? false : hasOlder,
     loadingOlder: !identityMatches ? false : loadingOlder,
     loadOlder,
@@ -629,13 +943,16 @@ function useSessionEvents(sessionId, options = {}) {
     loadOldest,
     loadingLatest: !identityMatches ? false : loadingLatest,
     jumpToLatest,
-    error: identityMatches ? error : null
+    jumpToLatestQuestion,
+    jumpToSequence,
+    loadingTarget: identityMatches && loadingTarget,
+    error: identityMatches ? newerError ?? error : null
   };
 }
 function boundBrowserSessionEventWindow(events, options = {}) {
   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 = [];
   let bytes = 2;
   const direction = options.direction ?? "newest";
@@ -646,7 +963,7 @@ function boundBrowserSessionEventWindow(events, options = {}) {
     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;
   }
@@ -657,184 +974,29 @@ function boundBrowserSessionEventWindow(events, options = {}) {
     truncated: selected.length < safe.length
   };
 }
-function boundBrowserLegacyEvent(event) {
-  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;
+function appendBrowserSessionEventWindow(current, batch, options = {}) {
+  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 events = [...current.events, ...batch];
+  let bytes = current.bytes;
+  for (let index = 0; index < batch.length; index += 1) {
+    bytes += browserJsonBytes(batch[index]) + (current.events.length + index > 0 ? 1 : 0);
   }
-  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,
-    surface: "browser_legacy_guard",
-    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, reason: "not_retained" },
-    details: [
-      {
-        path: "$.payload",
-        kind: "payload_preview",
-        originalBytes: payloadBytes,
-        deliveredBytes: browserUtf8Bytes(preview)
-      }
-    ]
-  };
-  const payload = {
-    ...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 = {
-    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);
+  let start = 0;
+  while (events.length - start > 1 && (bytes > maxBytes || events.length - start > maxCount)) {
+    bytes -= browserJsonBytes(events[start]) + 1;
+    start += 1;
   }
-  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) {
-  return encoder.encode(browserSerialize(value).value).byteLength;
-}
-function browserSerialize(value) {
-  try {
-    const serialized = JSON.stringify(value);
-    return { value: serialized === void 0 ? "null" : serialized, serializable: true };
-  } catch {
-    return {
-      value: '"[unserializable event payload omitted at browser boundary]"',
-      serializable: false
-    };
-  }
-}
-function browserPayloadIdentity(payload) {
-  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return {};
-  const record = payload;
-  const identity = {};
-  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, original, delivered) {
   return {
-    field,
-    originalBytes: typeof original === "string" ? browserUtf8Bytes(original) : 0,
-    deliveredBytes: typeof delivered === "string" ? browserUtf8Bytes(delivered) : 0
+    events: start === 0 ? events : events.slice(start),
+    bytes,
+    truncated: current.truncated || start > 0
   };
 }
-function boundBrowserOptionalText(value, maxBytes) {
-  return typeof value === "string" ? boundBrowserText(value, maxBytes) : value;
-}
-function boundBrowserText(value, maxBytes) {
-  const bytes = encoder.encode(value);
-  if (bytes.byteLength <= maxBytes) return value;
-  const marker = "\u2026[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, maxBytes) {
-  const bytes = encoder.encode(value);
-  if (bytes.byteLength <= maxBytes) return value;
-  const marker = `\u2026[${bytes.byteLength - maxBytes} bytes omitted]\u2026`;
-  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, truncation) {
-  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) {
-  return encoder.encode(value).byteLength;
-}
-function isBrowserUtf8Continuation(value) {
-  return (value & 192) === 128;
+function browserJsonBytes(value) {
+  return encoder.encode(JSON.stringify(value)).byteLength;
 }
-function observeSessionStatus(events, ref, setStatus) {
+function observeSessionStatus(events, ref) {
   let latest = null;
   for (const event of events) {
     const status = sessionStatusFromEvents([event]);
@@ -842,9 +1004,42 @@ function observeSessionStatus(events, ref, setStatus) {
       latest = { sequence: event.sequence, status };
     }
   }
-  if (!latest || latest.sequence < ref.current.sequence) return;
+  if (!latest || latest.sequence < ref.current.sequence) return void 0;
   ref.current = latest;
-  setStatus(latest.status);
+  return latest.status;
+}
+async function planForegroundCatchup(client, workspaceId, sessionId, cursor, options = {}) {
+  if (options.signal?.aborted) throw abortError();
+  const session = await client.getSession(workspaceId, sessionId, {
+    fresh: true,
+    ...options.signal ? { signal: options.signal } : {}
+  });
+  if (options.signal?.aborted) throw abortError();
+  const durableHead = Math.max(cursor, session.lastSequence);
+  const rawGap = durableHead - cursor;
+  if (rawGap <= FOREGROUND_DIRECT_REPLAY_MAX_SEQUENCES) {
+    return { kind: "resume" };
+  }
+  if (rawGap > FOREGROUND_COMPACT_PROBE_MAX_SEQUENCES) {
+    return { kind: "reload" };
+  }
+  const page = await loadNextPage(client, workspaceId, sessionId, cursor, {
+    pageSize: rawGap,
+    ...options.signal ? { signal: options.signal } : {}
+  });
+  const events = page.filter((event) => eventResumeSequence(event) > cursor);
+  if (events.length === 0) {
+    return { kind: "reload" };
+  }
+  assertAscending(events);
+  const resumeSequence = maxResumeSequence(events);
+  if (resumeSequence < durableHead) {
+    return { kind: "reload" };
+  }
+  if (events.length > FOREGROUND_COMPACT_CATCHUP_MAX_EVENTS || groupCount(events) > FOREGROUND_COMPACT_CATCHUP_MAX_GROUPS || browserJsonBytes(events) > FOREGROUND_COMPACT_CATCHUP_MAX_BYTES) {
+    return { kind: "reload" };
+  }
+  return { kind: "append", events, resumeSequence };
 }
 async function loadEventWindow(client, workspaceId, sessionId, options) {
   let cursor = options.before;
@@ -859,6 +1054,7 @@ async function loadEventWindow(client, workspaceId, sessionId, options) {
       pageSize: options.pageSize,
       ...options.signal ? { signal: options.signal } : {}
     });
+    if (options.isCurrent?.() === false) throw abortError();
     fetches += 1;
     if (page.length === 0) {
       reachedStart = true;
@@ -873,11 +1069,12 @@ async function loadEventWindow(client, workspaceId, sessionId, options) {
     }
   }
   let snapPages = 0;
-  while (!reachedStart && findBoundaryIndex(buffer) === -1 && snapPages < BOUNDARY_PAGE_CAP && fetches < options.maxFetches) {
+  while (!reachedStart && findBoundaryIndex(buffer) === -1 && snapPages < (options.boundaryPageCap ?? 0)) {
     const page = await loadPreviousPage(client, workspaceId, sessionId, cursor, {
       pageSize: options.pageSize,
       ...options.signal ? { signal: options.signal } : {}
     });
+    if (options.isCurrent?.() === false) throw abortError();
     fetches += 1;
     snapPages += 1;
     if (page.length === 0) {
@@ -898,24 +1095,28 @@ async function loadEventWindow(client, workspaceId, sessionId, options) {
       buffer = buffer.slice(boundary);
     }
   }
+  const densityWindow = trimBackwardToGroupTarget(buffer, options.targetGroups);
+  buffer = densityWindow.events;
   const oldest = buffer[0] ?? null;
   const newest = buffer[buffer.length - 1] ?? null;
   return {
     events: buffer,
     oldestSequence: oldest?.sequence ?? null,
     newestSequence: newest ? maxResumeSequence(buffer) : 0,
-    hasOlder: buffer.length > 0 && !reachedStart && oldest?.type !== "session.created"
+    hasOlder: buffer.length > 0 && (densityWindow.trimmed || !reachedStart && oldest?.type !== "session.created")
   };
 }
 function findBoundaryIndex(events) {
   for (let index = 0; index < events.length; index += 1) {
-    const type = events[index].type;
-    if (type === "session.created" || type === "user.message") {
+    if (isTurnBoundary(events[index])) {
       return index;
     }
   }
   return -1;
 }
+function isTurnBoundary(event) {
+  return event.type === "session.created" || event.type === "user.message";
+}
 async function loadForwardEventWindow(client, workspaceId, sessionId, options) {
   let cursor = options.after;
   let buffer = [];
@@ -929,6 +1130,7 @@ async function loadForwardEventWindow(client, workspaceId, sessionId, options) {
       pageSize: options.pageSize,
       ...options.signal ? { signal: options.signal } : {}
     });
+    if (options.isCurrent?.() === false) throw abortError();
     fetches += 1;
     if (page.length === 0) {
       reachedEnd = true;
@@ -936,21 +1138,45 @@ async function loadForwardEventWindow(client, workspaceId, sessionId, options) {
     }
     assertAscending(page);
     buffer = [...buffer, ...page];
-    cursor = page[page.length - 1].sequence;
-    if (page.length < options.pageSize) {
-      reachedEnd = true;
-      break;
-    }
+    cursor = maxResumeSequence(page);
   }
+  const densityWindow = trimForwardToGroupTarget(buffer, options.targetGroups);
+  buffer = densityWindow.events;
   const oldest = buffer[0] ?? null;
   const newest = buffer[buffer.length - 1] ?? null;
   return {
     events: buffer,
     oldestSequence: oldest?.sequence ?? null,
     newestSequence: newest ? maxResumeSequence(buffer) : 0,
-    hasNewer: buffer.length > 0 && !reachedEnd
+    hasNewer: buffer.length > 0 && (densityWindow.trimmed || !reachedEnd)
   };
 }
+function trimBackwardToGroupTarget(events, targetGroups) {
+  if (!Number.isFinite(targetGroups) || targetGroups <= 0 || events.length === 0) {
+    return { events, trimmed: false };
+  }
+  for (let index = events.length - 1; index > 0; index -= 1) {
+    if (!isTurnBoundary(events[index])) continue;
+    const candidate = events.slice(index);
+    if (groupCount(candidate) >= targetGroups) {
+      return { events: candidate, trimmed: true };
+    }
+  }
+  return { events, trimmed: false };
+}
+function trimForwardToGroupTarget(events, targetGroups) {
+  if (!Number.isFinite(targetGroups) || targetGroups <= 0 || events.length === 0) {
+    return { events, trimmed: false };
+  }
+  for (let index = 1; index < events.length; index += 1) {
+    if (!isTurnBoundary(events[index])) continue;
+    const candidate = events.slice(0, index);
+    if (groupCount(candidate) >= targetGroups) {
+      return { events: candidate, trimmed: true };
+    }
+  }
+  return { events, trimmed: false };
+}
 async function loadPreviousPage(client, workspaceId, sessionId, before, options) {
   if (options.signal?.aborted) {
     throw abortError();
@@ -1006,13 +1232,13 @@ function isLogStart(event) {
 function maxResumeSequence(events) {
   return events.reduce((max, event) => Math.max(max, eventResumeSequence(event)), 0);
 }
-function eventResumeSequence(event) {
-  const payload = asRecord(event.payload);
-  const coalescedUntil = Number(payload.coalescedUntil);
-  return Math.max(event.sequence, Number.isFinite(coalescedUntil) ? Math.floor(coalescedUntil) : 0);
+function maxResumeSequenceOrNull(events) {
+  return events.length > 0 ? maxResumeSequence(events) : null;
 }
-function asRecord(value) {
-  return value && typeof value === "object" ? value : {};
+function eventResumeSequence(event) {
+  const streamedCoverage = sessionEventStreamCoveredThrough(event);
+  if (streamedCoverage !== null) return streamedCoverage;
+  return typeof event.coveredThrough === "number" && Number.isSafeInteger(event.coveredThrough) && event.coveredThrough >= event.sequence ? event.coveredThrough : event.sequence;
 }
 function assertAscending(events) {
   for (let index = 1; index < events.length; index += 1) {
@@ -1047,224 +1273,122 @@ function abortError() {
   return error;
 }
 
-// src/hooks/use-file-attachments.ts
-import { useCallback as useCallback3, useEffect as useEffect3, useRef as useRef2, useState as useState3 } from "react";
-var isImage = (file) => file.type.startsWith("image/");
-function useFileAttachments(options = {}) {
-  const { client, workspaceId } = useEmbeddedFileAttachments(options);
-  const pasteFilter = options.pasteFilter ?? isImage;
-  const [attachments, setAttachments] = useState3([]);
-  const sources = useRef2(/* @__PURE__ */ new Map());
-  const previewUrls = useRef2(/* @__PURE__ */ new Map());
-  const revokePreview = useCallback3((id) => {
-    const previewUrl = previewUrls.current.get(id);
-    if (!previewUrl) return;
-    previewUrls.current.delete(id);
-    URL.revokeObjectURL(previewUrl);
-  }, []);
-  const revokeAllPreviews = useCallback3(() => {
-    const urls = [...previewUrls.current.values()];
-    previewUrls.current.clear();
-    for (const previewUrl of urls) URL.revokeObjectURL(previewUrl);
-  }, []);
-  const committedAttachmentIds = useRef2(/* @__PURE__ */ new Set());
-  useEffect3(() => {
-    const currentIds = new Set(attachments.map((attachment) => attachment.id));
-    for (const id of committedAttachmentIds.current) {
-      if (!currentIds.has(id)) revokePreview(id);
-    }
-    committedAttachmentIds.current = currentIds;
-  }, [attachments, revokePreview]);
-  const scopeGeneration = useRef2(0);
-  const previousScope = useRef2({ client, workspaceId });
-  useEffect3(() => {
-    const previous = previousScope.current;
-    if (previous.client === client && previous.workspaceId === workspaceId) return;
-    previousScope.current = { client, workspaceId };
-    scopeGeneration.current += 1;
-    sources.current.clear();
-    revokeAllPreviews();
-    setAttachments([]);
-  }, [client, revokeAllPreviews, workspaceId]);
-  useEffect3(
-    () => () => {
-      scopeGeneration.current += 1;
-      sources.current.clear();
-      revokeAllPreviews();
-    },
-    [revokeAllPreviews]
-  );
-  const startUpload = useCallback3(
-    (id, file) => {
-      const generation = scopeGeneration.current;
-      void client.uploadFile(workspaceId, {
-        filename: file.name || "file",
-        contentType: file.type || "application/octet-stream",
-        data: file
-      }).then((asset) => {
-        if (scopeGeneration.current !== generation) return;
-        sources.current.delete(id);
-        setAttachments(
-          (current) => current.map(
-            (attachment) => attachment.id === id ? {
-              ...attachment,
-              status: "ready",
-              file: asset,
-              name: asset.filename,
-              contentType: asset.contentType,
-              sizeBytes: asset.sizeBytes,
-              error: void 0
-            } : attachment
-          )
-        );
-      }).catch((error) => {
-        if (scopeGeneration.current !== generation) return;
-        setAttachments(
-          (current) => current.map(
-            (attachment) => attachment.id === id ? {
-              ...attachment,
-              status: "failed",
-              error: error instanceof Error ? error.message : String(error)
-            } : attachment
-          )
-        );
-      });
-    },
-    [client, workspaceId]
-  );
-  const addFiles = useCallback3(
-    (files) => {
-      for (const file of files) {
-        const id = crypto.randomUUID();
-        sources.current.set(id, file);
-        const previewUrl = isImage(file) ? URL.createObjectURL(file) : void 0;
-        if (previewUrl) previewUrls.current.set(id, previewUrl);
-        setAttachments((current) => [
-          ...current,
-          {
-            id,
-            name: file.name || "image",
-            contentType: file.type || "application/octet-stream",
-            sizeBytes: file.size,
-            status: "uploading",
-            ...previewUrl ? { previewUrl } : {}
-          }
-        ]);
-        startUpload(id, file);
+// src/hooks/use-session.ts
+import { useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
+function isTitleEvent(event) {
+  return event.type === "session.title_set";
+}
+function isSessionDetailEvent(event) {
+  return isTitleEvent(event) || event.type.startsWith("session.command.") || event.type.startsWith("session.wait.") || event.type === "session.status.changed" || event.type === "system.update.pending";
+}
+function useSession(sessionId, options = {}) {
+  const { client, workspaceId, workspaceControlEvent, registerSessionReconciler } = useEmbeddedSessionRead(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId);
+  const [override, setOverride] = useState2(null);
+  const nextReadRevision = useRef2(0);
+  const nextReadGeneration = useRef2(0);
+  const beginRead = options.beginRead;
+  const { run, mutating, mutationError, clearMutationError } = useMutationRunner();
+  const load = useCallback2(
+    async (signal) => {
+      if (!sessionId) {
+        return null;
       }
+      let readGeneration2 = 0;
+      const fetched = await client.getSession(workspaceId, sessionId, {
+        fresh: true,
+        signal,
+        onRequestStart: () => {
+          readGeneration2 = beginRead?.() ?? ++nextReadGeneration.current;
+        }
+      });
+      setOverride(null);
+      return {
+        session: fetched,
+        revision: ++nextReadRevision.current,
+        readGeneration: readGeneration2
+      };
     },
-    [startUpload]
+    [beginRead, client, workspaceId, sessionId]
   );
-  const retry = useCallback3(
-    (id) => {
-      const file = sources.current.get(id);
-      if (!file) {
-        return;
-      }
-      setAttachments(
-        (current) => current.map(
-          (attachment) => attachment.id === id ? { ...attachment, status: "uploading", error: void 0 } : attachment
-        )
-      );
-      startUpload(id, file);
-    },
-    [startUpload]
+  const { data, loading, error, refresh } = usePolledValue(load, {
+    pollIntervalMs: options.pollIntervalMs,
+    enabled
+  });
+  useEffect2(() => {
+    if (enabled && workspaceControlEvent) void refresh();
+  }, [enabled, refresh, workspaceControlEvent]);
+  useEffect2(() => {
+    if (!sessionId || !enabled) return;
+    return registerSessionReconciler(sessionId, "session", refresh);
+  }, [enabled, refresh, registerSessionReconciler, sessionId]);
+  const base = data?.session ?? null;
+  const readRevision = data?.revision ?? 0;
+  const readGeneration = data?.readGeneration ?? 0;
+  const session = useMemo2(
+    () => base && override && override.id === base.id ? { ...base, title: override.title, titleSource: override.titleSource } : base,
+    [base, override]
   );
-  const addFromPaste = useCallback3(
+  const sharedEvents = options.events;
+  const onTitleEvent = useCallback2(
     (event) => {
-      const clipboardFiles = event.clipboardData?.files;
-      if (!clipboardFiles) {
+      if (sharedEvents?.some(
+        (item) => item.sessionId === sessionId && !isTitleEvent(item) && isSessionDetailEvent(item) && item.sequence > (base?.lastSequence ?? -1)
+      )) {
+        void refresh();
+      } else if (!isTitleEvent(event)) {
+        if (!base || event.sequence > base.lastSequence) void refresh();
         return;
       }
-      const files = [...clipboardFiles].filter(pasteFilter);
-      if (files.length > 0) {
-        addFiles(files);
+      if (!base || event.sequence <= base.lastSequence) {
+        return;
       }
-    },
-    [addFiles, pasteFilter]
-  );
-  const restoreReadyFiles = useCallback3(
-    (files) => {
-      const incoming = /* @__PURE__ */ new Map();
-      for (const file of files) {
-        if (file.status === "ready" && file.workspaceId === workspaceId) {
-          incoming.set(file.id, file);
-        }
+      const payload = event.payload ?? {};
+      const title = payload.title;
+      if (typeof title !== "string") {
+        return;
       }
-      setAttachments((current) => {
-        const unresolved = current.filter((attachment) => attachment.status !== "ready");
-        const existingReady = new Map(
-          current.flatMap(
-            (attachment) => attachment.status === "ready" && attachment.file ? [[attachment.file.id, attachment]] : []
-          )
-        );
-        const restored = [...incoming.values()].map((file) => {
-          const existing = existingReady.get(file.id);
-          return existing ? {
-            ...existing,
-            name: file.filename,
-            contentType: file.contentType,
-            sizeBytes: file.sizeBytes,
-            status: "ready",
-            file,
-            error: void 0
-          } : {
-            id: `restored:${file.id}`,
-            name: file.filename,
-            contentType: file.contentType,
-            sizeBytes: file.sizeBytes,
-            status: "ready",
-            file
-            // No source File and no object URL: server metadata is the
-            // only authority restored across page/device boundaries.
-          };
-        });
-        return [...unresolved, ...restored];
+      const source = payload.source === "user" || payload.source === "agent" ? payload.source : null;
+      setOverride((current) => {
+        const next = current ?? base;
+        return { ...next, title, titleSource: source };
       });
     },
-    [workspaceId]
+    [base, refresh, sharedEvents, sessionId]
   );
-  const remove = useCallback3(
-    (id) => {
-      sources.current.delete(id);
-      revokePreview(id);
-      setAttachments((current) => current.filter((attachment) => attachment.id !== id));
+  useSessionEventTrigger(client, workspaceId, sessionId, isSessionDetailEvent, onTitleEvent, {
+    enabled,
+    ...options.events !== void 0 ? { events: options.events } : {}
+  });
+  const updateTitle = useCallback2(
+    async (title) => {
+      if (!sessionId) {
+        return null;
+      }
+      const result = await run(() => client.updateSession(workspaceId, sessionId, { title }));
+      if (result) {
+        setOverride(result);
+      }
+      return result;
     },
-    [revokePreview]
+    [client, workspaceId, sessionId, run]
   );
-  const removeReadyFiles = useCallback3((fileIds) => {
-    const accepted = new Set(fileIds);
-    if (accepted.size === 0) return;
-    setAttachments(
-      (current) => current.filter((attachment) => {
-        return !(attachment.status === "ready" && attachment.file !== void 0 && accepted.has(attachment.file.id));
-      })
-    );
-  }, []);
-  const clear = useCallback3(() => {
-    sources.current.clear();
-    revokeAllPreviews();
-    setAttachments([]);
-  }, [revokeAllPreviews]);
   return {
-    attachments,
-    readyResources: attachments.flatMap(
-      (attachment) => attachment.status === "ready" && attachment.file ? [{ kind: "file", fileId: attachment.file.id }] : []
-    ),
-    uploading: attachments.some((attachment) => attachment.status === "uploading"),
-    hasUnresolved: attachments.some((attachment) => attachment.status !== "ready"),
-    addFiles,
-    addFromPaste,
-    restoreReadyFiles,
-    retry,
-    remove,
-    removeReadyFiles,
-    clear
+    session,
+    loading,
+    error,
+    readRevision,
+    readGeneration,
+    refresh,
+    updateTitle,
+    updating: mutating,
+    mutationError,
+    clearMutationError
   };
 }
 
 // src/hooks/use-turn-queue.ts
-import { useCallback as useCallback4, useEffect as useEffect4, useLayoutEffect, useMemo as useMemo3, useRef as useRef3, useState as useState4 } from "react";
+import { useCallback as useCallback3, useEffect as useEffect3, useLayoutEffect, useMemo as useMemo3, useRef as useRef3, useState as useState3 } from "react";
 function isTurnQueueEvent(event) {
   return event.type.startsWith("turn.") || event.type.startsWith("session.queue.") || event.type.startsWith("session.control.") || event.type.startsWith("system.update.") || event.type.startsWith("workspace.inference.");
 }
@@ -1279,12 +1403,13 @@ function useTurnQueue(sessionId, options = {}) {
   const enabled = (options.enabled ?? true) && Boolean(sessionId);
   const targetKey = `${workspaceId}\0${sessionId ?? ""}`;
   const pageLive = usePageLiveActivity();
-  const [snapshot, setSnapshot] = useState4(null);
-  const [stateTargetKey, setStateTargetKey] = useState4(targetKey);
-  const [loading, setLoading] = useState4(enabled);
-  const [error, setError] = useState4(null);
-  const [mutationError, setMutationError] = useState4(null);
-  const [pendingByTurn, setPendingByTurn] = useState4({});
+  const [snapshot, setSnapshot] = useState3(null);
+  const [stateTargetKey, setStateTargetKey] = useState3(targetKey);
+  const [loading, setLoading] = useState3(enabled);
+  const [error, setError] = useState3(null);
+  const [mutationError, setMutationError] = useState3(null);
+  const [pendingByTurn, setPendingByTurn] = useState3({});
+  const [acceptedSteers, setAcceptedSteers] = useState3([]);
   const pendingRef = useRef3({});
   const readGeneration = useRef3(0);
   const targetKeyRef = useRef3(targetKey);
@@ -1301,8 +1426,21 @@ function useTurnQueue(sessionId, options = {}) {
     setError(null);
     setMutationError(null);
     setPendingByTurn({});
+    setAcceptedSteers([]);
   }, [enabled, targetKey]);
-  const acceptSnapshot = useCallback4(
+  useEffect3(() => {
+    if (acceptedSteers.length === 0 || options.events === void 0) return;
+    const durablyStartedTurnIds = new Set(
+      options.events.flatMap(
+        (event) => event.type === "turn.started" && event.turnId ? [event.turnId] : []
+      )
+    );
+    if (durablyStartedTurnIds.size === 0) return;
+    setAcceptedSteers(
+      (current) => current.filter((steer) => !durablyStartedTurnIds.has(steer.turnId))
+    );
+  }, [acceptedSteers.length, options.events]);
+  const acceptSnapshot = useCallback3(
     (ownedTargetKey, next) => {
       if (targetKeyRef.current !== ownedTargetKey) return false;
       const current = snapshotRef.current;
@@ -1316,7 +1454,7 @@ function useTurnQueue(sessionId, options = {}) {
     },
     []
   );
-  const load = useCallback4(
+  const load = useCallback3(
     async (rejectOnFailure = false) => {
       if (!sessionId) return;
       const ownedTargetKey = `${workspaceId}\0${sessionId}`;
@@ -1347,7 +1485,7 @@ function useTurnQueue(sessionId, options = {}) {
     },
     [client, workspaceId, sessionId, acceptSnapshot]
   );
-  useEffect4(() => {
+  useEffect3(() => {
     if (!enabled || !pageLive) {
       setLoading(false);
       return;
@@ -1376,10 +1514,10 @@ function useTurnQueue(sessionId, options = {}) {
       readGeneration.current += 1;
     };
   }, [load, enabled, pageLive, options.pollIntervalMs]);
-  useEffect4(() => {
+  useEffect3(() => {
     if (enabled && workspaceControlEvent) void load();
   }, [enabled, load, workspaceControlEvent]);
-  useEffect4(() => {
+  useEffect3(() => {
     if (!sessionId || !enabled) return;
     return registerSessionReconciler(sessionId, "queue", load);
   }, [enabled, load, registerSessionReconciler, sessionId]);
@@ -1396,7 +1534,7 @@ function useTurnQueue(sessionId, options = {}) {
     },
     async () => await load(true)
   );
-  const mutate = useCallback4(
+  const mutate = useCallback3(
     async (turnId, kind, command) => {
       const ownedTargetKey = targetKey;
       if (!sessionId || targetKeyRef.current !== ownedTargetKey || pendingRef.current[turnId]) {
@@ -1409,8 +1547,15 @@ function useTurnQueue(sessionId, options = {}) {
       setStateTargetKey(ownedTargetKey);
       setPendingByTurn(pendingRef.current);
       setMutationError(null);
+      const clientEventId = operationKey();
       try {
-        const result = await command(current, turn);
+        let result;
+        try {
+          result = await command(current, turn, clientEventId);
+        } catch (cause) {
+          if (!isOutcomeUnknownError(cause)) throw cause;
+          result = await command(current, turn, clientEventId);
+        }
         if (targetKeyRef.current !== ownedTargetKey) return null;
         acceptSnapshot(ownedTargetKey, result.snapshot);
         return result;
@@ -1431,13 +1576,13 @@ function useTurnQueue(sessionId, options = {}) {
     },
     [acceptSnapshot, load, sessionId, targetKey]
   );
-  const moveTurn = useCallback4(
+  const moveTurn = useCallback3(
     async (turnId, beforeTurnId) => {
       const result = await mutate(
         turnId,
         "move",
-        (current) => client.moveQueueItem(workspaceId, sessionId, turnId, {
-          clientEventId: operationKey(),
+        (current, _turn, clientEventId) => client.moveQueueItem(workspaceId, sessionId, turnId, {
+          clientEventId,
           expectedQueueVersion: current.version,
           beforeTurnId
         })
@@ -1446,13 +1591,13 @@ function useTurnQueue(sessionId, options = {}) {
     },
     [client, mutate, sessionId, workspaceId]
   );
-  const editTurn = useCallback4(
+  const editTurn = useCallback3(
     async (turnId, edit) => {
       const result = await mutate(
         turnId,
         "edit",
-        (_current, turn) => client.editQueueItem(workspaceId, sessionId, turnId, {
-          clientEventId: operationKey(),
+        (_current, turn, clientEventId) => client.editQueueItem(workspaceId, sessionId, turnId, {
+          clientEventId,
           expectedTurnVersion: turn.version,
           expectedDraftRevision: edit.expectedDraftRevision,
           replaceDraft: edit.replaceDraft
@@ -1462,28 +1607,65 @@ function useTurnQueue(sessionId, options = {}) {
     },
     [client, mutate, sessionId, workspaceId]
   );
-  const steerTurn = useCallback4(
+  const steerTurn = useCallback3(
     async (turnId) => {
+      const ownedTargetKey = targetKey;
+      const turn = snapshotRef.current?.items.find((candidate) => candidate.id === turnId);
+      if (targetKeyRef.current !== ownedTargetKey) return false;
+      if (!turn) {
+        setMutationError(new Error("That queued prompt changed before Steer could be sent."));
+        await load();
+        return false;
+      }
+      const optimistic = {
+        turnId: turn.id,
+        triggerEventId: turn.triggerEventId,
+        text: turn.prompt,
+        annotations: turn.annotations ?? [],
+        resources: turn.resources,
+        tools: turn.tools,
+        occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+        state: "sending"
+      };
+      setAcceptedSteers((current) => [
+        ...current.filter((steer) => steer.turnId !== turnId),
+        optimistic
+      ]);
       const result = await mutate(
         turnId,
         "steer",
-        (current, turn) => client.steerQueueItem(workspaceId, sessionId, turnId, {
-          clientEventId: operationKey(),
-          expectedTurnVersion: turn.version,
+        (current, queuedTurn, clientEventId) => client.steerQueueItem(workspaceId, sessionId, turnId, {
+          clientEventId,
+          expectedTurnVersion: queuedTurn.version,
           controlEtag: current.effectiveControl.controlEtag
         })
       );
-      return result !== null;
+      if (targetKeyRef.current !== ownedTargetKey) return false;
+      const advancedWithoutSteer = result === null && snapshotRef.current !== null && !snapshotRef.current.items.some((candidate) => candidate.id === turnId);
+      if (advancedWithoutSteer) {
+        setMutationError(null);
+        setAcceptedSteers((current) => current.filter((steer) => steer.turnId !== turnId));
+        return true;
+      }
+      const accepted = result !== null || snapshotRef.current?.items.some(
+        (candidate) => candidate.id === turnId && candidate.metadata.delivery === "steer"
+      ) === true;
+      setAcceptedSteers(
+        (current) => accepted ? current.map(
+          (steer) => steer.turnId === turnId ? { ...steer, state: "queued" } : steer
+        ) : current.filter((steer) => steer.turnId !== turnId)
+      );
+      return accepted;
     },
-    [client, mutate, sessionId, workspaceId]
+    [client, load, mutate, sessionId, targetKey, workspaceId]
   );
-  const removeTurn = useCallback4(
+  const removeTurn = useCallback3(
     async (turnId) => {
       const result = await mutate(
         turnId,
         "delete",
-        (_current, turn) => client.deleteQueueItem(workspaceId, sessionId, turnId, {
-          clientEventId: operationKey(),
+        (_current, turn, clientEventId) => client.deleteQueueItem(workspaceId, sessionId, turnId, {
+          clientEventId,
           expectedTurnVersion: turn.version,
           reason: "Deleted from the prompt queue"
         })
@@ -1499,7 +1681,7 @@ function useTurnQueue(sessionId, options = {}) {
     () => Object.keys(visiblePendingByTurn).length > 0,
     [visiblePendingByTurn]
   );
-  const mutationFor = useCallback4(
+  const mutationFor = useCallback3(
     (turnId) => visiblePendingByTurn[turnId] ?? null,
     [visiblePendingByTurn]
   );
@@ -1522,221 +1704,448 @@ function useTurnQueue(sessionId, options = {}) {
     mutationFor,
     mutating,
     mutationError: identityMatches ? mutationError : null,
-    clearMutationError: useCallback4(() => {
+    clearMutationError: useCallback3(() => {
       if (targetKeyRef.current === targetKey) setMutationError(null);
-    }, [targetKey])
+    }, [targetKey]),
+    acceptedSteers: identityMatches ? acceptedSteers : []
   };
 }
 function operationKey() {
   return globalThis.crypto.randomUUID();
 }
 function asError(cause) {
-  return cause instanceof Error ? cause : new Error(String(cause));
+  return normalizeError(cause);
 }
-
-// src/hooks/use-goal.ts
-import { OpenGeniApiError } from "@opengeni/sdk";
-import { useCallback as useCallback5, useEffect as useEffect5, useRef as useRef4, useState as useState5 } from "react";
-function isGoalEvent(event) {
-  return event.type.startsWith("goal.");
+function isOutcomeUnknownError(cause) {
+  return typeof cause === "object" && cause !== null && cause.outcomeUnknown === true;
 }
-function isGoalRefreshEvent(event) {
-  const type = event.type;
-  return isGoalEvent(event) || type.startsWith("turn.") || type.startsWith("session.") || type.startsWith("system.update.") || type.startsWith("workspace.inference.") || type.startsWith("user.");
+
+// src/hooks/use-human-input.ts
+import { useCallback as useCallback4, useEffect as useEffect4, useRef as useRef4, useState as useState4 } from "react";
+function isHumanInputEvent(event) {
+  return event.type === "session.humanInput.requested" || event.type === "user.humanInputResponse" || event.type === "turn.completed" || event.type === "turn.failed" || event.type === "turn.cancelled";
 }
-function useGoal(sessionId, options = {}) {
-  const { client, workspaceId } = useEmbeddedGoal(options);
+function useHumanInputRequests(sessionId, options = {}) {
+  const { client, workspaceId, registerSessionReconciler } = useEmbeddedHumanInputSession(options);
   const enabled = (options.enabled ?? true) && Boolean(sessionId);
-  const sharedEvents = options.events;
-  const sharedFeed = sharedEvents !== void 0;
-  const pageLive = usePageLiveActivity();
-  const [goal, setGoal] = useState5(null);
-  const [loading, setLoading] = useState5(enabled);
-  const [error, setError] = useState5(null);
-  const { run, mutating, mutationError, clearMutationError } = useMutationRunner();
-  const generation = useRef4(0);
-  const targetKeyRef = useRef4(null);
-  const load = useCallback5(async () => {
-    if (!sessionId) {
-      return;
-    }
-    const ticket = ++generation.current;
-    try {
-      const fetched = await client.getGoal(workspaceId, sessionId);
-      if (ticket === generation.current) {
-        setGoal(fetched);
-        setError(null);
-        setLoading(false);
-      }
-    } catch (cause) {
-      if (ticket !== generation.current) {
-        return;
-      }
-      if (cause instanceof OpenGeniApiError && cause.status === 404) {
-        setGoal(null);
-        setError(null);
-      } else {
-        setError(cause instanceof Error ? cause : new Error(String(cause)));
-      }
-      setLoading(false);
-    }
-  }, [client, workspaceId, sessionId]);
-  useEffect5(() => {
-    const targetKey = `${workspaceId} ${sessionId ?? ""}`;
-    if (targetKeyRef.current !== targetKey) {
-      targetKeyRef.current = targetKey;
-      setGoal(null);
-      setError(null);
-    }
-    if (!enabled || !pageLive) {
-      setLoading(false);
-      return;
-    }
-    if (sharedFeed) {
-      setLoading(false);
-      return () => {
-        generation.current += 1;
-      };
-    }
-    setLoading(true);
-    const pollIntervalMs = options.pollIntervalMs;
-    if (pollIntervalMs === void 0 || pollIntervalMs <= 0) {
-      void load();
-      return () => {
-        generation.current += 1;
-      };
-    }
-    let cancelled = false;
-    let timer = null;
-    const schedule = () => {
-      if (cancelled) return;
-      timer = setTimeout(() => {
-        timer = null;
-        void load().finally(schedule);
-      }, pollIntervalMs);
-    };
-    void load().finally(schedule);
-    return () => {
-      cancelled = true;
-      if (timer !== null) clearTimeout(timer);
-      generation.current += 1;
-    };
-  }, [load, enabled, pageLive, workspaceId, sessionId, options.pollIntervalMs, sharedFeed]);
-  const scheduleRefresh = useDebouncedCallback(() => void load());
-  useSessionEventTrigger(client, workspaceId, sessionId, isGoalRefreshEvent, scheduleRefresh, {
+  const load = useCallback4(
+    async () => sessionId ? await client.listHumanInputRequests(workspaceId, sessionId, { status: "pending" }) : [],
+    [client, sessionId, workspaceId]
+  );
+  const state = usePolledValue(load, {
     enabled,
-    ...sharedEvents !== void 0 ? { events: sharedEvents } : {}
+    pollIntervalMs: options.pollIntervalMs
   });
-  const pause = useCallback5(
-    async (rationale) => {
-      if (!sessionId) {
-        return null;
-      }
-      const result = await run(
-        () => client.updateGoal(workspaceId, sessionId, {
-          status: "paused",
-          ...rationale !== void 0 ? { rationale } : {}
-        })
-      );
-      if (result) {
-        setGoal(result);
+  const loadedRequests = state.data;
+  const refreshRequests = state.refresh;
+  const mutation = useMutationRunner(`${workspaceId}\0${sessionId ?? ""}`);
+  const [respondingRequestId, setRespondingRequestId] = useState4(null);
+  const [deadlineVersion, setDeadlineVersion] = useState4(0);
+  const respondingRequestRef = useRef4(null);
+  useEffect4(() => {
+    respondingRequestRef.current = null;
+    setRespondingRequestId(null);
+  }, [sessionId, workspaceId]);
+  useEffect4(() => {
+    if (!sessionId || !enabled) return;
+    return registerSessionReconciler(sessionId, "human-input", state.refresh);
+  }, [enabled, registerSessionReconciler, sessionId, state.refresh]);
+  const scheduleRefresh = useDebouncedCallback(() => void state.refresh());
+  useSessionEventTrigger(client, workspaceId, sessionId, isHumanInputEvent, scheduleRefresh, {
+    enabled,
+    ...options.events !== void 0 ? { events: options.events } : {}
+  });
+  useEffect4(() => {
+    const now2 = Date.now();
+    const nextDeadline = (loadedRequests ?? []).reduce((next, request) => {
+      if (request.status !== "pending" || !request.expiresAt) return next;
+      const deadline = Date.parse(request.expiresAt);
+      if (!Number.isFinite(deadline) || deadline <= now2) return next;
+      return next === null ? deadline : Math.min(next, deadline);
+    }, null);
+    if (nextDeadline === null) return;
+    const timer = globalThis.setTimeout(
+      () => {
+        setDeadlineVersion((current) => current + 1);
+        void refreshRequests();
+      },
+      Math.min(2147483647, Math.max(0, nextDeadline - now2 + 1))
+    );
+    return () => globalThis.clearTimeout(timer);
+  }, [loadedRequests, refreshRequests]);
+  const respond = useCallback4(
+    async (requestId, response) => {
+      if (!sessionId || respondingRequestRef.current !== null) return null;
+      respondingRequestRef.current = requestId;
+      setRespondingRequestId(requestId);
+      try {
+        const event = await mutation.run(
+          () => client.submitHumanInputResponse(workspaceId, sessionId, requestId, response, {
+            clientEventId: globalThis.crypto.randomUUID()
+          })
+        );
+        if (event) await state.refresh();
+        return event;
+      } finally {
+        if (respondingRequestRef.current === requestId) {
+          respondingRequestRef.current = null;
+          setRespondingRequestId(null);
+        }
       }
-      return result;
     },
-    [client, workspaceId, sessionId, run]
+    [client, mutation, sessionId, state, workspaceId]
   );
-  const resume = useCallback5(async () => {
-    if (!sessionId) {
-      return null;
-    }
-    const result = await run(() => client.updateGoal(workspaceId, sessionId, { status: "active" }));
-    if (result) {
-      setGoal(result);
-    }
-    return result;
-  }, [client, workspaceId, sessionId, run]);
-  const clearGoal = useCallback5(async () => {
-    if (!sessionId) {
-      return;
-    }
-    const ok = await run(async () => {
-      await client.deleteGoal(workspaceId, sessionId);
-      return true;
-    });
-    if (ok) {
-      generation.current += 1;
-      setGoal(null);
-      setError(null);
-    }
-  }, [client, workspaceId, sessionId, run]);
+  const now = Date.now();
+  void deadlineVersion;
   return {
-    goal,
-    isActive: goal?.status === "active",
-    isPaused: goal?.status === "paused",
-    isCompleted: goal?.status === "completed",
-    loading,
-    error,
-    refresh: load,
-    pause,
-    resume,
-    clearGoal,
-    deleteGoal: clearGoal,
-    updating: mutating,
-    mutationError,
-    clearMutationError
+    requests: [...state.data ?? []].filter((request) => isActionableHumanInputRequest(request, now)).sort(
+      (left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id)
+    ),
+    loading: state.loading,
+    error: state.error,
+    refresh: state.refresh,
+    respond,
+    respondingRequestId,
+    mutationError: mutation.mutationError,
+    clearMutationError: mutation.clearMutationError
   };
 }
 
-// src/hooks/use-session-control.ts
-import { useCallback as useCallback6, useLayoutEffect as useLayoutEffect2, useRef as useRef5 } from "react";
-function useSessionControl(sessionId, options = {}) {
-  const { client, workspaceId } = useEmbeddedSession(options);
-  const approvalTargetKey = `${workspaceId}\0${sessionId ?? ""}`;
-  const pendingApproval = useRef5(null);
-  useLayoutEffect2(() => {
-    if (pendingApproval.current?.targetKey !== approvalTargetKey) {
-      pendingApproval.current = null;
+// src/hooks/use-file-attachments.ts
+import { useCallback as useCallback5, useEffect as useEffect5, useRef as useRef5, useState as useState5 } from "react";
+var isImage = (file) => file.type.startsWith("image/");
+var fallbackAttachmentId = 0;
+function createAttachmentId() {
+  const cryptoSource = globalThis.crypto;
+  if (typeof cryptoSource?.randomUUID === "function") return cryptoSource.randomUUID();
+  fallbackAttachmentId += 1;
+  return `attachment:${Date.now().toString(36)}:${fallbackAttachmentId.toString(36)}`;
+}
+function secureContextRequiredErrorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "secure_context_required" ? error.code : void 0;
+}
+function useFileAttachments(options = {}) {
+  const { client, workspaceId } = useEmbeddedFileAttachments(options);
+  const formatError = useErrorMessage();
+  const pasteFilter = options.pasteFilter ?? isImage;
+  const [attachments, setAttachments] = useState5([]);
+  const attachmentsRef = useRef5(attachments);
+  attachmentsRef.current = attachments;
+  const sources = useRef5(/* @__PURE__ */ new Map());
+  const previewUrls = useRef5(/* @__PURE__ */ new Map());
+  const previewRetainers = useRef5(/* @__PURE__ */ new Map());
+  const pendingPreviewRevocations = useRef5(/* @__PURE__ */ new Set());
+  const revokePreview = useCallback5((id) => {
+    const previewUrl = previewUrls.current.get(id);
+    if (!previewUrl) return;
+    if ((previewRetainers.current.get(id) ?? 0) > 0) {
+      pendingPreviewRevocations.current.add(id);
+      return;
     }
-  }, [approvalTargetKey]);
-  const {
-    run: runControl,
-    mutating: controlling,
-    mutationError: controlError,
-    clearMutationError: clearControlError
-  } = useMutationRunner(approvalTargetKey);
-  const {
-    run: runApproval,
-    mutating: responding,
-    mutationError: approvalError,
-    clearMutationError: clearApprovalError
-  } = useMutationRunner(approvalTargetKey);
-  const pause = useCallback6(
-    async (reason) => {
-      if (!sessionId) {
-        return null;
-      }
-      return await runControl(
-        () => client.pauseSession(workspaceId, sessionId, reason !== void 0 ? { reason } : {})
-      );
+    previewUrls.current.delete(id);
+    pendingPreviewRevocations.current.delete(id);
+    URL.revokeObjectURL(previewUrl);
+  }, []);
+  const revokeAllPreviews = useCallback5(() => {
+    for (const id of previewUrls.current.keys()) revokePreview(id);
+  }, [revokePreview]);
+  const retainPreview = useCallback5(
+    (id) => {
+      if (!previewUrls.current.has(id)) return void 0;
+      previewRetainers.current.set(id, (previewRetainers.current.get(id) ?? 0) + 1);
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        const remaining = (previewRetainers.current.get(id) ?? 1) - 1;
+        if (remaining > 0) {
+          previewRetainers.current.set(id, remaining);
+          return;
+        }
+        previewRetainers.current.delete(id);
+        if (pendingPreviewRevocations.current.has(id)) revokePreview(id);
+      };
     },
-    [client, workspaceId, sessionId, runControl]
+    [revokePreview]
   );
-  const resume = useCallback6(
-    async (reason) => {
-      if (!sessionId) return null;
-      return await runControl(
-        () => client.resumeSession(workspaceId, sessionId, reason !== void 0 ? { reason } : {})
-      );
+  const committedAttachmentIds = useRef5(/* @__PURE__ */ new Set());
+  useEffect5(() => {
+    const currentIds = new Set(attachments.map((attachment) => attachment.id));
+    for (const id of committedAttachmentIds.current) {
+      if (!currentIds.has(id)) revokePreview(id);
+    }
+    committedAttachmentIds.current = currentIds;
+  }, [attachments, revokePreview]);
+  const scopeGeneration = useRef5(0);
+  const previousScope = useRef5({ client, workspaceId });
+  useEffect5(() => {
+    const previous = previousScope.current;
+    if (previous.client === client && previous.workspaceId === workspaceId) return;
+    previousScope.current = { client, workspaceId };
+    scopeGeneration.current += 1;
+    sources.current.clear();
+    revokeAllPreviews();
+    setAttachments([]);
+  }, [client, revokeAllPreviews, workspaceId]);
+  useEffect5(
+    () => () => {
+      scopeGeneration.current += 1;
+      sources.current.clear();
+      revokeAllPreviews();
     },
-    [client, workspaceId, sessionId, runControl]
+    [revokeAllPreviews]
   );
-  const decide = useCallback6(
-    async (approvalId, decision, message) => {
-      if (!sessionId) {
-        return null;
-      }
-      const decisionKey = JSON.stringify([approvalId, decision, message ?? null]);
-      if (pendingApproval.current?.decisionKey !== decisionKey) {
+  const startUpload = useCallback5(
+    (id, file) => {
+      const generation = scopeGeneration.current;
+      void client.uploadFile(workspaceId, {
+        filename: file.name || "file",
+        contentType: file.type || "application/octet-stream",
+        data: file,
+        ...options.scope ? { scope: options.scope } : {}
+      }).then((asset) => {
+        if (scopeGeneration.current !== generation) return;
+        sources.current.delete(id);
+        setAttachments(
+          (current) => current.map(
+            (attachment) => attachment.id === id ? {
+              ...attachment,
+              status: "ready",
+              file: asset,
+              name: asset.filename,
+              contentType: asset.contentType,
+              sizeBytes: asset.sizeBytes,
+              errorCode: void 0,
+              error: void 0,
+              errorCause: void 0
+            } : attachment
+          )
+        );
+      }).catch((error) => {
+        if (scopeGeneration.current !== generation) return;
+        setAttachments(
+          (current) => current.map(
+            (attachment) => attachment.id === id ? {
+              ...attachment,
+              status: "failed",
+              errorCode: secureContextRequiredErrorCode(error),
+              error: formatError(error),
+              errorCause: error
+            } : attachment
+          )
+        );
+      });
+    },
+    [client, workspaceId, options.scope, formatError]
+  );
+  const addFiles = useCallback5(
+    (files) => {
+      for (const file of files) {
+        const id = createAttachmentId();
+        sources.current.set(id, file);
+        const previewUrl = isImage(file) ? URL.createObjectURL(file) : void 0;
+        if (previewUrl) previewUrls.current.set(id, previewUrl);
+        setAttachments((current) => [
+          ...current,
+          {
+            id,
+            name: file.name || "image",
+            contentType: file.type || "application/octet-stream",
+            sizeBytes: file.size,
+            status: "uploading",
+            ...previewUrl ? { previewUrl } : {}
+          }
+        ]);
+        startUpload(id, file);
+      }
+    },
+    [startUpload]
+  );
+  const retry = useCallback5(
+    (id) => {
+      const file = sources.current.get(id);
+      if (!file) {
+        return;
+      }
+      setAttachments(
+        (current) => current.map(
+          (attachment) => attachment.id === id ? {
+            ...attachment,
+            status: "uploading",
+            errorCode: void 0,
+            error: void 0,
+            errorCause: void 0
+          } : attachment
+        )
+      );
+      startUpload(id, file);
+    },
+    [startUpload]
+  );
+  const addFromPaste = useCallback5(
+    (event) => {
+      const clipboardFiles = event.clipboardData?.files;
+      if (!clipboardFiles) {
+        return;
+      }
+      const files = [...clipboardFiles].filter(pasteFilter);
+      if (files.length > 0) {
+        addFiles(files);
+      }
+    },
+    [addFiles, pasteFilter]
+  );
+  const restoreReadyFiles = useCallback5(
+    (files) => {
+      const incoming = /* @__PURE__ */ new Map();
+      for (const file of files) {
+        if (file.status === "ready" && file.workspaceId === workspaceId) {
+          incoming.set(file.id, file);
+        }
+      }
+      setAttachments((current) => {
+        const unresolved = current.filter((attachment) => attachment.status !== "ready");
+        const existingReady = new Map(
+          current.flatMap(
+            (attachment) => attachment.status === "ready" && attachment.file ? [[attachment.file.id, attachment]] : []
+          )
+        );
+        const restored = [...incoming.values()].map((file) => {
+          const existing = existingReady.get(file.id);
+          return existing ? {
+            ...existing,
+            name: file.filename,
+            contentType: file.contentType,
+            sizeBytes: file.sizeBytes,
+            status: "ready",
+            file,
+            errorCode: void 0,
+            error: void 0,
+            errorCause: void 0
+          } : {
+            id: `restored:${file.id}`,
+            name: file.filename,
+            contentType: file.contentType,
+            sizeBytes: file.sizeBytes,
+            status: "ready",
+            file
+            // No source File and no object URL: server metadata is the
+            // only authority restored across page/device boundaries.
+          };
+        });
+        return [...unresolved, ...restored];
+      });
+    },
+    [workspaceId]
+  );
+  const loadPreview = useCallback5(
+    async (id, signal) => {
+      const generation = scopeGeneration.current;
+      const attachment = attachmentsRef.current.find((candidate) => candidate.id === id);
+      const createDownloadUrl = client.createFileDownloadUrl;
+      if (!attachment || attachment.status !== "ready" || !attachment.file || !attachment.contentType.startsWith("image/") || typeof createDownloadUrl !== "function" || signal?.aborted) {
+        return void 0;
+      }
+      const fileId = attachment.file.id;
+      const signed = await createDownloadUrl.call(client, workspaceId, fileId, { signal });
+      if (scopeGeneration.current !== generation || signal?.aborted) return void 0;
+      const current = attachmentsRef.current.find((candidate) => candidate.id === id);
+      if (current?.status !== "ready" || current.file?.id !== fileId) return void 0;
+      return signed.url;
+    },
+    [client, workspaceId]
+  );
+  const remove = useCallback5(
+    (id) => {
+      sources.current.delete(id);
+      revokePreview(id);
+      setAttachments((current) => current.filter((attachment) => attachment.id !== id));
+    },
+    [revokePreview]
+  );
+  const removeReadyFiles = useCallback5((fileIds) => {
+    const accepted = new Set(fileIds);
+    if (accepted.size === 0) return;
+    setAttachments(
+      (current) => current.filter((attachment) => {
+        return !(attachment.status === "ready" && attachment.file !== void 0 && accepted.has(attachment.file.id));
+      })
+    );
+  }, []);
+  const clear = useCallback5(() => {
+    sources.current.clear();
+    revokeAllPreviews();
+    setAttachments([]);
+  }, [revokeAllPreviews]);
+  return {
+    attachments,
+    readyResources: attachments.flatMap(
+      (attachment) => attachment.status === "ready" && attachment.file ? [{ kind: "file", fileId: attachment.file.id }] : []
+    ),
+    uploading: attachments.some((attachment) => attachment.status === "uploading"),
+    hasUnresolved: attachments.some((attachment) => attachment.status !== "ready"),
+    addFiles,
+    addFromPaste,
+    restoreReadyFiles,
+    ...typeof client.createFileDownloadUrl === "function" ? { loadPreview } : {},
+    retry,
+    retainPreview,
+    remove,
+    removeReadyFiles,
+    clear
+  };
+}
+
+// src/hooks/use-session-control.ts
+import { useCallback as useCallback6, useLayoutEffect as useLayoutEffect2, useRef as useRef6 } from "react";
+function useSessionControl(sessionId, options = {}) {
+  const { client, workspaceId } = useEmbeddedSession(options);
+  const approvalTargetKey = `${workspaceId}\0${sessionId ?? ""}`;
+  const pendingApproval = useRef6(null);
+  useLayoutEffect2(() => {
+    if (pendingApproval.current?.targetKey !== approvalTargetKey) {
+      pendingApproval.current = null;
+    }
+  }, [approvalTargetKey]);
+  const {
+    run: runControl,
+    mutating: controlling,
+    mutationError: controlError,
+    clearMutationError: clearControlError
+  } = useMutationRunner(approvalTargetKey);
+  const {
+    run: runApproval,
+    mutating: responding,
+    mutationError: approvalError,
+    clearMutationError: clearApprovalError
+  } = useMutationRunner(approvalTargetKey);
+  const pause = useCallback6(
+    async (reason) => {
+      if (!sessionId) {
+        return null;
+      }
+      return await runControl(
+        () => client.pauseSession(workspaceId, sessionId, reason !== void 0 ? { reason } : {})
+      );
+    },
+    [client, workspaceId, sessionId, runControl]
+  );
+  const resume = useCallback6(
+    async (reason) => {
+      if (!sessionId) return null;
+      return await runControl(
+        () => client.resumeSession(workspaceId, sessionId, reason !== void 0 ? { reason } : {})
+      );
+    },
+    [client, workspaceId, sessionId, runControl]
+  );
+  const decide = useCallback6(
+    async (approvalId, decision, message) => {
+      if (!sessionId) {
+        return null;
+      }
+      const decisionKey = JSON.stringify([approvalId, decision, message ?? null]);
+      if (pendingApproval.current?.decisionKey !== decisionKey) {
         pendingApproval.current = {
           targetKey: approvalTargetKey,
           decisionKey,
@@ -1784,193 +2193,10 @@ function useSessionControl(sessionId, options = {}) {
   };
 }
 
-// src/hooks/use-session-mcp-approval-policy.ts
-import { useCallback as useCallback7, useEffect as useEffect6, useLayoutEffect as useLayoutEffect3, useMemo as useMemo4, useRef as useRef6, useState as useState6 } from "react";
-function isSessionMcpApprovalPolicyEvent(event, serverId) {
-  if (event.type !== "session.mcp.approval_policy.updated") {
-    return false;
-  }
-  if (serverId === void 0) {
-    return true;
-  }
-  const payload = event.payload;
-  return payload?.serverId === serverId;
-}
-function useSessionMcpApprovalPolicy(sessionId, serverId, options = {}) {
-  const { client, workspaceId } = useEmbeddedSessionMcpApprovalPolicy(options);
-  const enabled = (options.enabled ?? true) && Boolean(sessionId && serverId);
-  const [override, setOverride] = useState6(null);
-  const targetKey = `${workspaceId}\0${sessionId ?? ""}\0${serverId ?? ""}`;
-  const authoritativeGeneration = useRef6(0);
-  const mutationIdentity = useMemo4(() => ({ client, targetKey }), [client, targetKey]);
-  const { run, mutating, mutationError, clearMutationError } = useMutationRunner(mutationIdentity);
-  useLayoutEffect3(() => {
-    authoritativeGeneration.current += 1;
-    setOverride(null);
-  }, [client, targetKey]);
-  const load = useCallback7(async () => {
-    const generation = authoritativeGeneration.current;
-    if (!sessionId || !serverId) {
-      return { targetKey, generation, server: null };
-    }
-    const session = await client.getSession(workspaceId, sessionId);
-    return {
-      targetKey,
-      generation,
-      server: session.mcpServers.find((server2) => server2.id === serverId) ?? null
-    };
-  }, [client, serverId, sessionId, targetKey, workspaceId]);
-  const {
-    data,
-    loading,
-    error: loadError,
-    refresh
-  } = usePolledValue(load, {
-    enabled,
-    pollIntervalMs: options.pollIntervalMs
-  });
-  useEffect6(() => {
-    if (data?.targetKey === targetKey && data.generation === authoritativeGeneration.current) {
-      setOverride(null);
-    }
-  }, [data, targetKey]);
-  const scheduleRefresh = useDebouncedCallback(() => void refresh());
-  const matchesPolicyEvent = useCallback7(
-    (event) => isSessionMcpApprovalPolicyEvent(event, serverId ?? void 0),
-    [serverId]
-  );
-  useSessionEventTrigger(
-    client,
-    workspaceId,
-    sessionId,
-    matchesPolicyEvent,
-    scheduleRefresh,
-    {
-      enabled,
-      ...options.events !== void 0 ? { events: options.events } : {}
-    },
-    async () => await refresh()
-  );
-  const update = useCallback7(
-    async (policy) => {
-      if (!sessionId || !serverId) {
-        return null;
-      }
-      const response = await run(
-        () => client.updateSessionMcpApprovalPolicy(workspaceId, sessionId, serverId, {
-          requireApproval: policy
-        })
-      );
-      if (response) {
-        authoritativeGeneration.current += 1;
-        setOverride(response.server);
-        void refresh();
-      }
-      return response;
-    },
-    [client, refresh, run, serverId, sessionId, workspaceId]
-  );
-  const server = override ?? data?.server ?? null;
-  return {
-    server,
-    policy: server?.requireApproval ?? null,
-    loading,
-    error: mutationError ?? loadError,
-    refresh: async () => {
-      await refresh();
-    },
-    update,
-    updating: mutating,
-    clearError: clearMutationError
-  };
-}
-
-// src/hooks/use-session-lineage.ts
-import { useCallback as useCallback8, useEffect as useEffect7, useRef as useRef7 } from "react";
-function isLineageRefreshEvent(event) {
-  if (event.type === "session.status.changed" || event.type === "session.created") {
-    return true;
-  }
-  if (event.type === "agent.toolCall.output") {
-    const payload = event.payload;
-    const name = typeof payload?.name === "string" ? payload.name : typeof payload?.toolName === "string" ? payload.toolName : "";
-    return name === "session_create" || name.endsWith("__session_create");
-  }
-  return false;
-}
-function isSessionCreateToolCallCreated(event) {
-  if (event.type !== "agent.toolCall.created") {
-    return false;
-  }
-  const payload = event.payload;
-  const name = typeof payload?.name === "string" ? payload.name : typeof payload?.toolName === "string" ? payload.toolName : "";
-  return name === "session_create" || name.endsWith("__session_create");
-}
-function useSessionLineage(sessionId, options = {}) {
-  const { client, workspaceId, workspaceControlEvent, registerSessionReconciler } = useEmbeddedSessionLineage(options);
-  const enabled = (options.enabled ?? true) && Boolean(sessionId);
-  const load = useCallback8(
-    async () => sessionId ? await client.getSessionLineage(workspaceId, sessionId) : { ancestors: [], children: [], truncated: false },
-    [client, workspaceId, sessionId]
-  );
-  const state = usePolledValue(load, { pollIntervalMs: options.pollIntervalMs, enabled });
-  const refresh = state.refresh;
-  useEffect7(() => {
-    if (enabled && workspaceControlEvent) void refresh();
-  }, [enabled, refresh, workspaceControlEvent]);
-  useEffect7(() => {
-    if (!sessionId || !enabled) return;
-    return registerSessionReconciler(sessionId, "lineage", refresh);
-  }, [enabled, refresh, registerSessionReconciler, sessionId]);
-  const refreshSoon = useDebouncedCallback(() => void refresh(), 150);
-  const delayedChildRefreshRef = useRef7(null);
-  useEffect7(() => {
-    return () => {
-      if (delayedChildRefreshRef.current !== null) {
-        clearTimeout(delayedChildRefreshRef.current);
-        delayedChildRefreshRef.current = null;
-      }
-    };
-  }, [sessionId, workspaceId]);
-  const refreshAfterChildCreate = useCallback8(() => {
-    void refresh();
-    if (delayedChildRefreshRef.current !== null) {
-      clearTimeout(delayedChildRefreshRef.current);
-    }
-    delayedChildRefreshRef.current = setTimeout(() => {
-      delayedChildRefreshRef.current = null;
-      void refresh();
-    }, 2500);
-  }, [refresh]);
-  useSessionEventTrigger(
-    client,
-    workspaceId,
-    sessionId,
-    isLineageRefreshEvent,
-    refreshSoon,
-    // SHARED-FEED ONLY: without a caller-provided events log the trigger would
-    // open its OWN streamEvents tail — a second live SSE connection next to the
-    // session route's useSessionEvents. A caller with no feed opts into polling
-    // (pollIntervalMs), never a duplicate stream.
-    { events: options.events, enabled: enabled && options.events !== void 0 }
-  );
-  useSessionEventTrigger(
-    client,
-    workspaceId,
-    sessionId,
-    isSessionCreateToolCallCreated,
-    refreshAfterChildCreate,
-    { events: options.events, enabled: enabled && options.events !== void 0 }
-  );
-  return {
-    lineage: state.data,
-    loading: state.loading,
-    error: state.error,
-    refresh
-  };
-}
-
 // src/approvals.ts
+import {
+  parseToolDisplayMetadata
+} from "@opengeni/sdk";
 function approvalsFromRequiresAction(payload) {
   const approvals = payload && typeof payload === "object" ? payload.approvals : void 0;
   if (!Array.isArray(approvals)) {
@@ -1979,11 +2205,13 @@ function approvalsFromRequiresAction(payload) {
   return approvals.map((approval, index) => {
     const raw = approval && typeof approval === "object" ? approval : {};
     const rawItem = raw.rawItem && typeof raw.rawItem === "object" ? raw.rawItem : {};
+    const display = parseToolDisplayMetadata(raw.display);
     return {
       // Mirror the runtime's canonical interruption identity before retaining
       // the legacy top-level callId fallback for already-normalized payloads.
       id: String(rawItem.callId ?? rawItem.id ?? raw.id ?? raw.callId ?? raw.name ?? index),
       name: String(raw.name ?? raw.toolName ?? rawItem.name ?? "approval"),
+      ...display ? { display } : {},
       arguments: raw.arguments ?? rawItem.arguments,
       raw: approval
     };
@@ -2022,140 +2250,80 @@ function projectPendingApprovals(events) {
   return pending;
 }
 
-// src/human-input.ts
-function humanInputRequestFromEvent(event) {
-  if (event.type !== "session.humanInput.requested" || !isRecord(event.payload)) return null;
-  const request = event.payload.request;
-  if (!isRecord(request) || typeof request.id !== "string" || !Array.isArray(request.questions)) {
-    return null;
-  }
-  return {
-    id: request.id,
-    turnId: event.turnId ?? null,
-    questions: request.questions,
-    allowSkip: request.allowSkip === true,
-    expiresAt: typeof request.expiresAt === "string" ? request.expiresAt : null
-  };
-}
-function projectPendingHumanInputRequests(events) {
-  const pending = /* @__PURE__ */ new Map();
-  for (const event of events) {
-    const requested = humanInputRequestFromEvent(event);
-    if (requested) {
-      pending.set(requested.id, requested);
-      continue;
-    }
-    if (event.type === "user.humanInputResponse" && isRecord(event.payload)) {
-      if (typeof event.payload.requestId === "string") pending.delete(event.payload.requestId);
-      continue;
-    }
-    if (event.type === "turn.completed" || event.type === "turn.failed" || event.type === "turn.cancelled") {
-      for (const [id, request] of pending) {
-        if (request.turnId === null || event.turnId === null || event.turnId === void 0 || request.turnId === event.turnId) {
-          pending.delete(id);
-        }
-      }
-    }
-  }
-  return [...pending.values()];
-}
-function isRecord(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-
-// src/hooks/use-human-input.ts
-import { useCallback as useCallback9, useEffect as useEffect8, useRef as useRef8, useState as useState7 } from "react";
-function isHumanInputEvent(event) {
-  return event.type === "session.humanInput.requested" || event.type === "user.humanInputResponse" || event.type === "turn.completed" || event.type === "turn.failed" || event.type === "turn.cancelled";
-}
-function useHumanInputRequests(sessionId, options = {}) {
-  const { client, workspaceId, registerSessionReconciler } = useEmbeddedHumanInputSession(options);
-  const enabled = (options.enabled ?? true) && Boolean(sessionId);
-  const load = useCallback9(
-    async () => sessionId ? await client.listHumanInputRequests(workspaceId, sessionId, { status: "pending" }) : [],
-    [client, sessionId, workspaceId]
+// src/conversation-timeline.ts
+function conversationTimeline(items, queue, composer) {
+  const queued = new Set(
+    queue.queue.filter((turn) => turn.metadata.delivery !== "steer").map((turn) => turn.triggerEventId)
   );
-  const state = usePolledValue(load, {
-    enabled,
-    pollIntervalMs: options.pollIntervalMs
-  });
-  const mutation = useMutationRunner(`${workspaceId}\0${sessionId ?? ""}`);
-  const [respondingRequestId, setRespondingRequestId] = useState7(null);
-  const respondingRequestRef = useRef8(null);
-  useEffect8(() => {
-    respondingRequestRef.current = null;
-    setRespondingRequestId(null);
-  }, [sessionId, workspaceId]);
-  useEffect8(() => {
-    if (!sessionId || !enabled) return;
-    return registerSessionReconciler(sessionId, "human-input", state.refresh);
-  }, [enabled, registerSessionReconciler, sessionId, state.refresh]);
-  const scheduleRefresh = useDebouncedCallback(() => void state.refresh());
-  useSessionEventTrigger(client, workspaceId, sessionId, isHumanInputEvent, scheduleRefresh, {
-    enabled,
-    ...options.events !== void 0 ? { events: options.events } : {}
-  });
-  const respond = useCallback9(
-    async (requestId, response) => {
-      if (!sessionId || respondingRequestRef.current !== null) return null;
-      respondingRequestRef.current = requestId;
-      setRespondingRequestId(requestId);
-      try {
-        const event = await mutation.run(
-          () => client.submitHumanInputResponse(workspaceId, sessionId, requestId, response, {
-            clientEventId: globalThis.crypto.randomUUID()
-          })
-        );
-        if (event) await state.refresh();
-        return event;
-      } finally {
-        if (respondingRequestRef.current === requestId) {
-          respondingRequestRef.current = null;
-          setRespondingRequestId(null);
-        }
-      }
-    },
-    [client, mutation, sessionId, state, workspaceId]
+  const pending = composer.optimisticMessages ?? [];
+  const pendingQueue = new Set(
+    pending.filter(
+      (message) => message.destination === "queue" && !(message.turnId && message.appliedQueueVersion != null && queue.snapshot && queue.snapshot.version >= message.appliedQueueVersion && !queue.queue.some((turn) => turn.id === message.turnId))
+    ).map((message) => `user-message:${message.clientEventId}`)
   );
-  return {
-    requests: [...state.data ?? []].sort(
-      (left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id)
-    ),
-    loading: state.loading,
-    error: state.error,
-    refresh: state.refresh,
-    respond,
-    respondingRequestId,
-    mutationError: mutation.mutationError,
-    clearMutationError: mutation.clearMutationError
-  };
+  const visible = items.filter(
+    (item) => item.kind !== "user-message" || !queued.has(item.id) && !pendingQueue.has(item.reconciliationKey ?? "")
+  );
+  const keys = new Set(
+    visible.flatMap((item) => item.kind === "user-message" ? [item.reconciliationKey] : [])
+  );
+  const optimistic = pending.filter(
+    (message) => (message.destination === "chat" || message.state === "failed") && !keys.has(`user-message:${message.clientEventId}`) && !queue.queue.some((turn) => turn.id === message.turnId)
+  ).map((message) => ({
+    kind: "user-message",
+    id: `optimistic:${message.clientEventId}`,
+    reconciliationKey: `user-message:${message.clientEventId}`,
+    text: message.text,
+    annotations: message.annotations.map((annotation, ordinal) => ({ ...annotation, ordinal })),
+    resources: message.resources,
+    tools: [],
+    occurredAt: message.occurredAt,
+    delivery: {
+      state: message.state,
+      ...message.error ? { error: message.error } : {},
+      ...message.state === "failed" ? {
+        ...message.retryable !== false && composer.retryOptimisticMessage ? { onRetry: () => composer.retryOptimisticMessage?.(message.clientEventId) } : {},
+        ...message.retryable === false && composer.restoreOptimisticMessage ? { onEdit: () => composer.restoreOptimisticMessage?.(message.clientEventId) } : {},
+        onRemove: () => composer.removeOptimisticMessage?.(message.clientEventId)
+      } : {}
+    }
+  }));
+  const ids = new Set(visible.map((item) => item.id));
+  const steers = (queue.acceptedSteers ?? []).filter((steer) => !ids.has(steer.triggerEventId)).map((steer) => ({
+    kind: "user-message",
+    id: steer.triggerEventId,
+    text: steer.text,
+    annotations: steer.annotations,
+    resources: steer.resources,
+    tools: steer.tools,
+    occurredAt: steer.occurredAt,
+    delivery: { state: steer.state }
+  }));
+  return [...visible, ...optimistic, ...steers];
 }
 
 export {
-  isTitleEvent,
-  useSession,
+  isActionableHumanInputRequest,
+  humanInputRequestFromEvent,
+  projectPendingHumanInputRequests,
+  invokeOlderHistoryLoaderWithReceiptCapture,
+  createOlderHistoryLoadReceipt,
   SESSION_EVENT_BROWSER_MAX_BYTES,
   SESSION_EVENT_BROWSER_MAX_COUNT,
-  SESSION_EVENT_BROWSER_SINGLE_EVENT_MAX_BYTES,
   SESSION_EVENT_BROWSER_PENDING_MAX_BYTES,
   SESSION_EVENT_BROWSER_PENDING_MAX_COUNT,
   useSessionEvents,
   boundBrowserSessionEventWindow,
-  useFileAttachments,
+  isTitleEvent,
+  useSession,
   isTurnQueueEvent,
   useTurnQueue,
-  isGoalEvent,
-  useGoal,
+  isHumanInputEvent,
+  useHumanInputRequests,
+  useFileAttachments,
   useSessionControl,
-  isSessionMcpApprovalPolicyEvent,
-  useSessionMcpApprovalPolicy,
-  isLineageRefreshEvent,
-  useSessionLineage,
   approvalsFromRequiresAction,
   projectPendingApprovals,
-  humanInputRequestFromEvent,
-  projectPendingHumanInputRequests,
-  isHumanInputEvent,
-  useHumanInputRequests
+  conversationTimeline
 };
-//# sourceMappingURL=chunk-B6WPZSTT.js.map
+//# sourceMappingURL=chunk-SJZDKVW2.js.map