@beeuni/sdk 0.2.0 → 0.3.0

package/dist/react/use-opencode-sessions/permissions.js

@@ -1,10 +1,37 @@
 import { getClient } from '../../core/runtime/client.js';
 import { unwrap } from './shared.js';
-export async function replyToPermission(requestId, reply, message) {
+const repliesInFlight = new Map();
+function permissionAlreadyAnswered(result) {
+    if (result.response?.status !== 404)
+        return false;
+    const err = result.error;
+    if (typeof err === 'string') {
+        return err.toLowerCase().includes('permission request not found');
+    }
+    if (!err || typeof err !== 'object')
+        return false;
+    const rec = err;
+    const data = rec.data && typeof rec.data === 'object' ? rec.data : undefined;
+    const message = data?.message ?? rec.message ?? rec.error ?? '';
+    return String(message).toLowerCase().includes('permission request not found');
+}
+async function sendPermissionReply(requestId, reply, message) {
     const client = getClient();
     const result = await client.permission.reply({ requestID: requestId, reply, message });
+    if (permissionAlreadyAnswered(result))
+        return;
     unwrap(result);
 }
+export async function replyToPermission(requestId, reply, message) {
+    const inFlight = repliesInFlight.get(requestId);
+    if (inFlight)
+        return inFlight;
+    const send = sendPermissionReply(requestId, reply, message).finally(() => {
+        repliesInFlight.delete(requestId);
+    });
+    repliesInFlight.set(requestId, send);
+    return send;
+}
 const KNOWN_PERMISSION_TYPES = [
     'bash',
     'edit',

package/dist/react/use-project-sessions.d.ts

@@ -9,7 +9,7 @@ export declare function shouldScanPastEmptySessionPages(data: {
     pages: ProjectSessionPage[];
     pageParams: unknown[];
 } | undefined, hasNextPage: boolean): boolean;
-export interface UseProjectSessionsOptions extends Pick<ListProjectSessionsOptions, 'scope' | 'limit' | 'parent' | 'startedBy' | 'q' | 'labels'> {
+export interface UseProjectSessionsOptions extends Pick<ListProjectSessionsOptions, 'scope' | 'limit' | 'parent' | 'startedBy' | 'q' | 'labels' | 'view'> {
     enabled?: boolean;
     refetchInterval?: number | false | ((sessions: ProjectSession[]) => number | false);
     refetchOnWindowFocus?: boolean;

package/dist/react/use-project-sessions.js

@@ -31,9 +31,9 @@ export function shouldScanPastEmptySessionPages(data, hasNextPage) {
 }
 export function useProjectSessions(projectId, options) {
     const scope = options?.scope ?? 'visible';
-    const { parent, startedBy, q, labels } = options ?? {};
+    const { parent, startedBy, q, labels, view } = options ?? {};
     const query = useInfiniteQuery({
-        queryKey: qk.project.sessionsPaged(projectId, scope, { parent, startedBy, q, labels }),
+        queryKey: qk.project.sessionsPaged(projectId, scope, { parent, startedBy, q, labels, view }),
         initialPageParam: null,
         queryFn: ({ pageParam }) => listProjectSessionsPage(projectId, {
             scope,
@@ -43,6 +43,7 @@ export function useProjectSessions(projectId, options) {
             startedBy,
             q,
             labels,
+            view,
         }),
         getNextPageParam: projectSessionsPageParam,
         enabled: options?.enabled ?? true,
@@ -55,12 +56,12 @@ export function useProjectSessions(projectId, options) {
             return interval(flattenProjectSessionPages(query.state.data));
         },
     });
-    const isScanning = shouldScanPastEmptySessionPages(query.data, query.hasNextPage);
-    const { isFetching, fetchNextPage } = query;
+    const isScanning = shouldScanPastEmptySessionPages(query.data, query.hasNextPage) && !query.isError;
+    const { isFetching, data, dataUpdatedAt, fetchNextPage } = query;
     useEffect(() => {
         if (isScanning && !isFetching)
             void fetchNextPage();
-    }, [isScanning, isFetching, fetchNextPage]);
+    }, [isScanning, isFetching, data, dataUpdatedAt, fetchNextPage]);
     return {
         ...query,
         isScanning,

package/dist/react/use-prompt-attachments.js

@@ -22,6 +22,7 @@ export function usePromptAttachments(projectId, options = {}) {
     return useMemo(() => ({
         add: controller.add,
         addMany: controller.addMany,
+        restore: controller.restore,
         retry: controller.retry,
         remove: controller.remove,
         abort: controller.abort,

package/dist/react/use-review-summary.d.ts

@@ -0,0 +1,13 @@
+import { type ApiReviewItem, type ReviewItemsPage, type ReviewItemsQuery } from '../core/rest/projects-client/index.js';
+export declare function useReviewSummary(projectId: string, options?: {
+    enabled?: boolean;
+    refetchInterval?: number | false;
+}): import("@tanstack/react-query").UseQueryResult<import("../index.js").ReviewSummary, Error>;
+export declare function nextReviewItemsCursor(page: ReviewItemsPage): string | undefined;
+export declare function reviewItemsOf(data: {
+    pages: ReadonlyArray<Pick<ReviewItemsPage, 'review_items'>>;
+} | undefined): ApiReviewItem[];
+export declare function useReviewItemPages(projectId: string, query?: ReviewItemsQuery, options?: {
+    enabled?: boolean;
+    refetchInterval?: number | false;
+}): import("@tanstack/react-query").UseInfiniteQueryResult<import("@tanstack/react-query").InfiniteData<ReviewItemsPage, unknown>, Error>;

package/dist/react/use-review-summary.js

@@ -0,0 +1,32 @@
+'use client';
+import { useInfiniteQuery, useQuery } from '@tanstack/react-query';
+import { getReviewSummary, listReviewItems, } from '../core/rest/projects-client/index.js';
+import { qk } from './query-keys.js';
+export function useReviewSummary(projectId, options) {
+    const enabled = Boolean(projectId) && options?.enabled !== false;
+    return useQuery({
+        queryKey: qk.project.reviewSummary(projectId),
+        queryFn: () => getReviewSummary(projectId),
+        enabled,
+        staleTime: 5_000,
+        refetchInterval: enabled ? (options?.refetchInterval ?? 60_000) : false,
+        refetchOnWindowFocus: false,
+    });
+}
+export function nextReviewItemsCursor(page) {
+    return page.next_cursor ?? undefined;
+}
+export function reviewItemsOf(data) {
+    return data?.pages.flatMap((page) => page.review_items) ?? [];
+}
+export function useReviewItemPages(projectId, query = {}, options) {
+    return useInfiniteQuery({
+        queryKey: qk.project.reviewItemPages(projectId, query),
+        queryFn: ({ pageParam }) => listReviewItems(projectId, { ...query, cursor: pageParam }),
+        initialPageParam: undefined,
+        getNextPageParam: nextReviewItemsCursor,
+        enabled: Boolean(projectId) && options?.enabled !== false,
+        staleTime: 5_000,
+        refetchInterval: options?.refetchInterval ?? false,
+    });
+}

package/dist/react/use-runtime-reconnect.js

@@ -1,6 +1,6 @@
 'use client';
 import { useEffect, useRef } from 'react';
-import { getAuthToken } from '../core/http/auth.js';
+import { getAuthToken as getSupabaseAccessToken } from '../core/http/auth.js';
 import { CONNECTION_FAULT_GRACE_MS, getSessionHealth, isRuntimeReady, } from '../core/session/index.js';
 import { incrementSandboxFail, markInitialCheckDone, resetForServerSwitch, resetSandboxFail, setRuntimeHealth, setRuntimeCapabilities, setSandboxStatus, useSandboxConnectionStore, } from '../browser/stores/sandbox-connection-store.js';
 import { useServerStore } from '../browser/stores/server-store.js';
@@ -109,7 +109,7 @@ export function useRuntimeReconnect() {
                     scheduleNext();
                     return;
                 }
-                token = await getAuthToken();
+                token = await getSupabaseAccessToken();
                 if (!token) {
                     scheduleNext();
                     return;

package/dist/react/use-session-list-state.d.ts

@@ -0,0 +1,6 @@
+import { type SessionListState } from '../core/rest/projects-client/sessions.js';
+export declare function useSessionListState(projectId: string): {
+    isPending: boolean;
+    setPinned: (sessionId: string, pinned: boolean) => Promise<SessionListState>;
+    setArchived: (sessionId: string, archived: boolean) => Promise<SessionListState>;
+};

package/dist/react/use-session-list-state.js

@@ -0,0 +1,33 @@
+'use client';
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useMemo } from 'react';
+import { setSessionArchived, setSessionPinned, } from '../core/rest/projects-client/sessions.js';
+import { qk } from './query-keys.js';
+import { updateCachedProjectSessions } from './session-cache-write.js';
+function changedState(session, change, now) {
+    if ('pinned' in change) {
+        return { pinned_at: change.pinned ? (session.pinned_at ?? now) : null, archived_at: change.pinned ? null : (session.archived_at ?? null) };
+    }
+    return { archived_at: change.archived ? (session.archived_at ?? now) : null, pinned_at: change.archived ? null : (session.pinned_at ?? null) };
+}
+export function useSessionListState(projectId) {
+    const client = useQueryClient();
+    const write = (sessionId, state) => updateCachedProjectSessions(client, projectId, (sessions) => sessions.map((session) => (session.session_id === sessionId ? { ...session, ...state(session) } : session)));
+    const mutation = useMutation({
+        mutationFn: ({ sessionId, change }) => 'pinned' in change
+            ? setSessionPinned(projectId, sessionId, change.pinned)
+            : setSessionArchived(projectId, sessionId, change.archived),
+        onMutate: ({ sessionId, change }) => {
+            const now = new Date().toISOString();
+            write(sessionId, (session) => changedState(session, change, now));
+        },
+        onSuccess: (state, { sessionId }) => write(sessionId, () => state),
+        onSettled: () => client.invalidateQueries({ queryKey: [...qk.project.sessionsScope(projectId), 'list-paged'] }),
+    });
+    const { mutateAsync, isPending } = mutation;
+    const actions = useMemo(() => ({
+        setPinned: (sessionId, pinned) => mutateAsync({ sessionId, change: { pinned } }),
+        setArchived: (sessionId, archived) => mutateAsync({ sessionId, change: { archived } }),
+    }), [mutateAsync]);
+    return { ...actions, isPending };
+}

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

@@ -1,11 +1,12 @@
 import { type SessionControlStreamOptions } from '../core/session/control-stream.js';
 import { type LoadSessionLogPage, type SessionLogDialect } from '../core/session-log/source.js';
 import type { SessionLog, SessionLogThread } from '../core/session-log/types.js';
-import { type SessionMessagesSource } from './use-session-messages.js';
+import { type SessionMessagesOptions, type SessionMessagesSource } from './use-session-messages.js';
 export declare function useSessionLog(session: SessionMessagesSource): (SessionLog & {
     source: 'v1' | 'v2';
 }) | null;
-export declare function useSessionLogThread(session: SessionMessagesSource, threadId?: string | null): SessionLogThread | null;
+export declare function useSessionLogRecord(session: Pick<SessionMessagesSource, 'sessionId'>): Partial<Omit<SessionLog, 'threads'>> | null;
+export declare function useSessionLogThread(session: SessionMessagesSource, threadId?: string | null, options?: SessionMessagesOptions): SessionLogThread | null;
 export declare function useSessionLogSync(projectId: string, sessionId: string, options: {
     enabled: boolean;
     loader?: LoadSessionLogPage | null;

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

@@ -4,12 +4,14 @@ import { useSandboxConnectionStore } from '../browser/stores/sandbox-connection-
 import { useSyncStore } from '../browser/stores/sync-store.js';
 import { openSessionStream } from '../core/session/control-stream.js';
 import { savedSessionLogCopies } from '../core/session-log/saved-log.js';
-import { isV1Thread, sessionLogOfV1Rows } from '../core/session-log/v1-view.js';
+import { sessionLogOfV1Rows, sessionLogThreadWithV1Rows } from '../core/session-log/v1-view.js';
 import { fetchFirstSessionLogPage, loadSessionLogPage, negotiateSessionLog, } from '../core/session-log/source.js';
 import { currentSavedCopyStore } from '../core/session-sync/saved-copy-store.js';
 import { selectSessionLog, selectSessionLogThread } from '../core/session-log/store.js';
 import { useFeatureFlag } from './use-feature-flag.js';
-import { useSessionMessages } from './use-session-messages.js';
+import { selectSessionRows } from './session-transcript-subscription.js';
+import { usePacedStoreValue, useSessionMessages } from './use-session-messages.js';
+const PACED = Symbol('paced');
 const sourced = new WeakMap();
 const withSource = (log, source) => {
     let out = sourced.get(log);
@@ -17,9 +19,9 @@ const withSource = (log, source) => {
         sourced.set(log, (out = { ...log, source }));
     return out;
 };
-function useV1SessionLog(session, threadId) {
-    const native = threadId || session.runtimeSessionId || session.opencodeSessionId || null;
-    const rows = useSessionMessages({ ...session, runtimeSessionId: native });
+function useV1SessionLog(session, threadId, enabled, options) {
+    const native = enabled ? threadId || session.runtimeSessionId || session.opencodeSessionId || null : null;
+    const rows = useSessionMessages({ ...session, runtimeSessionId: native, opencodeSessionId: null }, options);
     return useMemo(() => (native && rows.length ? sessionLogOfV1Rows(session.sessionId, native, rows) : null), [session.sessionId, native, rows]);
 }
 export function useSessionLog(session) {
@@ -27,18 +29,27 @@ export function useSessionLog(session) {
         const log = state.sessionLogs[session.sessionId];
         return log ? selectSessionLog(log) : null;
     });
-    const v1 = useV1SessionLog(session);
+    const v1 = useV1SessionLog(session, undefined, !v2);
     return v2 ? withSource(v2, 'v2') : v1 ? withSource(v1, 'v1') : null;
 }
-export function useSessionLogThread(session, threadId) {
-    const v2 = useSyncStore((state) => {
+export function useSessionLogRecord(session) {
+    return useSyncStore((state) => state.sessionLogs[session.sessionId]?.session ?? null);
+}
+export function useSessionLogThread(session, threadId, options) {
+    const throttleMs = options?.throttleMs && options.throttleMs > 0 ? options.throttleMs : 0;
+    const select = (state) => {
         const log = state.sessionLogs[session.sessionId];
-        return log ? selectSessionLogThread(log, threadId) : undefined;
-    });
-    const v1 = useV1SessionLog(session, threadId);
+        if (!log)
+            return undefined;
+        const thread = selectSessionLogThread(log, threadId);
+        return thread && sessionLogThreadWithV1Rows(log, thread, selectSessionRows(state, thread.thread_id), (id) => state.optimisticEchoOf(thread.thread_id, id));
+    };
+    const live = useSyncStore((state) => (throttleMs ? PACED : select(state)));
+    const paced = usePacedStoreValue(select, `${session.sessionId}/${threadId ?? ''}`, throttleMs);
+    const v2 = live === PACED ? paced : live;
+    const v1 = useV1SessionLog(session, threadId, v2 === undefined, options);
     return v2 !== undefined ? v2 : (v1?.threads[0] ?? null);
 }
-const pageThreadIsV1 = (page) => isV1Thread(page.threads.find((t) => t.thread_id === page.thread_id));
 export function useSessionLogSync(projectId, sessionId, options) {
     const loader = options.loader === undefined ? loadSessionLogPage : options.loader;
     const joinStream = options.joinStream ?? openSessionStream;
@@ -71,7 +82,7 @@ export function useSessionLogSync(projectId, sessionId, options) {
             const page = await fetchFirstSessionLogPage(loader, projectId, sessionId, controller.signal);
             if (stopped)
                 return null;
-            if (page && pageThreadIsV1(page)) {
+            if (page) {
                 store().applySessionLogPage(sessionId, page);
                 void copies?.write(projectId, sessionId, page);
             }
@@ -93,15 +104,13 @@ export function useSessionLogSync(projectId, sessionId, options) {
             busy = false;
             if (stopped)
                 return;
-            if (page && pageThreadIsV1(page)) {
+            if (page) {
                 setRefusedKey(null);
                 join({ schema: 'v2', onConnectionChange: onReconnect(() => void load()), onRuntimeResync: () => void load() });
                 return;
             }
             store().dropSessionLog(sessionId);
             setRefusedKey(`${projectId}/${sessionId}`);
-            if (page)
-                return;
             join({
                 onControl: (frame) => {
                     if (frame.type !== 'beeuni.control.turn')
@@ -119,7 +128,7 @@ export function useSessionLogSync(projectId, sessionId, options) {
             const saved = await Promise.resolve(copies?.read(projectId, sessionId) ?? null).catch(() => null);
             if (stopped)
                 return;
-            if (saved && pageThreadIsV1(saved) && !store().sessionLogs[sessionId])
+            if (saved && !store().sessionLogs[sessionId])
                 store().applySessionLogPage(sessionId, saved);
             await attempt();
         })();

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

@@ -1,4 +1,4 @@
-import { type MessageWithParts } from '../browser/stores/sync-store.js';
+import { useSyncStore, type MessageWithParts } from '../browser/stores/sync-store.js';
 export interface SessionMessagesSource {
     projectId: string;
     sessionId: string;
@@ -9,3 +9,4 @@ export interface SessionMessagesOptions {
     throttleMs?: number;
 }
 export declare function useSessionMessages(session: SessionMessagesSource, options?: SessionMessagesOptions): MessageWithParts[];
+export declare function usePacedStoreValue<T>(read: (state: ReturnType<typeof useSyncStore.getState>) => T, key: string, throttleMs: number): T;

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

@@ -16,31 +16,32 @@ export function useSessionMessages(session, options = {}) {
     return useMemo(() => messagesBeforeRewind(rows, rewind), [rows, rewind]);
 }
 function usePacedRows(readableSessionId, throttleMs) {
-    const read = () => readableSessionId ? selectSessionRows(useSyncStore.getState(), readableSessionId) : EMPTY_ROWS;
-    const [state, setState] = useState(() => ({ id: readableSessionId, rows: read() }));
+    return usePacedStoreValue((state) => (readableSessionId ? selectSessionRows(state, readableSessionId) : EMPTY_ROWS), readableSessionId, throttleMs);
+}
+export function usePacedStoreValue(read, key, throttleMs) {
+    const current = () => read(useSyncStore.getState());
+    const [state, setState] = useState(() => ({ key, value: current() }));
     useEffect(() => {
         if (!throttleMs)
             return;
         let lastShownAt = -Infinity;
         let timer = null;
-        let shown = null;
+        let shown;
         const now = () => (typeof performance !== 'undefined' ? performance.now() : Date.now());
         const flush = () => {
             timer = null;
-            const rows = read();
-            if (rows === shown)
+            const value = current();
+            if (value === shown)
                 return;
-            shown = rows;
+            shown = value;
             lastShownAt = now();
-            setState({ id: readableSessionId, rows });
+            setState({ key, value });
         };
-        const initial = read();
+        const initial = current();
         shown = initial;
-        setState((prev) => prev.id === readableSessionId && prev.rows === initial
-            ? prev
-            : { id: readableSessionId, rows: initial });
+        setState((prev) => (prev.key === key && prev.value === initial ? prev : { key, value: initial }));
         const unsubscribe = useSyncStore.subscribe(() => {
-            if (read() === shown)
+            if (current() === shown)
                 return;
             const wait = throttleMs - (now() - lastShownAt);
             if (wait <= 0) {
@@ -57,6 +58,6 @@ function usePacedRows(readableSessionId, throttleMs) {
             if (timer !== null)
                 clearTimeout(timer);
         };
-    }, [readableSessionId, throttleMs]);
-    return state.id === readableSessionId ? state.rows : read();
+    }, [key, throttleMs]);
+    return state.key === key ? state.value : current();
 }

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

@@ -10,19 +10,30 @@ import { qk } from './query-keys.js';
 export function useSessionStreamConnected(projectId, sessionId) {
     return useSyncExternalStore(subscribeSessionStreamConnections, () => !!projectId && !!sessionId && sessionStreamConnected(projectId, sessionId), () => false);
 }
+function openTurnsKey(turns) {
+    return (turns ?? []).map((turn) => turn.turn_token).sort().join(',');
+}
 export function applySessionControlFrame(queryClient, projectId, sessionId, frame, memory, nowMs = Date.now()) {
     if (frame.type === 'beeuni.control.turn') {
         const payload = frame.payload;
         if (!payload?.known || !Array.isArray(payload.turns))
             return;
+        const key = qk.project.sessionTurn(projectId, sessionId);
+        const previous = queryClient.getQueryData(key);
+        const canStop = typeof payload.can_stop === 'boolean'
+            ? payload.can_stop
+            : previous && openTurnsKey(previous.turns) === openTurnsKey(payload.turns)
+                ? previous.can_stop
+                : undefined;
         const observation = {
             turns: payload.turns,
             ...(payload.last_ended ? { last_ended: payload.last_ended } : {}),
             ...(payload.recent_failures ? { recent_failures: payload.recent_failures } : {}),
+            ...(canStop !== undefined ? { can_stop: canStop } : {}),
             ...(payload.working ? { working: payload.working } : {}),
             atMs: nowMs,
         };
-        queryClient.setQueryData(qk.project.sessionTurn(projectId, sessionId), observation);
+        queryClient.setQueryData(key, observation);
         return;
     }
     if (frame.type === 'beeuni.control.session') {

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

@@ -1,6 +1,6 @@
 import type { SessionTranscriptSyncEnvelope } from '../core/rest/projects-client/sessions.js';
-import { loadSessionRuntimeStatus, loadSessionTranscriptMessages } from '../browser/session-sync/session-sync-registry.js';
-export { loadSessionRuntimeStatus, loadSessionTranscriptMessages };
+import { loadSessionExportMessages, loadSessionRuntimeStatus, loadSessionTranscriptMessages } from '../browser/session-sync/session-sync-registry.js';
+export { loadSessionExportMessages, loadSessionRuntimeStatus, loadSessionTranscriptMessages };
 type FileDiff = Omit<import('../core/runtime/runtime-types.js').SnapshotFileDiff, 'patch'> & {
     patch?: string;
     before?: string;

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

@@ -1,18 +1,18 @@
 '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 { getSessionSyncController, loadSessionExportMessages, 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 { hasOnlyCacheSourcedMessages, hasRuntimeConfirmedMessage, 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 };
+export { loadSessionExportMessages, loadSessionRuntimeStatus, loadSessionTranscriptMessages };
 const EMPTY_DIFFS = [];
 const EMPTY_TODOS = [];
 const IDLE_STATUS = { type: 'idle' };
@@ -197,21 +197,23 @@ export function useSessionSync(sessionId, options = {}) {
         setIsLoadingOlderMirror(false);
         mirrorPageInFlight.current = null;
     }, [beeuniSessionScope, sessionId]);
+    const savedCursorCovered = useSyncStore(() => !!mirrorCursor && !sync.hasOlder && hasRuntimeConfirmedMessage(sessionId, mirrorCursor));
+    const savedCursor = savedCursorCovered ? null : mirrorCursor;
     const loadOlder = useCallback(() => {
         const source = chooseOlderSource({
             runtimeHasOlder: sync.hasOlder,
-            mirrorCursor,
+            mirrorCursor: savedCursor,
         });
         if (source === 'runtime')
             return controller.loadOlder();
-        if (source !== 'mirror' || !mirrorCursor)
+        if (source !== 'mirror' || !savedCursor)
             return Promise.resolve();
         if (mirrorPageInFlight.current)
             return mirrorPageInFlight.current;
         setIsLoadingOlderMirror(true);
         const pending = loadOlderSessionTranscriptMirror({
             beeuniSessionScope,
-            before: mirrorCursor,
+            before: savedCursor,
             child: savedChild ? sessionId : undefined,
         })
             .then((envelope) => {
@@ -231,7 +233,7 @@ export function useSessionSync(sessionId, options = {}) {
         });
         mirrorPageInFlight.current = pending;
         return pending;
-    }, [controller, beeuniSessionScope, mirrorCursor, savedChild, sessionId, sync.hasOlder]);
+    }, [controller, beeuniSessionScope, savedCursor, savedChild, sessionId, sync.hasOlder]);
     const retryTranscript = useCallback(() => {
         void controller.reconcile('manual');
     }, [controller]);
@@ -243,7 +245,7 @@ export function useSessionSync(sessionId, options = {}) {
         isBusy,
         isLoading,
         mirrorState,
-        hasOlder: sync.hasOlder || Boolean(mirrorCursor),
+        hasOlder: sync.hasOlder || Boolean(savedCursor),
         isLoadingOlder: sync.isLoadingOlder || isLoadingOlderMirror,
         loadOlder,
         diffs: diffs ?? EMPTY_DIFFS,

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

@@ -1,21 +1,11 @@
 '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 { loadSavedTranscript, 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,
-                }));
-        },
+        queryFn: ({ signal }) => loadSavedTranscript(projectId, sessionId, { signal }),
         enabled: enabled && !!projectId && !!sessionId,
         staleTime: 0,
         gcTime: 0,

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

@@ -11,6 +11,7 @@ export interface SessionTurnObservation {
     turns: SessionTurn[];
     last_ended?: SessionTurnEnded;
     recent_failures?: SessionTurnFailure[];
+    can_stop?: boolean;
     working?: SessionWorkingVerdict;
     atMs: number;
 }
@@ -35,3 +36,4 @@ export declare function readSessionTurnObservation(projectId: string, sessionId:
 }): Promise<SessionTurnObservation>;
 export declare function useSessionWorking(projectId: string, sessionId: string, options?: UseSessionWorkingOptions): WorkingProjection;
 export declare function useSessionTurnOutcome(projectId: string, sessionId: string): SessionTurnOutcome;
+export declare function useSessionCanStop(projectId: string, sessionId: string): boolean;

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

@@ -59,6 +59,7 @@ export async function readSessionTurnObservation(projectId, sessionId, options =
                 turns: turn.turns,
                 last_ended: turn.last_ended,
                 recent_failures: turn.recent_failures,
+                ...(turn.can_stop !== undefined ? { can_stop: turn.can_stop } : {}),
                 atMs: turn.atMs,
             };
         }
@@ -70,6 +71,7 @@ export async function readSessionTurnObservation(projectId, sessionId, options =
             turns: status.turns ?? [],
             last_ended: status.last_ended,
             recent_failures: status.recent_failures,
+            ...(typeof status.can_stop === 'boolean' ? { can_stop: status.can_stop } : {}),
             atMs,
         };
     });
@@ -215,3 +217,11 @@ export function useSessionTurnOutcome(projectId, sessionId) {
     }, [settleInMs, queryClient, projectId, sessionId]);
     return useMemo(() => ({ last_ended: lastEnded, recent_failures: recentFailures, atMs }), [lastEnded, recentFailures, atMs]);
 }
+export function useSessionCanStop(projectId, sessionId) {
+    const query = useQuery({
+        queryKey: qk.project.sessionTurn(projectId, sessionId),
+        queryFn: () => readSessionTurnObservation(projectId, sessionId, { bundle: false }),
+        enabled: false,
+    });
+    return query.data?.can_stop !== false;
+}

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

@@ -6,6 +6,7 @@ import { type AbortSettlement, type PromptPart } from './use-opencode-sessions/i
 import { type SessionPicks } from './use-session-picks.js';
 export type SessionPhase = 'starting' | 'ready' | 'error';
 export declare function shouldRetrySessionStart(failureCount: number, error: unknown, sessionId: string): boolean;
+export declare function presenceReturnReopensSession(heldByThisTab: boolean, cachedStage: string | null | undefined): boolean;
 export declare const SESSION_START_POLL_MS = 1500;
 export declare function resolveSessionRuntimeUrl(start: Pick<SessionStartResult, 'stage' | 'sandbox' | 'runtime_url'> | null | undefined): string | null;
 export interface SendOptions {
@@ -153,6 +154,11 @@ export declare function useSession(projectId: string, sessionId: string, options
     runtimePhase: import("./use-runtime-phase.js").RuntimePhase;
     working: import("../index.js").WorkingProjection;
     isBusy: boolean;
+    canStop: boolean;
+    presenceAwake: {
+        until: Date;
+        capAt: Date;
+    } | null;
     isCompacting: boolean;
     isLoading: boolean;
     savedTranscript: import("../core/session-sync/saved-transcript.js").SavedTranscript;