@beeuni/sdk 0.1.0

package/dist/react/use-session-sync.js

@@ -0,0 +1,252 @@
+'use client';
+import { useCallback, useEffect, useRef, useState, useSyncExternalStore } from 'react';
+import { claimSessionCacheOwnership, getSessionCacheOwnership, resolveSessionCacheOwnerScope, sessionCacheOwnerScopesConflict, } from '../browser/session-sync/session-cache-ownership.js';
+import { getSessionSyncController, loadSessionRuntimeStatus, loadSessionTranscriptMessages, resetSessionSyncControllersForSession, retainSessionSyncController, } from '../browser/session-sync/session-sync-registry.js';
+import { loadOlderSessionTranscriptMirror, loadSessionTranscriptMirror, mirrorMessagesForHydrate, parseBeeuniSessionScope, refreshSavedCopy, SAVED_COPY_REFRESH_DELAY_MS, shouldHydrateFromMirror, } from '../browser/session-sync/server-transcript-mirror.js';
+import { currentSavedCopyStore } from '../core/session-sync/saved-copy-store.js';
+import { chooseOlderSource, mirrorCursorAfter } from '../browser/session-sync/mirror-paging.js';
+import { transcriptIsFragment } from '../core/session-sync/fragment.js';
+import { onTabVisible } from '../browser/session-sync/visibility.js';
+import { useSandboxConnectionStore } from '../browser/stores/sandbox-connection-store.js';
+import { hasOnlyCacheSourcedMessages, useSyncStore } from '../browser/stores/sync-store.js';
+import { useCurrentRuntime } from './use-current-runtime.js';
+import { selectSessionRows } from './session-transcript-subscription.js';
+import { canQueryRuntimeSession } from './use-opencode-sessions/index.js';
+export { loadSessionRuntimeStatus, loadSessionTranscriptMessages };
+const EMPTY_DIFFS = [];
+const EMPTY_TODOS = [];
+const IDLE_STATUS = { type: 'idle' };
+export function sessionSyncBusy(input) {
+    return input.working ?? input.streamBusy;
+}
+export function livenessBusy(input) {
+    if (!input.networkEnabled)
+        return false;
+    return sessionSyncBusy(input) || input.serverHoldsTurn === true;
+}
+export function useSessionSync(sessionId, options = {}) {
+    const { beeuniSessionScope, networkEnabled = true, working, serverHoldsTurn, mirror, subscribeMessages = true, savedChild = false, } = options;
+    const runtimeHealthy = useSandboxConnectionStore((state) => state.healthy === true);
+    const runtimeScope = useCurrentRuntime((state) => state.sandboxId) ?? 'none';
+    const cacheOwnerScope = resolveSessionCacheOwnerScope(runtimeScope, beeuniSessionScope);
+    const currentOwner = getSessionCacheOwnership(sessionId);
+    const cacheBelongsToAnotherRuntime = !!sessionId && sessionCacheOwnerScopesConflict(currentOwner, cacheOwnerScope);
+    const readableSessionId = cacheBelongsToAnotherRuntime ? '' : sessionId;
+    const controller = getSessionSyncController(sessionId, undefined, runtimeScope);
+    const sync = useSyncExternalStore(controller.subscribe, controller.getSnapshot, controller.getSnapshot);
+    useEffect(() => {
+        if (!canQueryRuntimeSession(sessionId))
+            return;
+        return useSyncStore.getState().retainSession(sessionId);
+    }, [sessionId]);
+    useEffect(() => {
+        if (!canQueryRuntimeSession(sessionId) || !cacheOwnerScope)
+            return;
+        const claim = claimSessionCacheOwnership(sessionId, cacheOwnerScope);
+        if (!sessionCacheOwnerScopesConflict(claim.previousOwnerScope, cacheOwnerScope)) {
+            return;
+        }
+        resetSessionSyncControllersForSession(sessionId, runtimeScope === 'none' ? undefined : runtimeScope);
+        useSyncStore.getState().clearSession(sessionId);
+    }, [cacheOwnerScope, runtimeScope, sessionId]);
+    const mirrorKey = `${beeuniSessionScope ?? ''}|${sessionId}|${mirror === undefined ? 'read' : mirror === null ? 'null' : 'envelope'}${savedChild ? '|child' : ''}`;
+    const [mirrorAbsentFor, setMirrorAbsentFor] = useState(null);
+    useEffect(() => {
+        if (!canQueryRuntimeSession(sessionId) || !beeuniSessionScope)
+            return;
+        const overSavedCopy = hasOnlyCacheSourcedMessages(sessionId);
+        if ((useSyncStore.getState().messages[sessionId]?.length ?? 0) > 0 && !overSavedCopy)
+            return;
+        const abort = new AbortController();
+        const scope = parseBeeuniSessionScope(beeuniSessionScope);
+        const saved = scope && !savedChild ? currentSavedCopyStore() : null;
+        const paint = (envelope, overCopy) => {
+            const state = useSyncStore.getState();
+            const replaceable = overCopy && hasOnlyCacheSourcedMessages(sessionId);
+            if (!shouldHydrateFromMirror({
+                envelope,
+                runtimeSessionId: sessionId,
+                hasMessages: replaceable ? false : (state.messages[sessionId]?.length ?? 0) > 0,
+            })) {
+                return false;
+            }
+            state.hydrate(sessionId, mirrorMessagesForHydrate(envelope), { source: 'cache' });
+            setMirrorCursor(mirrorCursorAfter(envelope));
+            return true;
+        };
+        let local = null;
+        const applyLocal = (envelope) => {
+            if (abort.signal.aborted || !envelope)
+                return;
+            if (paint(envelope, false))
+                local = envelope;
+        };
+        const kept = saved && scope && !overSavedCopy ? saved.read(scope.projectId, scope.sessionId) : null;
+        const localRead = kept && typeof kept.then === 'function'
+            ? kept.then(applyLocal, () => undefined)
+            : (applyLocal(kept), Promise.resolve());
+        const read = mirror !== undefined
+            ? Promise.resolve(mirror)
+            : loadSessionTranscriptMirror({
+                beeuniSessionScope,
+                signal: abort.signal,
+                child: savedChild ? sessionId : undefined,
+            });
+        void Promise.all([read, localRead]).then(([envelope]) => {
+            if (abort.signal.aborted)
+                return;
+            if (!envelope) {
+                if (!local)
+                    setMirrorAbsentFor(mirrorKey);
+                return;
+            }
+            if (saved && scope)
+                void saved.write(scope.projectId, scope.sessionId, envelope);
+            const olderThanLocal = local !== null &&
+                !!envelope.captured_at &&
+                !!local.captured_at &&
+                Date.parse(envelope.captured_at) < Date.parse(local.captured_at);
+            if (olderThanLocal || !paint(envelope, overSavedCopy || local !== null)) {
+                if (!local)
+                    setMirrorAbsentFor(mirrorKey);
+            }
+        });
+        return () => abort.abort();
+    }, [beeuniSessionScope, sessionId, mirror, mirrorKey, savedChild]);
+    const wasWorking = useRef(false);
+    useEffect(() => {
+        const endedTurn = wasWorking.current && !working;
+        wasWorking.current = working === true;
+        if (!endedTurn || savedChild)
+            return;
+        const scope = parseBeeuniSessionScope(beeuniSessionScope);
+        const saved = currentSavedCopyStore();
+        if (!scope || !saved)
+            return;
+        const timer = setTimeout(() => {
+            void refreshSavedCopy(saved, scope.projectId, scope.sessionId);
+        }, SAVED_COPY_REFRESH_DELAY_MS);
+        return () => clearTimeout(timer);
+    }, [working, beeuniSessionScope, savedChild]);
+    useEffect(() => {
+        if (!networkEnabled || !canQueryRuntimeSession(sessionId) || runtimeScope === 'none')
+            return;
+        resetSessionSyncControllersForSession(sessionId, runtimeScope);
+        const release = retainSessionSyncController(sessionId, runtimeScope);
+        void controller.reconcile('initial');
+        return release;
+    }, [controller, networkEnabled, runtimeScope, sessionId]);
+    useEffect(() => {
+        if (!networkEnabled || !canQueryRuntimeSession(sessionId))
+            return;
+        let repairing = false;
+        const check = (state) => {
+            if (repairing)
+                return;
+            if (!transcriptIsFragment({
+                hasMessages: (state.messages[sessionId]?.length ?? 0) > 0,
+                wasEvicted: state.wasTranscriptEvicted(sessionId),
+            })) {
+                return;
+            }
+            repairing = true;
+            void controller.reconcile('eviction').finally(() => {
+                repairing = false;
+            });
+        };
+        check(useSyncStore.getState());
+        return useSyncStore.subscribe((state) => check(state));
+    }, [controller, networkEnabled, sessionId]);
+    useEffect(() => {
+        if (!networkEnabled || !canQueryRuntimeSession(sessionId))
+            return;
+        return onTabVisible(() => {
+            void controller.reconcile('visible');
+        });
+    }, [controller, networkEnabled, sessionId]);
+    const liveMessages = useSyncStore((state) => subscribeMessages ? selectSessionRows(state, readableSessionId) : null);
+    const messages = liveMessages ?? selectSessionRows(useSyncStore.getState(), readableSessionId);
+    const status = useSyncStore((state) => state.sessionStatus[readableSessionId] ?? IDLE_STATUS);
+    const diffs = useSyncStore((state) => state.diffs[readableSessionId]);
+    const todos = useSyncStore((state) => state.todos[readableSessionId]);
+    const streamBusy = status.type === 'busy' || status.type === 'retry';
+    const isBusy = sessionSyncBusy({ working, streamBusy });
+    const isLoading = !useSyncStore((state) => readableSessionId in state.messages);
+    const mirrorState = !canQueryRuntimeSession(sessionId) || !beeuniSessionScope
+        ? 'idle'
+        : messages.length > 0
+            ? 'painted'
+            : mirrorAbsentFor === mirrorKey
+                ? 'absent'
+                : 'loading';
+    useEffect(() => {
+        if (options.streamConnected === undefined)
+            return;
+        controller.setStreamReliable(options.streamConnected);
+        return () => controller.setStreamReliable(false);
+    }, [controller, options.streamConnected]);
+    useEffect(() => {
+        const readable = canQueryRuntimeSession(sessionId);
+        controller.setBusy(readable && livenessBusy({ networkEnabled, runtimeHealthy, working, streamBusy, serverHoldsTurn }), networkEnabled && readable && runtimeScope !== 'none');
+    }, [controller, streamBusy, networkEnabled, runtimeHealthy, working, serverHoldsTurn, sessionId, runtimeScope]);
+    const [mirrorCursor, setMirrorCursor] = useState(null);
+    const [isLoadingOlderMirror, setIsLoadingOlderMirror] = useState(false);
+    const mirrorPageInFlight = useRef(null);
+    useEffect(() => {
+        setMirrorCursor(null);
+        setIsLoadingOlderMirror(false);
+        mirrorPageInFlight.current = null;
+    }, [beeuniSessionScope, sessionId]);
+    const loadOlder = useCallback(() => {
+        const source = chooseOlderSource({
+            runtimeHasOlder: sync.hasOlder,
+            mirrorCursor,
+        });
+        if (source === 'runtime')
+            return controller.loadOlder();
+        if (source !== 'mirror' || !mirrorCursor)
+            return Promise.resolve();
+        if (mirrorPageInFlight.current)
+            return mirrorPageInFlight.current;
+        setIsLoadingOlderMirror(true);
+        const pending = loadOlderSessionTranscriptMirror({
+            beeuniSessionScope,
+            before: mirrorCursor,
+            child: savedChild ? sessionId : undefined,
+        })
+            .then((envelope) => {
+            if (!envelope?.available || envelope.source !== 'mirror') {
+                setMirrorCursor(null);
+                return;
+            }
+            const rows = mirrorMessagesForHydrate(envelope);
+            if (rows.length > 0) {
+                useSyncStore.getState().hydrate(sessionId, rows, { source: 'cache' });
+            }
+            setMirrorCursor(mirrorCursorAfter(envelope));
+        })
+            .finally(() => {
+            mirrorPageInFlight.current = null;
+            setIsLoadingOlderMirror(false);
+        });
+        mirrorPageInFlight.current = pending;
+        return pending;
+    }, [controller, beeuniSessionScope, mirrorCursor, savedChild, sessionId, sync.hasOlder]);
+    const retryTranscript = useCallback(() => {
+        void controller.reconcile('manual');
+    }, [controller]);
+    return {
+        messages,
+        status,
+        freshness: sync.freshness,
+        retryTranscript,
+        isBusy,
+        isLoading,
+        mirrorState,
+        hasOlder: sync.hasOlder || Boolean(mirrorCursor),
+        isLoadingOlder: sync.isLoadingOlder || isLoadingOlderMirror,
+        loadOlder,
+        diffs: diffs ?? EMPTY_DIFFS,
+        todos: todos ?? EMPTY_TODOS,
+    };
+}

package/dist/react/use-session-transcript-history.d.ts

@@ -0,0 +1,6 @@
+export declare function useSessionTranscriptHistory(projectId: string, sessionId: string, enabled: boolean): {
+    envelope: import("../index.js").SessionTranscriptSyncEnvelope | null;
+    rootSessionId: string | null;
+    emptyRootSessionId: string | null;
+    isLoading: boolean;
+};

package/dist/react/use-session-transcript-history.js

@@ -0,0 +1,38 @@
+'use client';
+import { useQuery } from '@tanstack/react-query';
+import { getSessionTranscriptSync } from '../core/rest/projects-client/sessions.js';
+import { OPEN_BUNDLE_TRANSCRIPT_LIMIT, openBundleHistory, settledOpenBundle, } from '../core/session/open-bundle.js';
+import { savedCopyEmptyRoot } from '../core/session-sync/saved-transcript.js';
+import { qk } from './query-keys.js';
+export function useSessionTranscriptHistory(projectId, sessionId, enabled) {
+    const query = useQuery({
+        queryKey: [...qk.project.session(projectId, sessionId), 'transcript-history'],
+        queryFn: ({ signal }) => {
+            const bundle = settledOpenBundle(projectId, sessionId);
+            return ((bundle && openBundleHistory(bundle)) ??
+                getSessionTranscriptSync(projectId, sessionId, {
+                    limit: OPEN_BUNDLE_TRANSCRIPT_LIMIT,
+                    history: true,
+                    signal,
+                }));
+        },
+        enabled: enabled && !!projectId && !!sessionId,
+        staleTime: 0,
+        gcTime: 0,
+        retry: 1,
+        refetchOnWindowFocus: false,
+    });
+    const data = enabled ? query.data : null;
+    const envelope = data?.available &&
+        data.source === 'mirror' &&
+        (data.runtime_session_id ?? data.opencode_session_id) &&
+        data.messages.length
+        ? data
+        : null;
+    return {
+        envelope,
+        rootSessionId: envelope?.runtime_session_id ?? envelope?.opencode_session_id ?? null,
+        emptyRootSessionId: savedCopyEmptyRoot(data),
+        isLoading: enabled && query.isPending,
+    };
+}

package/dist/react/use-session-working.d.ts

@@ -0,0 +1,37 @@
+import type { SessionStatus } from '../core/runtime/runtime-types.js';
+import { type SessionTurn, type SessionTurnEnded, type SessionTurnFailure } from '../core/rest/projects-client/sessions.js';
+import { type AbortReceipt, type SendReceipt, type WorkingInboxInput, type WorkingInputs, type WorkingProjection } from '../core/session/working.js';
+import type { SessionTurnOutcome } from '../core/session/turn-end-cause.js';
+import { type SessionWorkingVerdict } from '../core/session/working-server.js';
+export declare const WORKING_POLL_IDLE_MS = 15000;
+export declare const WORKING_POLL_ACTIVE_MS = 5000;
+export declare function workingPollMs(projection: WorkingProjection): number;
+export declare function streamTurnPhase(status: SessionStatus | undefined): 'idle' | 'active' | 'none';
+export interface SessionTurnObservation {
+    turns: SessionTurn[];
+    last_ended?: SessionTurnEnded;
+    recent_failures?: SessionTurnFailure[];
+    working?: SessionWorkingVerdict;
+    atMs: number;
+}
+export declare function buildWorkingInputs(input: {
+    turn: SessionTurnObservation | undefined;
+    inbox: WorkingInboxInput | undefined;
+    status: SessionStatus | undefined;
+    statusAtMs: number;
+    statusOrigin?: 'wire' | 'local';
+    activityAtMs?: number;
+    optimistic: SendReceipt | null;
+    abort?: AbortReceipt | null;
+    nowMs: number;
+}): WorkingInputs;
+export interface UseSessionWorkingOptions {
+    enabled?: boolean;
+    runtimeSessionId?: string | null;
+}
+export declare function streamObservationStamp(storeStampMs: number | undefined, nowMs: number): number;
+export declare function readSessionTurnObservation(projectId: string, sessionId: string, options?: {
+    bundle?: boolean;
+}): Promise<SessionTurnObservation>;
+export declare function useSessionWorking(projectId: string, sessionId: string, options?: UseSessionWorkingOptions): WorkingProjection;
+export declare function useSessionTurnOutcome(projectId: string, sessionId: string): SessionTurnOutcome;

package/dist/react/use-session-working.js

@@ -0,0 +1,217 @@
+'use client';
+import { useQuery, useQueryClient } from '@tanstack/react-query';
+import { useEffect, useMemo, useState } from 'react';
+import { useSessionWorkingStore } from '../browser/stores/session-working-store.js';
+import { useSyncStore } from '../browser/stores/sync-store.js';
+import { getSessionTurn, } from '../core/rest/projects-client/sessions.js';
+import { projectWorking, workingExpiryAtMs, } from '../core/session/working.js';
+import { claimOpenBundle, openBundleTurn } from '../core/session/open-bundle.js';
+import { createTickSingleFlight } from '../core/session/single-flight.js';
+import { TURN_END_SETTLE_MS } from '../core/session/turn-end-settle.js';
+import { qk } from './query-keys.js';
+import { usePollOwner } from './use-poll-owner.js';
+import { projectServerWorking, serverWorkingExpiryAtMs, } from '../core/session/working-server.js';
+import { useSessionStreamConnected } from './use-session-stream.js';
+export const WORKING_POLL_IDLE_MS = 15_000;
+export const WORKING_POLL_ACTIVE_MS = 5_000;
+export function workingPollMs(projection) {
+    return projection.state === 'working' ? WORKING_POLL_ACTIVE_MS : WORKING_POLL_IDLE_MS;
+}
+export function streamTurnPhase(status) {
+    if (!status)
+        return 'none';
+    return status.type === 'idle' ? 'idle' : 'active';
+}
+export function buildWorkingInputs(input) {
+    return {
+        nowMs: input.nowMs,
+        optimistic: input.optimistic,
+        abort: input.abort ?? null,
+        inbox: input.inbox ?? null,
+        server: input.turn
+            ? { turns: input.turn.turns, lastEnded: input.turn.last_ended, atMs: input.turn.atMs }
+            : null,
+        activity: input.activityAtMs ? { atMs: input.activityAtMs } : null,
+        stream: input.status
+            ? {
+                type: input.status.type === 'idle'
+                    ? 'idle'
+                    : input.status.type === 'retry'
+                        ? 'retry'
+                        : 'busy',
+                origin: input.statusOrigin ?? 'wire',
+                atMs: input.statusAtMs,
+            }
+            : null,
+    };
+}
+const workingObserverCounts = new Map();
+export function streamObservationStamp(storeStampMs, nowMs) {
+    return storeStampMs ?? nowMs;
+}
+export async function readSessionTurnObservation(projectId, sessionId, options = {}) {
+    const claimed = options.bundle === false ? null : claimOpenBundle(projectId, sessionId);
+    if (claimed) {
+        const bundle = await claimed;
+        const turn = bundle ? openBundleTurn(bundle) : null;
+        if (turn) {
+            return {
+                turns: turn.turns,
+                last_ended: turn.last_ended,
+                recent_failures: turn.recent_failures,
+                atMs: turn.atMs,
+            };
+        }
+    }
+    return turnReads(`${projectId}/${sessionId}`, async () => {
+        const atMs = Date.now();
+        const status = await getSessionTurn(projectId, sessionId);
+        return {
+            turns: status.turns ?? [],
+            last_ended: status.last_ended,
+            recent_failures: status.recent_failures,
+            atMs,
+        };
+    });
+}
+const turnReads = createTickSingleFlight();
+export function useSessionWorking(projectId, sessionId, options = {}) {
+    const { enabled = true, runtimeSessionId = null } = options;
+    const streamKey = runtimeSessionId ?? '';
+    const status = useSyncStore((state) => streamKey ? state.sessionStatus[streamKey] : undefined);
+    const statusOrigin = useSyncStore((state) => streamKey ? state.sessionStatusOrigin[streamKey] : undefined);
+    const statusAtMs = useSyncStore((state) => streamKey ? state.sessionStatusAt[streamKey] : undefined);
+    const optimistic = useSessionWorkingStore((state) => state.receipts[sessionId] ?? null);
+    const abort = useSessionWorkingStore((state) => state.aborts[sessionId] ?? null);
+    const inbox = useSessionWorkingStore((state) => state.inbox[sessionId]);
+    useEffect(() => {
+        if (!sessionId)
+            return;
+        workingObserverCounts.set(sessionId, (workingObserverCounts.get(sessionId) ?? 0) + 1);
+        return () => {
+            const next = (workingObserverCounts.get(sessionId) ?? 1) - 1;
+            if (next > 0) {
+                workingObserverCounts.set(sessionId, next);
+                return;
+            }
+            workingObserverCounts.delete(sessionId);
+            useSessionWorkingStore.getState().clearSession(sessionId);
+        };
+    }, [sessionId]);
+    const [observed, setObserved] = useState(null);
+    useEffect(() => {
+        if (!status) {
+            setObserved((previous) => (previous && previous.key === streamKey ? previous : null));
+            return;
+        }
+        setObserved({
+            key: streamKey,
+            status,
+            origin: statusOrigin ?? 'wire',
+            atMs: streamObservationStamp(statusAtMs, Date.now()),
+        });
+    }, [status, statusOrigin, statusAtMs, streamKey]);
+    const stream = observed && observed.key === streamKey ? observed : null;
+    const activityAtMs = useSyncStore((s) => streamKey ? s.sessionActivityAt[streamKey] : undefined);
+    const canRead = enabled && !!projectId && !!sessionId;
+    const inputsFor = (turn, nowMs) => buildWorkingInputs({
+        turn,
+        inbox,
+        status: stream?.status,
+        statusAtMs: stream?.atMs ?? 0,
+        statusOrigin: stream?.origin,
+        activityAtMs,
+        optimistic,
+        abort,
+        nowMs,
+    });
+    const project = (turn, nowMs) => projectWorking(inputsFor(turn, nowMs));
+    const pollOwner = usePollOwner(`turn:${projectId}/${sessionId}`, canRead);
+    const streamConnected = useSessionStreamConnected(projectId, sessionId);
+    const queryClient = useQueryClient();
+    const query = useQuery({
+        queryKey: qk.project.sessionTurn(projectId, sessionId),
+        enabled: canRead,
+        queryFn: () => readSessionTurnObservation(projectId, sessionId, {
+            bundle: queryClient.getQueryData(qk.project.sessionTurn(projectId, sessionId)) === undefined,
+        }),
+        refetchInterval: (query) => pollOwner && !streamConnected ? workingPollMs(project(query.state.data, Date.now())) : false,
+        refetchOnWindowFocus: !streamConnected,
+        retry: 1,
+    });
+    const streamPhase = streamTurnPhase(stream?.status);
+    useEffect(() => {
+        if (!canRead || streamConnected || streamPhase === 'none')
+            return;
+        void queryClient.invalidateQueries({
+            queryKey: qk.project.sessionTurn(projectId, sessionId),
+        });
+        void queryClient.invalidateQueries({
+            queryKey: qk.project.sessionPrompts(projectId, sessionId),
+        });
+    }, [canRead, streamConnected, projectId, sessionId, streamPhase, queryClient]);
+    const drainedAtMs = inbox?.drainedAtMs;
+    useEffect(() => {
+        if (!canRead || streamConnected || drainedAtMs == null)
+            return;
+        void queryClient.invalidateQueries({
+            queryKey: qk.project.sessionTurn(projectId, sessionId),
+        });
+    }, [canRead, streamConnected, projectId, sessionId, drainedAtMs, queryClient]);
+    const inputs = inputsFor(canRead ? query.data : undefined, Date.now());
+    const serverVerdict = canRead && streamConnected ? query.data?.working : undefined;
+    const projection = serverVerdict && query.data
+        ? projectServerWorking({
+            working: serverVerdict,
+            atMs: query.data.atMs,
+            optimistic,
+            abort,
+            nowMs: Date.now(),
+        })
+        : projectWorking(inputs);
+    const [, setExpiryTick] = useState(0);
+    const expiryAtMs = serverVerdict
+        ? serverWorkingExpiryAtMs({ optimistic, abort })
+        : workingExpiryAtMs(inputs);
+    useEffect(() => {
+        if (expiryAtMs === null)
+            return;
+        const timer = setTimeout(() => setExpiryTick((tick) => tick + 1), Math.max(0, expiryAtMs - Date.now()) + 1);
+        return () => clearTimeout(timer);
+    }, [expiryAtMs]);
+    const identity = `${projection.state}|${projection.pendingDelivery ?? false}|${projection.source}|${projection.turnId}|${projection.since}|${projection.serverOpenTurnToken}`;
+    return useMemo(() => projection, [identity]);
+}
+export function useSessionTurnOutcome(projectId, sessionId) {
+    const queryClient = useQueryClient();
+    const query = useQuery({
+        queryKey: qk.project.sessionTurn(projectId, sessionId),
+        queryFn: () => readSessionTurnObservation(projectId, sessionId, { bundle: false }),
+        enabled: false,
+    });
+    const lastEnded = query.data?.last_ended;
+    const recentFailures = query.data?.recent_failures;
+    const atMs = query.data?.atMs;
+    const settleInMs = useMemo(() => {
+        if (typeof atMs !== 'number')
+            return null;
+        let wait = null;
+        for (const failure of recentFailures ?? []) {
+            if (failure.error || !failure.ended_at)
+                continue;
+            const remaining = TURN_END_SETTLE_MS - (atMs - Date.parse(failure.ended_at));
+            if (remaining > 0 && (wait === null || remaining > wait))
+                wait = remaining;
+        }
+        return wait;
+    }, [recentFailures, atMs]);
+    useEffect(() => {
+        if (settleInMs === null)
+            return;
+        const timer = setTimeout(() => {
+            void queryClient.invalidateQueries({ queryKey: qk.project.sessionTurn(projectId, sessionId) });
+        }, settleInMs);
+        return () => clearTimeout(timer);
+    }, [settleInMs, queryClient, projectId, sessionId]);
+    return useMemo(() => ({ last_ended: lastEnded, recent_failures: recentFailures, atMs }), [lastEnded, recentFailures, atMs]);
+}