@opengeni/react 0.28.2 → 0.32.1

package/dist/{chunk-PMSGE233.js → chunk-A2WITZTI.js}

@@ -1,3 +1,8 @@
+import {
+  buildTimeline,
+  groupTimeline,
+  sessionStatusFromEvents
+} from "./chunk-TCCE5ZU5.js";
 import {
   useDebouncedCallback,
   useEmbeddedFileAttachments,
@@ -10,12 +15,7 @@ import {
   useMutationRunner,
   usePolledValue,
   useSessionEventTrigger
-} from "./chunk-HQFPO7VX.js";
-import {
-  buildTimeline,
-  groupTimeline,
-  sessionStatusFromEvents
-} from "./chunk-OCHBZ2X7.js";
+} from "./chunk-7CJOAW3V.js";
 
 // src/hooks/use-session.ts
 import { useCallback, useEffect, useMemo, useState } from "react";
@@ -102,9 +102,15 @@ function useSession(sessionId, options = {}) {
 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;
 var INITIAL_FETCH_CAP = 1;
 var OLDER_GROUP_TARGET = 32;
 var OLDER_FETCH_CAP = 2;
+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 EMPTY_EVENTS = [];
 var encoder = new TextEncoder();
@@ -152,17 +158,28 @@ function useSessionEvents(sessionId, options = {}) {
   const [connectionState, setConnectionState] = useState2("idle");
   const [error, setError] = useState2(null);
   const [hasOlder, setHasOlder] = useState2(false);
+  const [hasNewer, setHasNewer] = useState2(false);
   const [sessionStatusProjection, setSessionStatusProjection] = useState2(
     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 lastSequenceRef = useRef(after);
   const streamResumeSequenceRef = useRef(after);
   const oldestSequenceRef = useRef(null);
+  const newestSequenceRef = useRef(null);
   const hasOlderRef = useRef(false);
+  const hasNewerRef = useRef(false);
   const loadingOlderRef = useRef(false);
+  const loadingNewerRef = useRef(false);
+  const loadingOldestRef = useRef(false);
+  const loadingLatestRef = useRef(false);
+  const viewModeRef = useRef("live");
   const initialWindowLoadedRef = useRef(false);
   const streamAbortRef = useRef(null);
   const streamKeyRef = useRef(null);
@@ -181,15 +198,26 @@ function useSessionEvents(sessionId, options = {}) {
       setEventWindow(EMPTY_EVENT_WINDOW);
       setError(null);
       setHasOlder(false);
+      setHasNewer(false);
       sessionStatusRef.current = { sequence: after, status: null };
       setSessionStatusProjection(null);
       setLoadingOlder(false);
+      setLoadingNewer(false);
+      setLoadingOldest(false);
+      setLoadingLatest(false);
       setInitialLoading(true);
       lastSequenceRef.current = after;
       streamResumeSequenceRef.current = after;
       oldestSequenceRef.current = null;
+      newestSequenceRef.current = null;
       hasOlderRef.current = false;
+      hasNewerRef.current = false;
       loadingOlderRef.current = false;
+      loadingNewerRef.current = false;
+      loadingOldestRef.current = false;
+      loadingLatestRef.current = false;
+      viewModeRef.current = "live";
+      setViewMode("live");
       initialWindowLoadedRef.current = false;
     }
     const generation = generationRef.current + 1;
@@ -202,6 +230,11 @@ function useSessionEvents(sessionId, options = {}) {
       setConnectionState("idle");
       return;
     }
+    if (viewMode === "history") {
+      setConnectionState("idle");
+      setInitialLoading(false);
+      return;
+    }
     const controller = new AbortController();
     const isCurrent = () => generationRef.current === generation && !controller.signal.aborted;
     streamAbortRef.current = controller;
@@ -243,6 +276,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;
       if (retained.truncated) {
         hasOlderRef.current = true;
         setHasOlder(true);
@@ -271,11 +305,14 @@ function useSessionEvents(sessionId, options = {}) {
           eventWindowRef.current = retained;
           setEventWindow(retained);
           oldestSequenceRef.current = retained.events[0]?.sequence ?? window.oldestSequence;
+          newestSequenceRef.current = retained.events.at(-1)?.sequence ?? window.newestSequence;
           hasOlderRef.current = window.hasOlder || retained.truncated;
+          hasNewerRef.current = false;
           lastSequenceRef.current = window.newestSequence;
           streamResumeSequenceRef.current = window.newestSequence;
           initialWindowLoadedRef.current = true;
           setHasOlder(window.hasOlder || retained.truncated);
+          setHasNewer(false);
           setInitialLoading(false);
         }
         if (fullReplay) {
@@ -340,10 +377,12 @@ function useSessionEvents(sessionId, options = {}) {
     fullReplay,
     streamKey,
     streamEpoch,
+    viewMode,
     reconcileSession
   ]);
+  const navigationBusy = () => loadingOlderRef.current || loadingNewerRef.current || loadingOldestRef.current || loadingLatestRef.current;
   const loadOlder = useCallback2(async () => {
-    if (!sessionId || loadingOlderRef.current || !hasOlderRef.current) {
+    if (!sessionId || navigationBusy() || !hasOlderRef.current) {
       return false;
     }
     const before = oldestSequenceRef.current;
@@ -386,22 +425,177 @@ function useSessionEvents(sessionId, options = {}) {
       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);
-      setStreamEpoch((epoch) => epoch + 1);
+      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);
+      }
       return olderStillAvailable;
     } finally {
-      if (generationRef.current === generation) {
-        loadingOlderRef.current = false;
-        setLoadingOlder(false);
+      loadingOlderRef.current = false;
+      setLoadingOlder(false);
+    }
+  }, [client, workspaceId, sessionId]);
+  const loadOldest = useCallback2(async () => {
+    if (!sessionId || navigationBusy() || !hasOlderRef.current) {
+      return false;
+    }
+    const generation = generationRef.current;
+    loadingOldestRef.current = true;
+    setLoadingOldest(true);
+    try {
+      const window = await loadForwardEventWindow(client, workspaceId, sessionId, {
+        after: 0,
+        pageSize: OLDEST_PAGE_SIZE,
+        targetGroups: OLDEST_GROUP_TARGET,
+        maxFetches: OLDEST_FETCH_CAP
+      });
+      if (generationRef.current !== generation) {
+        return false;
+      }
+      if (window.events.length === 0) {
+        hasOlderRef.current = false;
+        setHasOlder(false);
+        return false;
+      }
+      streamAbortRef.current?.abort();
+      observeSessionStatus(window.events, sessionStatusRef, setSessionStatusProjection);
+      const retained = boundBrowserSessionEventWindow(window.events, { direction: "oldest" });
+      const retainedOldest = retained.events[0]?.sequence ?? null;
+      const retainedNewest = retained.events.at(-1)?.sequence ?? null;
+      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;
+      viewModeRef.current = "history";
+      setViewMode("history");
+      return newer;
+    } finally {
+      loadingOldestRef.current = false;
+      setLoadingOldest(false);
+    }
+  }, [client, workspaceId, sessionId]);
+  const loadNewer = useCallback2(async () => {
+    if (!sessionId || navigationBusy() || !hasNewerRef.current) {
+      return false;
+    }
+    const afterSequence = newestSequenceRef.current;
+    if (afterSequence === null) {
+      hasNewerRef.current = false;
+      setHasNewer(false);
+      return false;
+    }
+    const generation = generationRef.current;
+    loadingNewerRef.current = true;
+    setLoadingNewer(true);
+    try {
+      const window = await loadForwardEventWindow(client, workspaceId, sessionId, {
+        after: afterSequence,
+        pageSize: NEWER_PAGE_SIZE,
+        targetGroups: NEWER_GROUP_TARGET,
+        maxFetches: NEWER_FETCH_CAP
+      });
+      if (generationRef.current !== generation) {
+        return false;
+      }
+      if (window.events.length === 0) {
+        hasNewerRef.current = false;
+        setHasNewer(false);
+        streamResumeSequenceRef.current = afterSequence;
+        viewModeRef.current = "live";
+        setViewMode("live");
+        setStreamEpoch((epoch) => epoch + 1);
+        return false;
+      }
+      const current = eventWindowRef.current;
+      assertAppendOrder(current.events, window.events);
+      observeSessionStatus(window.events, sessionStatusRef, setSessionStatusProjection);
+      const previousOldest = current.events[0]?.sequence ?? null;
+      const next = boundBrowserSessionEventWindow([...current.events, ...window.events], {
+        direction: "newest"
+      });
+      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;
+      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 highWater = Math.max(lastSequenceRef.current, retainedNewest);
+      lastSequenceRef.current = highWater;
+      const newer = window.hasNewer || retainedNewest < highWater;
+      hasNewerRef.current = newer;
+      setHasNewer(newer);
+      if (!newer) {
+        streamResumeSequenceRef.current = retainedNewest;
+        viewModeRef.current = "live";
+        setViewMode("live");
+        setStreamEpoch((epoch) => epoch + 1);
+      }
+      return newer;
+    } finally {
+      loadingNewerRef.current = false;
+      setLoadingNewer(false);
     }
   }, [client, workspaceId, sessionId]);
+  const jumpToLatest = useCallback2(async () => {
+    if (!sessionId || navigationBusy()) {
+      return;
+    }
+    loadingLatestRef.current = true;
+    setLoadingLatest(true);
+    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);
+      await Promise.resolve();
+    } finally {
+      loadingLatestRef.current = false;
+      setLoadingLatest(false);
+    }
+  }, [after, sessionId]);
   const identityMatches = stateStreamKey === streamKey;
   const visibleEvents = identityMatches ? eventWindow.events : EMPTY_EVENTS;
   const timeline = useMemo2(() => buildTimeline(visibleEvents), [visibleEvents]);
@@ -417,6 +611,13 @@ function useSessionEvents(sessionId, options = {}) {
     hasOlder: !identityMatches ? false : hasOlder,
     loadingOlder: !identityMatches ? false : loadingOlder,
     loadOlder,
+    hasNewer: !identityMatches ? false : hasNewer,
+    loadingNewer: !identityMatches ? false : loadingNewer,
+    loadNewer,
+    loadingOldest: !identityMatches ? false : loadingOldest,
+    loadOldest,
+    loadingLatest: !identityMatches ? false : loadingLatest,
+    jumpToLatest,
     error: identityMatches ? error : null
   };
 }
@@ -704,6 +905,41 @@ function findBoundaryIndex(events) {
   }
   return -1;
 }
+async function loadForwardEventWindow(client, workspaceId, sessionId, options) {
+  let cursor = options.after;
+  let buffer = [];
+  let fetches = 0;
+  let reachedEnd = false;
+  while (fetches < options.maxFetches) {
+    if (buffer.length > 0 && groupCount(buffer) >= options.targetGroups) {
+      break;
+    }
+    const page = await loadNextPage(client, workspaceId, sessionId, cursor, {
+      pageSize: options.pageSize,
+      ...options.signal ? { signal: options.signal } : {}
+    });
+    fetches += 1;
+    if (page.length === 0) {
+      reachedEnd = true;
+      break;
+    }
+    assertAscending(page);
+    buffer = [...buffer, ...page];
+    cursor = page[page.length - 1].sequence;
+    if (page.length < options.pageSize) {
+      reachedEnd = true;
+      break;
+    }
+  }
+  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
+  };
+}
 async function loadPreviousPage(client, workspaceId, sessionId, before, options) {
   if (options.signal?.aborted) {
     throw abortError();
@@ -727,6 +963,26 @@ async function loadPreviousPage(client, workspaceId, sessionId, before, options)
   }
   return Object.assign(page, { requested });
 }
+async function loadNextPage(client, workspaceId, sessionId, after, options) {
+  if (options.signal?.aborted) {
+    throw abortError();
+  }
+  const requested = options.pageSize;
+  if (requested === 0) {
+    return Object.assign([], { requested });
+  }
+  const page = await client.listEvents(workspaceId, sessionId, {
+    after,
+    limit: requested,
+    compact: true,
+    direction: "after",
+    payloadMode: "full"
+  });
+  if (options.signal?.aborted) {
+    throw abortError();
+  }
+  return Object.assign(page, { requested });
+}
 function groupCount(events) {
   if (events.length === 0) {
     return 0;
@@ -762,6 +1018,14 @@ function assertPrependOrder(existing, older) {
     throw new Error("@opengeni/react: loadOlder returned overlapping session events");
   }
 }
+function assertAppendOrder(existing, newer) {
+  if (!shouldAssertDevelopment() || existing.length === 0 || newer.length === 0) {
+    return;
+  }
+  if (newer[0].sequence <= existing[existing.length - 1].sequence) {
+    throw new Error("@opengeni/react: loadNewer returned overlapping session events");
+  }
+}
 function shouldAssertDevelopment() {
   const processEnv = globalThis.process?.env;
   return processEnv !== void 0 && processEnv.NODE_ENV !== "production";
@@ -1364,12 +1628,97 @@ function useGoal(sessionId, options = {}) {
   };
 }
 
+// src/hooks/use-session-lineage.ts
+import { useCallback as useCallback6, useEffect as useEffect5, useRef as useRef5 } 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 = useCallback6(
+    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;
+  useEffect5(() => {
+    if (enabled && workspaceControlEvent) void refresh();
+  }, [enabled, refresh, workspaceControlEvent]);
+  useEffect5(() => {
+    if (!sessionId || !enabled) return;
+    return registerSessionReconciler(sessionId, "lineage", refresh);
+  }, [enabled, refresh, registerSessionReconciler, sessionId]);
+  const refreshSoon = useDebouncedCallback(() => void refresh(), 150);
+  const delayedChildRefreshRef = useRef5(null);
+  useEffect5(() => {
+    return () => {
+      if (delayedChildRefreshRef.current !== null) {
+        clearTimeout(delayedChildRefreshRef.current);
+        delayedChildRefreshRef.current = null;
+      }
+    };
+  }, [sessionId, workspaceId]);
+  const refreshAfterChildCreate = useCallback6(() => {
+    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/hooks/use-session-control.ts
-import { useCallback as useCallback6, useLayoutEffect as useLayoutEffect2, useRef as useRef5 } from "react";
+import { useCallback as useCallback7, useLayoutEffect as useLayoutEffect2, useRef as useRef6 } from "react";
 function useSessionControl(sessionId, options = {}) {
   const { client, workspaceId } = useEmbeddedSession(options);
   const approvalTargetKey = `${workspaceId}\0${sessionId ?? ""}`;
-  const pendingApproval = useRef5(null);
+  const pendingApproval = useRef6(null);
   useLayoutEffect2(() => {
     if (pendingApproval.current?.targetKey !== approvalTargetKey) {
       pendingApproval.current = null;
@@ -1387,7 +1736,7 @@ function useSessionControl(sessionId, options = {}) {
     mutationError: approvalError,
     clearMutationError: clearApprovalError
   } = useMutationRunner(approvalTargetKey);
-  const pause = useCallback6(
+  const pause = useCallback7(
     async (reason) => {
       if (!sessionId) {
         return null;
@@ -1398,7 +1747,7 @@ function useSessionControl(sessionId, options = {}) {
     },
     [client, workspaceId, sessionId, runControl]
   );
-  const resume = useCallback6(
+  const resume = useCallback7(
     async (reason) => {
       if (!sessionId) return null;
       return await runControl(
@@ -1407,7 +1756,7 @@ function useSessionControl(sessionId, options = {}) {
     },
     [client, workspaceId, sessionId, runControl]
   );
-  const decide = useCallback6(
+  const decide = useCallback7(
     async (approvalId, decision, message) => {
       if (!sessionId) {
         return null;
@@ -1436,16 +1785,16 @@ function useSessionControl(sessionId, options = {}) {
     },
     [approvalTargetKey, client, workspaceId, sessionId, runApproval]
   );
-  const approve = useCallback6(
+  const approve = useCallback7(
     async (approvalId, message) => await decide(approvalId, "approve", message),
     [decide]
   );
-  const reject = useCallback6(
+  const reject = useCallback7(
     async (approvalId, message) => await decide(approvalId, "reject", message),
     [decide]
   );
   const error = approvalError ?? controlError;
-  const clearError = useCallback6(() => {
+  const clearError = useCallback7(() => {
     clearControlError();
     clearApprovalError();
   }, [clearControlError, clearApprovalError]);
@@ -1462,7 +1811,7 @@ function useSessionControl(sessionId, options = {}) {
 }
 
 // src/hooks/use-session-mcp-approval-policy.ts
-import { useCallback as useCallback7, useEffect as useEffect5, useLayoutEffect as useLayoutEffect3, useMemo as useMemo4, useRef as useRef6, useState as useState6 } from "react";
+import { useCallback as useCallback8, useEffect as useEffect6, useLayoutEffect as useLayoutEffect3, useMemo as useMemo4, useRef as useRef7, useState as useState6 } from "react";
 function isSessionMcpApprovalPolicyEvent(event, serverId) {
   if (event.type !== "session.mcp.approval_policy.updated") {
     return false;
@@ -1478,14 +1827,14 @@ function useSessionMcpApprovalPolicy(sessionId, serverId, 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 authoritativeGeneration = useRef7(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 load = useCallback8(async () => {
     const generation = authoritativeGeneration.current;
     if (!sessionId || !serverId) {
       return { targetKey, generation, server: null };
@@ -1506,13 +1855,13 @@ function useSessionMcpApprovalPolicy(sessionId, serverId, options = {}) {
     enabled,
     pollIntervalMs: options.pollIntervalMs
   });
-  useEffect5(() => {
+  useEffect6(() => {
     if (data?.targetKey === targetKey && data.generation === authoritativeGeneration.current) {
       setOverride(null);
     }
   }, [data, targetKey]);
   const scheduleRefresh = useDebouncedCallback(() => void refresh());
-  const matchesPolicyEvent = useCallback7(
+  const matchesPolicyEvent = useCallback8(
     (event) => isSessionMcpApprovalPolicyEvent(event, serverId ?? void 0),
     [serverId]
   );
@@ -1528,7 +1877,7 @@ function useSessionMcpApprovalPolicy(sessionId, serverId, options = {}) {
     },
     async () => await refresh()
   );
-  const update = useCallback7(
+  const update = useCallback8(
     async (policy) => {
       if (!sessionId || !serverId) {
         return null;
@@ -1562,91 +1911,6 @@ function useSessionMcpApprovalPolicy(sessionId, serverId, options = {}) {
   };
 }
 
-// src/hooks/use-session-lineage.ts
-import { useCallback as useCallback8, useEffect as useEffect6, 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;
-  useEffect6(() => {
-    if (enabled && workspaceControlEvent) void refresh();
-  }, [enabled, refresh, workspaceControlEvent]);
-  useEffect6(() => {
-    if (!sessionId || !enabled) return;
-    return registerSessionReconciler(sessionId, "lineage", refresh);
-  }, [enabled, refresh, registerSessionReconciler, sessionId]);
-  const refreshSoon = useDebouncedCallback(() => void refresh(), 150);
-  const delayedChildRefreshRef = useRef7(null);
-  useEffect6(() => {
-    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
 function approvalsFromRequiresAction(payload) {
   const approvals = payload && typeof payload === "object" ? payload.approvals : void 0;
@@ -1823,11 +2087,11 @@ export {
   useTurnQueue,
   isGoalEvent,
   useGoal,
+  isLineageRefreshEvent,
+  useSessionLineage,
   useSessionControl,
   isSessionMcpApprovalPolicyEvent,
   useSessionMcpApprovalPolicy,
-  isLineageRefreshEvent,
-  useSessionLineage,
   approvalsFromRequiresAction,
   projectPendingApprovals,
   humanInputRequestFromEvent,
@@ -1835,4 +2099,4 @@ export {
   isHumanInputEvent,
   useHumanInputRequests
 };
-//# sourceMappingURL=chunk-PMSGE233.js.map
+//# sourceMappingURL=chunk-A2WITZTI.js.map