@beeuni/sdk 0.1.0 → 0.3.0

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

@@ -0,0 +1,143 @@
+'use client';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { useSandboxConnectionStore } from '../browser/stores/sandbox-connection-store.js';
+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 { 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 { 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);
+    if (!out)
+        sourced.set(log, (out = { ...log, source }));
+    return out;
+};
+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) {
+    const v2 = useSyncStore((state) => {
+        const log = state.sessionLogs[session.sessionId];
+        return log ? selectSessionLog(log) : null;
+    });
+    const v1 = useV1SessionLog(session, undefined, !v2);
+    return v2 ? withSource(v2, 'v2') : v1 ? withSource(v1, 'v1') : null;
+}
+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];
+        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);
+}
+export function useSessionLogSync(projectId, sessionId, options) {
+    const loader = options.loader === undefined ? loadSessionLogPage : options.loader;
+    const joinStream = options.joinStream ?? openSessionStream;
+    const active = options.enabled && !!loader && !!projectId && !!sessionId;
+    const live = useSandboxConnectionStore((state) => state.runtimeCapabilities);
+    const served = useRef(null);
+    const key = `${projectId}/${sessionId}`;
+    if (live?.includes('session.log.v2'))
+        served.current = key;
+    const capabilities = served.current === key ? ['session.log.v2'] : live;
+    const flag = useFeatureFlag(active ? projectId : null, 'session_log').enabled;
+    const negotiated = active ? negotiateSessionLog({ capabilities, flag, loader }) : 'v1';
+    const [refusedKey, setRefusedKey] = useState(null);
+    const dialect = negotiated === 'v2' && refusedKey !== key ? 'v2' : 'v1';
+    useEffect(() => {
+        if (negotiated !== 'v2' || !loader)
+            return;
+        const controller = new AbortController();
+        const store = useSyncStore.getState;
+        const copies = savedSessionLogCopies(currentSavedCopyStore());
+        let stream = null;
+        let stopped = false;
+        let busy = false;
+        let lastEnded;
+        const join = (options) => {
+            stream?.close();
+            stream = joinStream({ projectId, sessionId, ...options });
+        };
+        const load = async () => {
+            const page = await fetchFirstSessionLogPage(loader, projectId, sessionId, controller.signal);
+            if (stopped)
+                return null;
+            if (page) {
+                store().applySessionLogPage(sessionId, page);
+                void copies?.write(projectId, sessionId, page);
+            }
+            return page;
+        };
+        const onReconnect = (run) => {
+            let connected = true;
+            return (up) => {
+                if (up && !connected)
+                    run();
+                connected = up;
+            };
+        };
+        const attempt = async () => {
+            if (busy || stopped)
+                return;
+            busy = true;
+            const page = await load();
+            busy = false;
+            if (stopped)
+                return;
+            if (page) {
+                setRefusedKey(null);
+                join({ schema: 'v2', onConnectionChange: onReconnect(() => void load()), onRuntimeResync: () => void load() });
+                return;
+            }
+            store().dropSessionLog(sessionId);
+            setRefusedKey(`${projectId}/${sessionId}`);
+            join({
+                onControl: (frame) => {
+                    if (frame.type !== 'beeuni.control.turn')
+                        return;
+                    const ended = frame.payload?.last_ended?.turn_token ?? null;
+                    const seen = lastEnded;
+                    lastEnded = ended;
+                    if (seen !== undefined && ended !== seen)
+                        void attempt();
+                },
+                onConnectionChange: onReconnect(() => void attempt()),
+            });
+        };
+        void (async () => {
+            const saved = await Promise.resolve(copies?.read(projectId, sessionId) ?? null).catch(() => null);
+            if (stopped)
+                return;
+            if (saved && !store().sessionLogs[sessionId])
+                store().applySessionLogPage(sessionId, saved);
+            await attempt();
+        })();
+        return () => {
+            stopped = true;
+            controller.abort();
+            stream?.close();
+            store().dropSessionLog(sessionId);
+        };
+    }, [negotiated, loader, joinStream, projectId, sessionId]);
+    return dialect;
+}

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;

package/dist/react/use-session.js

@@ -1,6 +1,6 @@
 'use client';
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
-import { useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
 import { useOpenCodeCompactionStore } from '../browser/stores/opencode-compaction-store.js';
 import { useSessionWorkingStore } from '../browser/stores/session-working-store.js';
 import { compactionExpiryAtMs, projectCompacting, serverCompactionRevalidateAtMs, } from '../core/session/compaction.js';
@@ -29,7 +29,7 @@ import { useCanonicalRuntimeSession } from './use-canonical-opencode-session.js'
 import { useRuntimeEventStream } from './use-opencode-events/index.js';
 import { useSessionStream } from './use-session-stream.js';
 import { sessionStreamConnected } from '../core/session/control-stream.js';
-import { presenceReporter, watchHumanPresence } from './human-presence.js';
+import { PRESENCE_AWAKE_REFRESH_MS, presenceAwakeFrom, presenceReporter, watchHumanPresence, } from './human-presence.js';
 import { formatModelString } from './use-opencode-local.js';
 import { runtimeKeys, rejectQuestion as rejectQuestionApi, replyToPermission, replyToQuestion, useAbortRuntimeSession, useExecuteRuntimeCommand, useRuntimeSession, } from './use-opencode-sessions/index.js';
 import { mintSessionWireMessageId } from './use-opencode-sessions/messages.js';
@@ -42,11 +42,13 @@ import { useRuntimePhase } from './use-runtime-phase.js';
 import { useSessionPicks } from './use-session-picks.js';
 import { derivePhase } from './use-session-phase.js';
 import { isEmptyConversation, resolveSavedTranscript } from '../core/session-sync/saved-transcript.js';
+import { useSessionLogSync } from './use-session-log.js';
 import { useSessionSync } from './use-session-sync.js';
 import { selectTranscriptShapeKey } from './session-transcript-subscription.js';
 import { useSessionStartGiveUp } from './use-session-start-give-up.js';
-import { useSessionTurnOutcome, useSessionWorking } from './use-session-working.js';
+import { useSessionCanStop, useSessionTurnOutcome, useSessionWorking } from './use-session-working.js';
 import { cancelSessionTurn } from './session-stop.js';
+import { useTurnEndHandoff } from './turn-end-handoff.js';
 import { useVisibleAgents } from './use-visible-agents.js';
 import { createBeeuni } from '../core/client/beeuni.js';
 import { platformConfig } from '../core/http/config.js';
@@ -59,6 +61,9 @@ export function shouldRetrySessionStart(failureCount, error, sessionId) {
     }
     return !isSessionStartError(error) && failureCount < 3;
 }
+export function presenceReturnReopensSession(heldByThisTab, cachedStage) {
+    return heldByThisTab || cachedStage === 'stopped';
+}
 export const SESSION_START_POLL_MS = 1_500;
 export function resolveSessionRuntimeUrl(start) {
     if (!start || start.stage !== 'ready')
@@ -407,22 +412,53 @@ export function useSession(projectId, sessionId, options = {}) {
     const presenceAlertsRef = useRef(presenceAlerts);
     const presencePageExitRef = useRef(presencePageExit);
     const presenceReporterRef = useRef(null);
+    const lastPresenceActiveRef = useRef(null);
+    const [presenceAwake, setPresenceAwakeState] = useState(null);
+    const presenceAwakeRef = useRef(presenceAwake);
+    const setPresenceAwake = useCallback((next) => {
+        if (next === null && presenceAwakeRef.current === null)
+            return;
+        presenceAwakeRef.current = next;
+        setPresenceAwakeState(next);
+    }, []);
+    const presenceReportRef = useRef(0);
     useEffect(() => {
         if (!browserPresence || !presenceTabId || !projectId || !sessionId)
             return;
         const tab_id = presenceTabId;
         const handle = createBeeuni(platformConfig()).session(projectId, sessionId);
         const reporter = presenceReporter(({ active, alerts }) => {
+            if (active &&
+                lastPresenceActiveRef.current === false &&
+                presenceReturnReopensSession(stoppedByUserRef.current === sessionId, queryClient.getQueryData(sessionStartKey(projectId, sessionId))
+                    ?.stage)) {
+                stoppedByUserRef.current = null;
+                openedAtRef.current = { sessionId, at: Date.now() };
+                void queryClient.invalidateQueries({ queryKey: sessionStartKey(projectId, sessionId) });
+            }
+            lastPresenceActiveRef.current = active;
+            const report = ++presenceReportRef.current;
+            if (!active)
+                setPresenceAwake(null);
             const keepalive = !active && presencePageExitRef.current;
-            void handle.presence({ tab_id, active, alerts }, { keepalive }).catch(() => { });
+            void handle
+                .presence({ tab_id, active, alerts }, { keepalive })
+                .then((res) => {
+                if (active && report === presenceReportRef.current && res.data) {
+                    setPresenceAwake(presenceAwakeFrom(res.data));
+                }
+            })
+                .catch(() => { });
         }, presenceAlertsRef.current);
         presenceReporterRef.current = reporter;
         const stop = watchHumanPresence({ doc: document, win: window }, reporter.report, () => sessionStreamConnected(projectId, sessionId), () => presencePageExitRef.current);
+        const refresh = window.setInterval(reporter.refresh, PRESENCE_AWAKE_REFRESH_MS);
         return () => {
+            window.clearInterval(refresh);
             presenceReporterRef.current = null;
             stop();
         };
-    }, [browserPresence, presenceTabId, projectId, sessionId]);
+    }, [browserPresence, presenceTabId, projectId, sessionId, queryClient]);
     useEffect(() => {
         presenceAlertsRef.current = presenceAlerts;
         presenceReporterRef.current?.setAlerts(presenceAlerts);
@@ -485,6 +521,17 @@ export function useSession(projectId, sessionId, options = {}) {
     const sandbox = startData?.sandbox ?? null;
     const startReady = stage === 'ready';
     const terminal = stage === 'failed' || stage === 'stopped';
+    const startReadyRef = useRef(startReady);
+    useEffect(() => {
+        if (startReady && !startReadyRef.current) {
+            presenceReporterRef.current?.refresh();
+        }
+        else if (!startReady && startReadyRef.current) {
+            presenceReportRef.current += 1;
+            setPresenceAwake(null);
+        }
+        startReadyRef.current = startReady;
+    }, [startReady]);
     useIsomorphicLayoutEffect(() => {
         if (!startEnabled)
             return;
@@ -549,6 +596,7 @@ export function useSession(projectId, sessionId, options = {}) {
     }, [startEnabled, switchedBoxId, refetchStart]);
     useRuntimeEventStream({ enabled: switched, projectId, sessionId });
     const transcriptHistoryEnabled = startEnabled && chatEngine;
+    useSessionLogSync(projectId, sessionId, { enabled: startEnabled });
     const transcriptHistory = useSessionTranscriptHistory(projectId, sessionId, transcriptHistoryEnabled);
     const canonicalSession = useCanonicalRuntimeSession({
         projectId,
@@ -567,11 +615,24 @@ export function useSession(projectId, sessionId, options = {}) {
         enabled,
         runtimeSessionId: ocSessionId,
     });
+    const canStop = useSessionCanStop(projectId, sessionId);
+    const turnRunning = working.state === 'working';
+    const turnRanRef = useRef(turnRunning);
+    useEffect(() => {
+        if (turnRunning) {
+            presenceReportRef.current += 1;
+            setPresenceAwake(null);
+        }
+        else if (turnRanRef.current) {
+            presenceReporterRef.current?.refresh();
+        }
+        turnRanRef.current = turnRunning;
+    }, [turnRunning]);
     const { noteSendReceipt, acceptSendReceipt, clearSendReceipt } = useSessionWorkingStore.getState();
     const rawSync = useSessionSync(chatEngine ? ocSessionId : '', {
         beeuniSessionScope: `${projectId}/${sessionId}`,
         streamConnected,
-        mirror: transcriptHistory.envelope ?? undefined,
+        mirror: transcriptHistory.envelope,
         networkEnabled: switched,
         working: working.state === 'working',
         serverHoldsTurn: working.serverOpenTurnToken !== null,
@@ -589,6 +650,25 @@ export function useSession(projectId, sessionId, options = {}) {
     const messages = useMemo(() => messagesBeforeRewind(sync.messages, restRewind), [sync.messages, restRewind]);
     const turnOutcome = useSessionTurnOutcome(projectId, sessionId);
     const turnRead = typeof turnOutcome.atMs === 'number';
+    const lastEndedToken = turnOutcome.last_ended?.turn_token ?? null;
+    const lastEndedSeenRef = useRef(undefined);
+    useEffect(() => {
+        if (!turnRead)
+            return;
+        const seen = lastEndedSeenRef.current;
+        lastEndedSeenRef.current = lastEndedToken;
+        if (seen !== undefined && seen !== lastEndedToken)
+            presenceReporterRef.current?.refresh();
+    }, [turnRead, lastEndedToken]);
+    useTurnEndHandoff({
+        enabled,
+        projectId,
+        sessionId,
+        runtimeSessionId: ocSessionId || null,
+        working: turnRunning,
+        openTurnToken: working.serverOpenTurnToken,
+        lastEndedToken,
+    });
     const savedEmptyRoot = transcriptHistoryEnabled ? transcriptHistory.emptyRootSessionId : null;
     const emptyProvenForRoot = savedEmptyRoot !== null && savedEmptyRoot === ocSessionId;
     const savedTranscript = resolveSavedTranscript({
@@ -855,6 +935,8 @@ export function useSession(projectId, sessionId, options = {}) {
         runtimePhase,
         working,
         isBusy: working.state === 'working',
+        canStop,
+        presenceAwake,
         isCompacting,
         isLoading: sync.isLoading,
         savedTranscript,