@opengeni/react 1.0.1 → 1.0.2-canary.37191796234001

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

@@ -163,6 +163,7 @@ export function useVoiceInput({
   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 +177,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> => {
@@ -468,6 +470,14 @@ export function useVoiceInput({
           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;
@@ -944,6 +954,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 +966,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;

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,54 +1,96 @@
-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;
+  /** 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;
+  /** Optional shared causal clock invoked when each network read starts. */
+  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;
+  /** Monotonic revision of accepted authoritative list-page reads. */
+  readRevision: number;
+  /** Causal generation captured when the accepted network read started. */
+  readGeneration: number;
   refresh: () => Promise<void>;
 };
 
 /** 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 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" : "",
     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;
@@ -56,17 +98,60 @@ export function useWorkspaceSessions(
     previousQueryKey.current = queryKey;
   }, [queryKey]);
   const load = useCallback(
-    async () => ({
-      queryKey,
-      page: await client.listSessionPage(workspaceId, {
+    async (signal?: AbortSignal) => {
+      const readGeneration = beginRead?.() ?? ++nextReadGeneration.current;
+      const query = {
+        ...(includeTotals ? { includeTotals: true } : {}),
+        ...(needsYouOnly ? { needsYouOnly: true } : {}),
         ...(limit !== undefined ? { limit } : {}),
         ...(parentSessionId !== undefined ? { parentSessionId } : {}),
         ...(cursor !== undefined ? { cursor } : {}),
         ...(search !== undefined ? { search } : {}),
         ...(pinsOnly ? { pinsOnly: true } : {}),
-      }),
-    }),
-    [client, workspaceId, limit, parentSessionId, cursor, search, pinsOnly, queryKey],
+        ...(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,
+      limit,
+      parentSessionId,
+      cursor,
+      search,
+      pinsOnly,
+      includePinned,
+      archivedOnly,
+      sortBy,
+      archiveStatus,
+      queryKey,
+    ],
   );
   const state = usePolledValue(load, {
     pollIntervalMs: options.pollIntervalMs,
@@ -85,6 +170,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
@@ -96,6 +182,8 @@ export function useWorkspaceSessions(
         queryKeyTransition ||
         (state.data !== null && state.data.queryKey !== queryKey)),
     error: state.error,
+    readRevision: page ? (state.data?.revision ?? 0) : 0,
+    readGeneration: page ? (state.data?.readGeneration ?? 0) : 0,
     refresh: state.refresh,
   };
 }

package/src/human-input.ts

@@ -1,4 +1,4 @@
-import type { HumanInputQuestion, SessionEvent } from "@opengeni/sdk";
+import type { HumanInputQuestion, SessionEvent, SessionHumanInputRequest } from "@opengeni/sdk";
 
 /** Minimal actionable request shape available from the durable event log. */
 export type PendingHumanInputRequest = {
@@ -9,6 +9,17 @@ export type PendingHumanInputRequest = {
   expiresAt: string | null;
 };
 
+/** A pending row stops being actionable at its durable deadline, even before refresh. */
+export function isActionableHumanInputRequest(
+  request: Pick<SessionHumanInputRequest, "status" | "expiresAt">,
+  nowMs = Date.now(),
+): boolean {
+  if (request.status !== "pending") return false;
+  if (!request.expiresAt) return true;
+  const deadline = Date.parse(request.expiresAt);
+  return Number.isFinite(deadline) && deadline > nowMs;
+}
+
 /** Parse one generic `session.humanInput.requested` event defensively. */
 export function humanInputRequestFromEvent(
   event: Pick<SessionEvent, "type" | "payload" | "turnId">,

package/src/identity-link-accounts.tsx

@@ -0,0 +1,148 @@
+import { useEffect, useRef, useState } from "react";
+import type { ExternalIdentityLink, ExternalIdentityLinkPage } from "@opengeni/sdk";
+
+export type IdentityLinkAccountsClient = {
+  listIdentityLinks(workspaceId: string, cursor?: string): Promise<ExternalIdentityLinkPage>;
+  revokeIdentityLink(
+    workspaceId: string,
+    linkId: string,
+    expectedRevision: number,
+  ): Promise<ExternalIdentityLink>;
+};
+
+/** Participant-scoped inventory. Revocation never deletes native work or merges
+ * identities. The caller remounts this component when the signed-in user changes. */
+export function IdentityLinkAccounts({
+  client,
+  workspaceId,
+}: {
+  client: IdentityLinkAccountsClient;
+  workspaceId: string;
+}) {
+  const [links, setLinks] = useState<ExternalIdentityLink[]>([]);
+  const [cursor, setCursor] = useState<string | null>(null);
+  const [busy, setBusy] = useState(true);
+  const [error, setError] = useState(false);
+  const [revision, setRevision] = useState(0);
+  const generation = useRef(0);
+  const inFlight = useRef(false);
+  useEffect(() => {
+    const current = ++generation.current;
+    inFlight.current = true;
+    setLinks([]);
+    setCursor(null);
+    setBusy(true);
+    setError(false);
+    void client
+      .listIdentityLinks(workspaceId)
+      .then(
+        (page) => {
+          if (current !== generation.current) return;
+          setLinks(page.links);
+          setCursor(page.nextCursor);
+        },
+        () => {
+          if (current === generation.current) setError(true);
+        },
+      )
+      .finally(() => {
+        if (current === generation.current) {
+          inFlight.current = false;
+          setBusy(false);
+        }
+      });
+    return () => {
+      // Invalidate live async work, rather than cleaning up a captured DOM node.
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      generation.current++;
+    };
+  }, [client, workspaceId, revision]);
+
+  async function act(link?: ExternalIdentityLink) {
+    if (inFlight.current || (!link && !cursor)) return;
+    const current = generation.current;
+    inFlight.current = true;
+    setBusy(true);
+    setError(false);
+    try {
+      if (link) {
+        const updated = await client.revokeIdentityLink(workspaceId, link.id, link.revision);
+        if (current === generation.current)
+          setLinks((values) =>
+            values.map((value) => (value.id === updated.id ? { ...value, ...updated } : value)),
+          );
+      } else {
+        const page = await client.listIdentityLinks(workspaceId, cursor!);
+        if (current === generation.current) {
+          setLinks((values) => [
+            ...new Map([...values, ...page.links].map((value) => [value.id, value])).values(),
+          ]);
+          setCursor(page.nextCursor);
+        }
+      }
+    } catch {
+      if (current === generation.current) setError(true);
+    } finally {
+      if (current === generation.current) {
+        inFlight.current = false;
+        setBusy(false);
+      }
+    }
+  }
+  return (
+    <section
+      className="og-connect og-identity-link"
+      aria-label="Linked product access"
+      aria-busy={busy}
+    >
+      <h2>Linked product access</h2>
+      <p>
+        Manage products allowed to act as your account in this organization. Revoking a link stops
+        future linked access; it does not delete your work or undo an operation already started.
+      </p>
+      {/* The links sit in one card under the heading, like a settings section;
+          the empty and loading lines are rows of that card. */}
+      <div className="og-identity-link-card">
+        {error && (
+          <div role="alert">
+            Could not update account links. Reload to see current access.
+            <button type="button" disabled={busy} onClick={() => setRevision((value) => value + 1)}>
+              Reload links
+            </button>
+          </div>
+        )}
+        {busy && <p role="status">Loading account links…</p>}
+        {!busy && !error && links.length === 0 && (
+          <p>No products have linked access to this account.</p>
+        )}
+        <ul>
+          {links.map((link) => (
+            <li key={link.id}>
+              <p>
+                {link.externalIdentity?.source || "Product identity"}{" "}
+                <code>{link.externalIdentity?.externalId ?? link.externalIdentityId}</code>
+              </p>
+              <p>
+                Status: {link.status}.{" "}
+                {link.expiresAt
+                  ? `Expires ${new Date(link.expiresAt).toLocaleString()}.`
+                  : "No automatic expiry."}
+              </p>
+              <p>{link.permissions.join(", ")}</p>
+              {(link.status === "active" || link.status === "pending") && (
+                <button type="button" disabled={busy} onClick={() => void act(link)}>
+                  Revoke access
+                </button>
+              )}
+            </li>
+          ))}
+        </ul>
+        {cursor && (
+          <button type="button" disabled={busy} onClick={() => void act()}>
+            Load more links
+          </button>
+        )}
+      </div>
+    </section>
+  );
+}

package/src/identity-link-consent.tsx

@@ -0,0 +1,192 @@
+import { useEffect, useRef, useState } from "react";
+import type {
+  ExternalIdentityLink,
+  ConfirmExternalIdentityLinkRequest,
+  ExternalIdentityLinkPreview,
+} from "@opengeni/sdk";
+
+export type IdentityLinkClient = {
+  previewIdentityLink(
+    workspaceId: string,
+    linkId: string,
+    challenge: string,
+  ): Promise<ExternalIdentityLinkPreview>;
+  confirmIdentityLink(
+    workspaceId: string,
+    linkId: string,
+    input: ConfirmExternalIdentityLinkRequest,
+  ): Promise<ExternalIdentityLink>;
+  revokeIdentityLink(
+    workspaceId: string,
+    linkId: string,
+    expectedRevision: number,
+  ): Promise<ExternalIdentityLink>;
+};
+export type IdentityLinkConsentProps = {
+  client: IdentityLinkClient;
+  workspaceId: string;
+  linkId: string;
+  challenge: string;
+  /** Host label is explanatory, never proof of the requesting application. */
+  className?: string;
+  onComplete?: (link: ExternalIdentityLink) => void;
+};
+
+/** Optional native-login consent. Ordinary Connect does not use this surface.
+ * Permission choices only narrow the server's request; no automatic approval. */
+export function IdentityLinkConsent({
+  client,
+  workspaceId,
+  linkId,
+  challenge,
+  className,
+  onComplete,
+}: IdentityLinkConsentProps) {
+  const [link, setLink] = useState<ExternalIdentityLink | null>(null);
+  const [preview, setPreview] = useState<ExternalIdentityLinkPreview | null>(null);
+  const [selected, setSelected] = useState<ExternalIdentityLink["permissions"]>([]);
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState(false);
+  const [retry, setRetry] = useState(0);
+  const generation = useRef(0);
+  useEffect(() => {
+    const current = ++generation.current;
+    setLink(null);
+    setPreview(null);
+    setSelected([]);
+    setBusy(true);
+    setError(false);
+    void client
+      .previewIdentityLink(workspaceId, linkId, challenge)
+      .then(
+        (result) => {
+          if (generation.current !== current) return;
+          setPreview(result);
+          setLink(result.link);
+          setSelected(result.link.permissions);
+        },
+        () => {
+          if (generation.current === current) setError(true);
+        },
+      )
+      .finally(() => {
+        if (generation.current === current) setBusy(false);
+      });
+    return () => {
+      // Invalidate live async work, rather than cleaning up a captured DOM node.
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      generation.current++;
+    };
+  }, [client, workspaceId, linkId, challenge, retry]);
+  async function mutate(revoke: boolean) {
+    if (!link || busy) return;
+    const current = generation.current;
+    setBusy(true);
+    setError(false);
+    try {
+      const result = revoke
+        ? await client.revokeIdentityLink(workspaceId, linkId, link.revision)
+        : await client.confirmIdentityLink(workspaceId, linkId, {
+            challenge,
+            expectedRevision: link.revision,
+            permissions: selected,
+          });
+      if (generation.current !== current) return;
+      setLink(result);
+      onComplete?.(result);
+    } catch {
+      if (generation.current === current) setError(true);
+    } finally {
+      if (generation.current === current) setBusy(false);
+    }
+  }
+  return (
+    <section
+      className={["og-connect og-identity-link", className].filter(Boolean).join(" ")}
+      aria-label="Link your account"
+      aria-busy={busy}
+    >
+      <h2>Link your Opengeni account</h2>
+      <p>
+        Only continue if you started this request in a product you trust. Linking lets that product
+        act as your account with the permissions you select. It does not merge accounts or move
+        existing work.
+      </p>
+      {preview && (
+        <dl>
+          <dt>Organization</dt>
+          <dd>{preview.organizationId}</dd>
+          <dt>Product user</dt>
+          <dd>
+            {preview.externalIdentity.externalId} ({preview.externalIdentity.source})
+          </dd>
+          <dt>Your Opengeni identity</dt>
+          <dd>{preview.nativeSubjectId}</dd>
+        </dl>
+      )}
+      {error && (
+        <div role="alert">
+          This request could not be completed. It may have expired, changed, or require you to sign
+          in to the right organization.
+          {!link && (
+            <button type="button" disabled={busy} onClick={() => setRetry((value) => value + 1)}>
+              Try again
+            </button>
+          )}
+        </div>
+      )}
+      {!link && busy && <p role="status">Loading the account-link request…</p>}
+      {link?.status === "pending" && (
+        <>
+          <p>
+            {link.expiresAt
+              ? `Access ends ${new Date(link.expiresAt).toLocaleString()}.`
+              : "Access lasts until you or the product revoke this link."}{" "}
+            Your current permissions still apply.
+          </p>
+          <fieldset disabled={busy}>
+            <legend>Allow these permissions</legend>
+            {link.permissions.map((permission) => (
+              <label key={permission}>
+                <input
+                  type="checkbox"
+                  checked={selected.includes(permission)}
+                  onChange={(event) =>
+                    setSelected((values) =>
+                      event.target.checked
+                        ? [...values, permission]
+                        : values.filter((value) => value !== permission),
+                    )
+                  }
+                />
+                <span>{permission.replaceAll(":", " · ")}</span>
+              </label>
+            ))}
+          </fieldset>
+          <button
+            type="button"
+            disabled={busy || selected.length === 0}
+            onClick={() => void mutate(false)}
+          >
+            {busy ? "Saving…" : "Allow selected access"}
+          </button>
+          <p>You can close this page without granting access.</p>
+        </>
+      )}
+      {link?.status === "active" && (
+        <>
+          <p role="status">Account linked. Return to your product to continue.</p>
+          <button type="button" disabled={busy} onClick={() => void mutate(true)}>
+            Revoke this link
+          </button>
+        </>
+      )}
+      {link?.status === "revoked" && (
+        <p role="status">Link revoked. Your Opengeni account and existing work are unchanged.</p>
+      )}
+      {link?.status === "expired" && (
+        <p role="status">This request has expired. Start a new request from your product.</p>
+      )}
+    </section>
+  );
+}