@opengeni/react 3.1.0 → 3.1.3-canary.38890816741001

package/src/hooks/use-voice-input.ts

@@ -11,6 +11,7 @@ import {
 } from "../voice-recording-store";
 import {
   acquireDefaultVoiceRecordingOwnerLease,
+  liveVoiceRecordingOwnerIds,
   type VoiceRecordingOwnerLease,
 } from "../voice-recording-owner";
 import { appendFinalTranscript } from "./use-transcription";
@@ -65,6 +66,10 @@ export type UseVoiceInputResult = {
   stream: MediaStream | null;
   recordingId: string | null;
   durationSeconds: number;
+  /** Wall-clock start of the current capture (epoch ms), or null when not recording. */
+  recordingStartedAt: number | null;
+  /** Capture stops and transcribes automatically after this many seconds. */
+  maxRecordingSeconds: number | null;
   locallySaved: boolean;
   hasRecoverableRecording: boolean;
   savedTranscript: string | null;
@@ -75,7 +80,10 @@ export type UseVoiceInputResult = {
   retry: () => void;
   /** Explicitly insert a durably saved transcript whose prior handoff may be uncertain. */
   insertSavedTranscript: () => Promise<void>;
-  /** Cancel active work. A stopped/transcribing recording remains recoverable. */
+  /**
+   * Cancel active work without losing speech: a recording longer than a few
+   * seconds and any stopped/transcribing recording stay locally recoverable.
+   */
   cancel: () => void;
   /** Intentionally delete the current durable recording. */
   discard: () => Promise<void>;
@@ -85,6 +93,8 @@ export const VOICE_RECORDING_TIMESLICE_MILLISECONDS = 5_000;
 export const VOICE_RECORDING_OWNER_HEARTBEAT_MILLISECONDS = 5_000;
 export const VOICE_RECORDING_OWNER_STALE_MILLISECONDS = 30_000;
 export const VOICE_RECORDING_CLIENT_MAX_DURATION_SECONDS = 600;
+// Cancel deletes only an accidental start; anything longer is kept for the user.
+const VOICE_RECORDING_DISCARD_ON_CANCEL_MAX_MILLISECONDS = 3_000;
 export const VOICE_RECORDING_RESUMABLE_CLIENT_MAX_DURATION_SECONDS = 8 * 60 * 60;
 export const VOICE_RECORDING_RECOVERY_STATUS_POLL_MILLISECONDS = 2_000;
 export const VOICE_RECORDING_RECOVERY_MAX_MUTATION_DELAY_MILLISECONDS = 30_000;
@@ -159,10 +169,14 @@ export function useVoiceInput({
   const recorderRef = useRef<MediaRecorder | null>(null);
   const streamRef = useRef<MediaStream | null>(null);
   const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  // Cancel/Escape/voice takeover keep a real dictation instead of deleting it.
+  const holdOnStopRef = useRef(false);
+  const recordingStartedAtRef = useRef(0);
   const automaticRetryTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const automaticRetryAttemptRef = useRef(0);
   const ownerHeartbeatTimerRef = useRef<ReturnType<typeof setInterval> | null>(null);
   const controllerRef = useRef<AbortController | null>(null);
+  const disabledRef = useRef(disabled);
   const valueRef = useRef(value);
   const storeRef = useRef<VoiceRecordingStore | null>(null);
   const storePromiseRef = useRef<Promise<VoiceRecordingStore> | null>(null);
@@ -176,6 +190,7 @@ export function useVoiceInput({
   const statusRef = useRef(status);
   valueRef.current = value;
   statusRef.current = status;
+  disabledRef.current = disabled;
   workspaceIdRef.current = workspaceId;
 
   const ensureOwnerId = useCallback(async (): Promise<string> => {
@@ -319,15 +334,31 @@ export function useVoiceInput({
         generation === generationRef.current && workspaceIdRef.current === workspaceId;
       const [store, ownerId] = await Promise.all([ensureStore(), ensureOwnerId()]);
       if (!active()) return;
-      const staleBefore = new Date(
+      const heartbeatStaleBefore = new Date(
         readNow().getTime() - VOICE_RECORDING_OWNER_STALE_MILLISECONDS,
       ).toISOString();
-      await store.cleanupHandedOffManifests({ ownerId, staleBefore }).catch(() => undefined);
+      await store
+        .cleanupHandedOffManifests({ ownerId, staleBefore: heartbeatStaleBefore })
+        .catch(() => undefined);
       if (!active()) return;
-      const manifests = await store.listRecoverableManifests(workspaceId, {
-        ownerId,
-        staleBefore,
-      });
+      // A closed or crashed tab releases its owner lock at once: recover its
+      // recording now rather than after the heartbeat window (the user who
+      // reopens the app right away must still see their dictation).
+      const liveOwners =
+        createOwnerIdRef.current === undefined ? await liveVoiceRecordingOwnerIds() : null;
+      if (!active()) return;
+      const staleBefore = liveOwners ? readNow().toISOString() : heartbeatStaleBefore;
+      const manifests = (
+        await store.listRecoverableManifests(workspaceId, { ownerId, staleBefore })
+      ).filter(
+        (manifest) =>
+          !liveOwners ||
+          !manifest.ownerId ||
+          manifest.ownerId === ownerId ||
+          !liveOwners.has(manifest.ownerId) ||
+          !manifest.ownerHeartbeatAt ||
+          manifest.ownerHeartbeatAt <= heartbeatStaleBefore,
+      );
       if (!active()) return;
       for (const candidate of manifests) {
         try {
@@ -351,14 +382,20 @@ export function useVoiceInput({
           }
           rememberManifest(claimed);
           beginOwnerHeartbeat(claimed);
+          const transcriptReady =
+            claimed.finalizationState === "transcript-ready" && claimed.transcriptText !== null;
           setStatus(
-            claimed.finalizationState === "transcript-ready" && claimed.transcriptText !== null
+            transcriptReady
               ? "transcript-ready"
               : claimed.recoveryMode === "automatic"
                 ? "retrying"
                 : "recovered",
           );
-          setError(null);
+          // An append-mode transcript may already be in the draft (the page
+          // closed between appending and recording the handoff).
+          setError(
+            transcriptReady && candidate.handoffMode === "append" ? "handoff_uncertain" : null,
+          );
           return;
         } catch (reason) {
           if (reason instanceof VoiceRecordingOwnedError) continue;
@@ -462,12 +499,21 @@ export function useVoiceInput({
 
         automaticRetryAttemptRef.current = 0;
         if (ready.handoffMode === "explicit") {
+          // Never appended: offer an explicit insert, not an "already inserted?" warning.
           setStatus("transcript-ready");
-          setError("handoff_uncertain");
+          setError(null);
           focusInput();
           return;
         }
 
+        // Session creation can disable the composer while a recording is
+        // transcribing. Keep the durable transcript for explicit insertion
+        // later; never append text after Send captured its visible snapshot.
+        if (disabledRef.current) {
+          setStatus("transcript-ready");
+          return;
+        }
+
         const next = appendFinalTranscript(valueRef.current, response.text);
         if (next !== valueRef.current) {
           valueRef.current = next;
@@ -814,6 +860,15 @@ export function useVoiceInput({
               await preserveForRetry(retained, attemptCaptureLimitError, generation);
               return;
             }
+            if (holdOnStopRef.current) {
+              holdOnStopRef.current = false;
+              const retained = await updateManifestBestEffort(stopped, {
+                recoveryMode: "manual",
+                handoffMode: "explicit",
+              });
+              await preserveForRetry(retained, null, generation);
+              return;
+            }
             await finalizePersistedRecording(generation);
           });
       };
@@ -822,6 +877,8 @@ export function useVoiceInput({
         resolveCaptureSettledRef.current = resolve;
       });
       attemptRecordingStartedAt = readNow().getTime();
+      recordingStartedAtRef.current = attemptRecordingStartedAt;
+      holdOnStopRef.current = false;
       recorder.start(VOICE_RECORDING_TIMESLICE_MILLISECONDS);
       recorderStarted = true;
       setStatus("recording");
@@ -944,6 +1001,7 @@ export function useVoiceInput({
   const insertSavedTranscript = useCallback(async (): Promise<void> => {
     const manifest = manifestRef.current;
     if (
+      disabledRef.current ||
       !manifest ||
       manifest.workspaceId !== workspaceId ||
       manifest.finalizationState !== "transcript-ready" ||
@@ -955,7 +1013,7 @@ export function useVoiceInput({
     controllerRef.current?.abort();
     controllerRef.current = null;
     const store = await ensureStore();
-    if (generation !== generationRef.current) return;
+    if (generation !== generationRef.current || disabledRef.current) return;
     const next = appendFinalTranscript(valueRef.current, manifest.transcriptText);
     if (next !== valueRef.current) {
       valueRef.current = next;
@@ -1058,7 +1116,27 @@ export function useVoiceInput({
   ]);
 
   const cancel = useCallback(() => {
-    if (status === "recording" || status === "requesting-permission") {
+    if (status === "recording") {
+      const recorder = recorderRef.current;
+      const elapsed = readNow().getTime() - recordingStartedAtRef.current;
+      if (
+        recorder &&
+        recorder.state !== "inactive" &&
+        elapsed >= VOICE_RECORDING_DISCARD_ON_CANCEL_MAX_MILLISECONDS
+      ) {
+        // Never delete real speech on Cancel/Escape: stop, keep it locally, and
+        // let the user transcribe or explicitly discard it.
+        if (timerRef.current) clearTimeout(timerRef.current);
+        timerRef.current = null;
+        holdOnStopRef.current = true;
+        setStatus("saving");
+        recorder.stop();
+        return;
+      }
+      void discard();
+      return;
+    }
+    if (status === "requesting-permission") {
       void discard();
       return;
     }
@@ -1082,7 +1160,7 @@ export function useVoiceInput({
         await preserveForRetry(retained, null, generation);
       });
     }
-  }, [discard, preserveForRetry, status, updateManifestBestEffort]);
+  }, [discard, preserveForRetry, readNow, status, updateManifestBestEffort]);
 
   useEffect(() => {
     const current = manifestRef.current;
@@ -1145,6 +1223,8 @@ export function useVoiceInput({
     const onKeyDown = (event: KeyboardEvent) => {
       if (
         event.key === "Escape" &&
+        // A dialog, menu, or popover that handled Escape owns it.
+        !event.defaultPrevented &&
         (status === "requesting-permission" ||
           status === "recording" ||
           status === "saving" ||
@@ -1168,6 +1248,19 @@ export function useVoiceInput({
       automaticRetryTimerRef.current = null;
       const manifest = manifestRef.current;
       const ownerReady = ownerIdPromiseRef.current;
+      const knownOwnerId = ownerIdRef.current;
+      const ownerLease = ownerLeaseRef.current;
+      const closingStore = storeRef.current;
+      const ownsClosingStore = ownsStoreRef.current;
+      // Detach synchronously: a remount of this instance (React StrictMode,
+      // keyed re-render) must open a fresh store and owner instead of reusing
+      // the connection this cleanup is about to close.
+      storeRef.current = null;
+      storePromiseRef.current = null;
+      ownerIdRef.current = null;
+      ownerIdPromiseRef.current = null;
+      ownerLeaseRef.current = null;
+      manifestRef.current = null;
       stopOwnerHeartbeat();
       const recorder = recorderRef.current;
       let captureSettled = persistenceQueueRef.current;
@@ -1179,9 +1272,8 @@ export function useVoiceInput({
       void captureSettled
         .catch(() => undefined)
         .then(async () => {
-          const ownerId =
-            ownerIdRef.current ?? (ownerReady ? await ownerReady.catch(() => null) : null);
-          const store = storeRef.current;
+          const ownerId = knownOwnerId ?? (ownerReady ? await ownerReady.catch(() => null) : null);
+          const store = closingStore;
           if (store && manifest && ownerId) {
             const wasProcessing =
               statusRef.current === "saving" ||
@@ -1210,12 +1302,11 @@ export function useVoiceInput({
               )
               .catch(() => undefined);
           }
-          if (ownsStoreRef.current) await store?.close();
+          if (ownsClosingStore) await store?.close();
         })
         .catch(() => undefined)
         .finally(() => {
-          ownerLeaseRef.current?.release();
-          ownerLeaseRef.current = null;
+          ownerLease?.release();
         });
     },
     [clearCaptureRuntime, readNow, stopOwnerHeartbeat],
@@ -1228,6 +1319,17 @@ export function useVoiceInput({
     stream,
     recordingId,
     durationSeconds,
+    recordingStartedAt: status === "recording" ? recordingStartedAtRef.current || null : null,
+    maxRecordingSeconds: capability
+      ? Math.min(
+          capability.resumable && isResumableVoiceInputClient(client)
+            ? capability.resumable.maxDurationSeconds
+            : capability.maxDurationSeconds,
+          capability.resumable && isResumableVoiceInputClient(client)
+            ? VOICE_RECORDING_RESUMABLE_CLIENT_MAX_DURATION_SECONDS
+            : VOICE_RECORDING_CLIENT_MAX_DURATION_SECONDS,
+        )
+      : null,
     locallySaved,
     hasRecoverableRecording: manifestRef.current !== null && status !== "recording",
     savedTranscript:
@@ -1492,6 +1594,12 @@ function errorCode(error: unknown): string {
 }
 
 function isRetryableVoiceInputError(error: unknown): boolean {
+  if (
+    ["insufficient_credits", "allowance_exhausted", "monthly_model_cost_limit"].includes(
+      errorCode(error),
+    )
+  )
+    return false;
   if (error instanceof OpenGeniApiError) {
     return error.retryable && error.status !== 409;
   }

package/src/hooks/use-workspace-capture.ts

@@ -194,8 +194,9 @@ export function useWorkspaceCapture(
           return;
         }
         setDegradedReason(null);
-        // Resolve the changed-file count immediately from the response's stats — the
-        // default-tab signal must not wait on a >2MB manifest-URL hop.
+        // Expose metadata while a large signed manifest downloads. Consumers
+        // must distinguish this pending count from a resolved capture; zero
+        // working-tree files can still have committed-only branch changes.
         setFileCount(res.stats.fileCount);
         // Exactly one of manifest / manifestUrl is non-null (M2 contract). The inline
         // manifest is the <200ms common case; a >2MB manifest is a signed URL hop.

package/src/hooks/use-workspace-edit.ts

@@ -1,4 +1,5 @@
-import { useCallback, useEffect, useRef, useState } from "react";
+import type { FileSystemRouteIdentity } from "@opengeni/sdk";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { useOpenGeni, type ClientOverride } from "../provider";
 import { sandboxAcceptsLiveIo } from "../lib/sandbox-liveness";
 
@@ -39,6 +40,9 @@ export type UseWorkspaceEditOptions = ClientOverride & {
   path?: string | null | undefined;
   /** The capture-served content loaded into the editor — the flush base (C2). */
   baseContent?: string | null | undefined;
+  /** Exact capability identity for the selected filesystem route. A route/root
+   * change discards the buffered edit and makes stale flushes fail retryably. */
+  route?: FileSystemRouteIdentity | undefined;
   /** `capabilities.liveness` — "warm" | "draining" | "cold". Drives the flush. */
   liveness?: string | undefined;
   /** True while the host is actively warming the box (attach in flight, not warm
@@ -95,9 +99,18 @@ export function useWorkspaceEdit(
   const { client, workspaceId } = useOpenGeni(options);
   const path = options.path ?? null;
   const baseContent = options.baseContent ?? null;
+  const routeEpoch = options.route?.epoch;
+  const routeRoot = options.route?.root;
+  const route = useMemo<FileSystemRouteIdentity | undefined>(
+    () =>
+      routeEpoch !== undefined && routeRoot !== undefined
+        ? { epoch: routeEpoch, root: routeRoot }
+        : undefined,
+    [routeEpoch, routeRoot],
+  );
   const live = isLive(options.liveness);
   const offline = options.offline === true;
-  const identityKey = `${workspaceId}\u0000${sessionId ?? ""}\u0000${path ?? ""}`;
+  const identityKey = `${workspaceId}\u0000${sessionId ?? ""}\u0000${path ?? ""}\u0000${routeEpoch ?? ""}\u0000${routeRoot ?? ""}`;
 
   const [buffer, setBuffer] = useState<string | null>(null);
   const [wantsWarm, setWantsWarm] = useState(false);
@@ -178,7 +191,7 @@ export function useWorkspaceEdit(
           const liveRead = await client.fsRead(
             workspaceId,
             sessionId,
-            { path },
+            { path, ...(route ? { route } : {}) },
             { signal: readAbort.signal },
           );
           if (readAbortRef.current === readAbort) readAbortRef.current = null;
@@ -190,7 +203,12 @@ export function useWorkspaceEdit(
             return;
           }
         }
-        await client.fsWrite(workspaceId, sessionId, { path, content, overwrite: true });
+        await client.fsWrite(workspaceId, sessionId, {
+          path,
+          content,
+          overwrite: true,
+          ...(route ? { route } : {}),
+        });
         if (identityGenerationRef.current !== identityGeneration) return;
         setConflict(null);
         setFlush("flushed");
@@ -207,7 +225,7 @@ export function useWorkspaceEdit(
         }
       }
     },
-    [client, workspaceId, sessionId, path, baseContent, stateIdentity, identityKey],
+    [client, workspaceId, sessionId, path, baseContent, route, stateIdentity, identityKey],
   );
 
   // Auto-flush once the box is warm and a buffer is pending (the wake completed).

package/src/hooks/use-workspace-sessions.ts

@@ -1,16 +1,26 @@
-import type { Session } from "@opengeni/sdk";
+import type { Session, SessionListEntry, SessionListTotals } from "@opengeni/sdk";
 import { useCallback, useEffect, useRef } from "react";
 import { useOpenGeni, type ClientOverride } from "../provider";
 import { usePolledValue } from "./internal";
 
 export type UseWorkspaceSessionsOptions = ClientOverride & {
+  includeTotals?: boolean | undefined;
+  needsYouOnly?: boolean | undefined;
+  /** Only read-only sessions moved to the idle-session archive. */
+  contentArchivedOnly?: boolean | undefined;
+  /** Compact list records; detail reads remain full sessions. */
+  projection?: "summary" | undefined;
   limit?: number | undefined;
   parentSessionId?: string | null | undefined;
   cursor?: string | undefined;
   search?: string | undefined;
   /** Return only the complete personal pinned projection. */
   pinsOnly?: boolean | undefined;
+  /** Skip pinned details when the pinned section is loaded separately. */
+  includePinned?: boolean | undefined;
   archivedOnly?: boolean | undefined;
+  sortBy?: "updatedAt" | "createdAt" | "name" | undefined;
+  archiveStatus?: "active" | "archived" | "all" | undefined;
   /** Refresh interval (ms) for fleet/manager views. Off by default. */
   pollIntervalMs?: number | undefined;
   enabled?: boolean | undefined;
@@ -18,16 +28,17 @@ export type UseWorkspaceSessionsOptions = ClientOverride & {
   beginRead?: (() => number) | undefined;
 };
 
-export type UseWorkspaceSessionsResult = {
+export type UseWorkspaceSessionsResult<T extends Session | SessionListEntry = Session> = {
   /**
    * All visible rows, with pins first. This preserves the pre-pinning hook
    * contract for consumers that only read `sessions`.
    */
-  sessions: Session[];
+  sessions: T[];
   /** The complete personal pinned section, also present in `sessions`. */
-  pinned: Session[];
+  pinned: T[];
   /** True when the server omitted older pins from its bounded pinned section. */
   pinnedTruncated: boolean;
+  totals: SessionListTotals | null;
   nextCursor: string | null;
   loading: boolean;
   error: Error | null;
@@ -39,62 +50,115 @@ export type UseWorkspaceSessionsResult = {
 };
 
 /** List the workspace's sessions — the data behind fleet and manager views. */
+export function useWorkspaceSessions(
+  options: UseWorkspaceSessionsOptions & { projection: "summary" },
+): UseWorkspaceSessionsResult<SessionListEntry>;
+export function useWorkspaceSessions(
+  options?: UseWorkspaceSessionsOptions & { projection?: undefined },
+): UseWorkspaceSessionsResult;
+export function useWorkspaceSessions(
+  options: UseWorkspaceSessionsOptions,
+): UseWorkspaceSessionsResult<Session | SessionListEntry>;
 export function useWorkspaceSessions(
   options: UseWorkspaceSessionsOptions = {},
-): UseWorkspaceSessionsResult {
+): UseWorkspaceSessionsResult<Session | SessionListEntry> {
   const { client, workspaceId } = useOpenGeni(options);
+  const projection = options.projection;
+  const includeTotals = options.includeTotals;
+  const needsYouOnly = options.needsYouOnly;
+  const contentArchivedOnly = options.contentArchivedOnly;
   const limit = options.limit;
   const parentSessionId = options.parentSessionId;
   const cursor = options.cursor;
   const search = options.search;
   const pinsOnly = options.pinsOnly;
+  const includePinned = options.includePinned;
   const archivedOnly = options.archivedOnly;
+  const sortBy = options.sortBy;
+  const archiveStatus = options.archiveStatus;
   const enabled = options.enabled ?? true;
   const nextReadRevision = useRef(0);
   const nextReadGeneration = useRef(0);
   const beginRead = options.beginRead;
   const queryKey = [
     workspaceId,
+    projection ?? "full",
+    includeTotals ? "totals" : "",
+    needsYouOnly ? "needs-you" : "",
+    contentArchivedOnly ? "read-only" : "",
     limit ?? "",
     parentSessionId === null ? "null" : (parentSessionId ?? ""),
     cursor ?? "",
     search ?? "",
     pinsOnly ? "1" : "",
+    includePinned === false ? "no-pins" : "",
     archivedOnly ? "archived" : "active",
+    sortBy ?? "",
+    archiveStatus ?? "",
   ].join("\u0000");
   const previousQueryKey = useRef(queryKey);
   const queryKeyTransition = previousQueryKey.current !== queryKey;
   useEffect(() => {
     previousQueryKey.current = queryKey;
   }, [queryKey]);
-  const load = useCallback(async () => {
-    const readGeneration = beginRead?.() ?? ++nextReadGeneration.current;
-    const page = await client.listSessionPage(workspaceId, {
-      ...(limit !== undefined ? { limit } : {}),
-      ...(parentSessionId !== undefined ? { parentSessionId } : {}),
-      ...(cursor !== undefined ? { cursor } : {}),
-      ...(search !== undefined ? { search } : {}),
-      ...(pinsOnly ? { pinsOnly: true } : {}),
-      ...(archivedOnly ? { archivedOnly: true } : {}),
-    });
-    return {
+  const load = useCallback(
+    async (signal?: AbortSignal) => {
+      const readGeneration = beginRead?.() ?? ++nextReadGeneration.current;
+      const query = {
+        ...(includeTotals ? { includeTotals: true } : {}),
+        ...(needsYouOnly ? { needsYouOnly: true } : {}),
+        ...(contentArchivedOnly ? { contentArchivedOnly: true } : {}),
+        ...(limit !== undefined ? { limit } : {}),
+        ...(parentSessionId !== undefined ? { parentSessionId } : {}),
+        ...(cursor !== undefined ? { cursor } : {}),
+        ...(search !== undefined ? { search } : {}),
+        ...(pinsOnly ? { pinsOnly: true } : {}),
+        ...(includePinned === false ? { includePinned: false } : {}),
+        ...(archivedOnly ? { archivedOnly: true } : {}),
+        ...(sortBy ? { sortBy } : {}),
+        ...(archiveStatus ? { archiveStatus } : {}),
+        signal,
+      };
+      const page =
+        projection === "summary"
+          ? client.listSessionSummaryPage
+            ? await client.listSessionSummaryPage(workspaceId, query)
+            : await client.listSessionPage(workspaceId, query).then(async (full) => {
+                const { sessionListEntry } = await import("@opengeni/sdk/session-list-entries");
+                return {
+                  ...full,
+                  pinned: full.pinned.map(sessionListEntry),
+                  sessions: full.sessions.map(sessionListEntry),
+                };
+              })
+          : await client.listSessionPage(workspaceId, query);
+      return {
+        queryKey,
+        page,
+        revision: ++nextReadRevision.current,
+        readGeneration,
+      };
+    },
+    [
+      beginRead,
+      client,
+      workspaceId,
+      projection,
+      includeTotals,
+      needsYouOnly,
+      contentArchivedOnly,
+      limit,
+      parentSessionId,
+      cursor,
+      search,
+      pinsOnly,
+      includePinned,
+      archivedOnly,
+      sortBy,
+      archiveStatus,
       queryKey,
-      page,
-      revision: ++nextReadRevision.current,
-      readGeneration,
-    };
-  }, [
-    beginRead,
-    client,
-    workspaceId,
-    limit,
-    parentSessionId,
-    cursor,
-    search,
-    pinsOnly,
-    archivedOnly,
-    queryKey,
-  ]);
+    ],
+  );
   const state = usePolledValue(load, {
     pollIntervalMs: options.pollIntervalMs,
     enabled,
@@ -112,6 +176,7 @@ export function useWorkspaceSessions(
     sessions: [...pinned, ...ordinary],
     pinned,
     pinnedTruncated: page?.pinnedTruncated ?? false,
+    totals: page?.totals ?? null,
     nextCursor: page?.nextCursor ?? null,
     // `usePolledValue` clears the old data and starts the new request in an
     // effect. During that query-key transition render, its old loading flag