@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/src/app/personal-github-reconnect.test.tsx

@@ -0,0 +1,356 @@
+// Bendik's own GitHub grant went stale (GitHub refused the token refresh).
+// The settings page said "Connected as @benyhh · 0 repos" and a passing
+// "Your GitHub account is unavailable" toast vanished before he could act.
+// When reconnecting is needed, the person gets one lasting Reconnect toast;
+// when nothing is needed, a background read stays quiet.
+import { afterEach, describe, expect, spyOn, test } from "bun:test";
+import { forwardRef } from "react";
+import * as Sonner from "sonner";
+import type { ClientConfig } from "@opengeni/sdk";
+import { OpenGeniApiError, type OpenGeniBrowserClient } from "@opengeni/sdk/browser";
+
+import { actRun, flush, registerDom, renderHook } from "../../test/render-hook";
+import {
+  createSlackLinkPrepareController,
+  PERSONAL_GITHUB_RECONNECT_TOAST_ID,
+  useAppState,
+  type AppStateHost,
+} from "./app-state";
+import { configurePageAppHost } from "./lib/app-host";
+import { browserPage, type NavigationHost } from "./lib/navigation";
+
+registerDom();
+
+const WORKSPACE_ID = "22222222-2222-4222-8222-222222222222";
+const ACCOUNT_ID = "33333333-3333-4333-8333-333333333333";
+
+const location = { pathname: "/", search: {}, searchStr: "", hash: "", state: {} };
+configurePageAppHost({
+  navigation: {
+    useNavigate: () => async () => {},
+    useLocation: () => location,
+    useRouterState: ({ select }: { select: (state: { location: typeof location }) => unknown }) =>
+      select({ location }),
+    useRouter: () => ({ state: { location } }),
+    useSearch: () => ({}),
+    Link: forwardRef<HTMLAnchorElement>((props, ref) => <a ref={ref} {...props} />),
+    stringifySearch: () => "",
+    page: browserPage,
+  } as unknown as NavigationHost,
+});
+
+function personalConnection(status: "active" | "needs_reauth" | "revoked", version: number) {
+  return {
+    id: "personal-1",
+    status,
+    version,
+    metadata: { githubLogin: "benyhh" },
+  };
+}
+
+/** The person's GitHub API, as the settings page and every chat read it. */
+function personalGitHubHost(api: {
+  statuses: ReturnType<typeof personalConnection>[];
+  repositories: () => unknown;
+  oauthStarts: number;
+  reconnectAccountIds?: Array<string | undefined>;
+  disconnects?: Array<{ connectionId: string; expectedVersion: number }>;
+  /** The live connection version; a disconnect naming another one is refused. */
+  liveVersion?: number;
+}) {
+  const client = new Proxy(
+    {
+      getAccessContext: async () => ({
+        mode: "managed",
+        subjectId: "user:1",
+        defaultWorkspaceId: WORKSPACE_ID,
+        defaultAccountId: ACCOUNT_ID,
+        accountGrants: [],
+        workspaceGrants: [
+          {
+            workspaceId: WORKSPACE_ID,
+            accountId: ACCOUNT_ID,
+            subjectId: "user:1",
+            permissions: ["connections:read", "connections:write", "workspace:read"],
+          },
+        ],
+      }),
+      listWorkspaces: async () => [{ id: WORKSPACE_ID, name: "Platform", settings: {} }],
+      personalGitHubStatus: async () => ({
+        enabled: true,
+        connection: api.statuses.length > 1 ? api.statuses.shift() : api.statuses[0],
+        reviewUrl: null,
+      }),
+      listPersonalGitHubRepositories: async () => api.repositories(),
+      beginConnect: async (_workspaceId: string, request: { reconnectAccountId?: string }) => {
+        api.oauthStarts += 1;
+        api.reconnectAccountIds?.push(request.reconnectAccountId);
+        return { nextAction: { type: "authorize", url: "https://github.com/login/oauth" } };
+      },
+      disconnectPersonalGitHub: async (
+        _workspaceId: string,
+        connectionId: string,
+        request: { expectedVersion: number },
+      ) => {
+        api.disconnects?.push({ connectionId, expectedVersion: request.expectedVersion });
+        if (api.liveVersion !== undefined && request.expectedVersion !== api.liveVersion) {
+          throw new OpenGeniApiError(409, "personal GitHub connection changed", {
+            correlationId: crypto.randomUUID(),
+          });
+        }
+        return {};
+      },
+    } as Record<string, unknown>,
+    { get: (target, key) => target[key as string] ?? (async () => ({})) },
+  ) as unknown as OpenGeniBrowserClient;
+  const noop = async () => {};
+  return {
+    authority: "host",
+    createOpenGeniClient: () => client,
+    fetchClientConfig: async () =>
+      ({
+        deploymentRevision: "rev-1",
+        defaultModel: "gpt-5.6-sol",
+        allowedModels: ["gpt-5.6-sol"],
+        models: [],
+        mcpServers: [],
+        auth: { mode: "none" },
+      }) as unknown as ClientConfig,
+    captureProductEvent: () => {},
+    fetchAuthSession: async () => null,
+    signInEmail: noop,
+    signUpEmail: noop,
+    signOutManaged: noop,
+    startManagedSocialSignIn: noop,
+    configureManagedActorEpoch: () => {},
+    getStoredAccessKey: () => null,
+    setStoredAccessKey: () => {},
+    clearStoredAccessKey: () => {},
+    slackLink: createSlackLinkPrepareController(null),
+    initialInvalidSlackLinkQueryWorkspaceId: null,
+  } as unknown as AppStateHost;
+}
+
+async function openWorkspace(host: AppStateHost) {
+  const rendered = await renderHook(
+    () => useAppState(host, { bootstrapSuspended: false }),
+    undefined,
+  );
+  for (let i = 0; i < 20 && !rendered.result.current.appContext; i++) await flush(10);
+  await actRun(() => rendered.result.current.appContext!.prepareWorkspaceTransition(WORKSPACE_ID));
+  await flush(10);
+  return rendered;
+}
+
+const reconnectRefused = () => {
+  throw new OpenGeniApiError(409, "Reconnect your GitHub account to keep working as you", {
+    correlationId: crypto.randomUUID(),
+  });
+};
+
+describe("a personal GitHub grant that needs reconnecting", () => {
+  afterEach(() => {
+    for (const method of ["error", "warning", "dismiss"] as const) {
+      (Sonner.toast[method] as unknown as { mockRestore?: () => void }).mockRestore?.();
+    }
+  });
+
+  test("GitHub refusing the grant shows one lasting Reconnect toast, not a passing error", async () => {
+    const toastError = spyOn(Sonner.toast, "error");
+    const toastWarning = spyOn(Sonner.toast, "warning");
+    // The status still said active when the repository read found the
+    // refused grant; reading it again shows needs_reauth.
+    const api = {
+      statuses: [personalConnection("active", 3), personalConnection("needs_reauth", 4)],
+      repositories: reconnectRefused,
+      oauthStarts: 0,
+      reconnectAccountIds: [] as Array<string | undefined>,
+    };
+    const rendered = await openWorkspace(personalGitHubHost(api));
+    try {
+      const refresh = () =>
+        actRun(() => rendered.result.current.appContext!.refreshPersonalGitHub(WORKSPACE_ID));
+      await refresh();
+      await flush(10);
+
+      const context = rendered.result.current.appContext!;
+      expect(context.personalGitHubStatus?.connection?.status).toBe("needs_reauth");
+      expect(context.personalGitHubSelection).toBeNull();
+      expect(toastError).not.toHaveBeenCalled();
+      expect(toastWarning).toHaveBeenCalledTimes(1);
+      const [title, data] = toastWarning.mock.calls[0]!;
+      expect(title).toBe("Reconnect your GitHub");
+      expect(data).toMatchObject({
+        id: PERSONAL_GITHUB_RECONNECT_TOAST_ID,
+        description: "Opengeni can't work as @benyhh until you reconnect.",
+        duration: Infinity,
+        closeButton: true,
+        action: { label: "Reconnect" },
+      });
+
+      // Its one action starts reconnecting this connection.
+      await actRun(async () => {
+        (data as unknown as { action: { onClick: () => void } }).action.onClick();
+        await flush(10);
+      });
+      expect(api.oauthStarts).toBe(1);
+      expect(api.reconnectAccountIds).toEqual(["personal-1"]);
+
+      // A later background read of the same stale grant does not bring a
+      // dismissed toast back.
+      await refresh();
+      await flush(10);
+      expect(toastWarning).toHaveBeenCalledTimes(1);
+    } finally {
+      await rendered.unmount();
+    }
+  });
+
+  test("a stale grant reported by the status read shows the Reconnect toast too", async () => {
+    const toastWarning = spyOn(Sonner.toast, "warning");
+    const api = {
+      statuses: [personalConnection("needs_reauth", 4)],
+      repositories: () => ({ repositories: [], nextCursor: null, selection: null }),
+      oauthStarts: 0,
+    };
+    const rendered = await openWorkspace(personalGitHubHost(api));
+    try {
+      await actRun(() => rendered.result.current.appContext!.refreshPersonalGitHub(WORKSPACE_ID));
+      await flush(10);
+      expect(toastWarning).toHaveBeenCalledTimes(1);
+      expect(toastWarning.mock.calls[0]![0]).toBe("Reconnect your GitHub");
+    } finally {
+      await rendered.unmount();
+    }
+  });
+
+  test("reconnecting clears the toast", async () => {
+    const toastWarning = spyOn(Sonner.toast, "warning");
+    const toastDismiss = spyOn(Sonner.toast, "dismiss");
+    const selection = {
+      connectionAuthorityGeneration: 5,
+      credentialBindingId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
+      providerPrincipalId: "59779138",
+      selectionGeneration: 1,
+      repositories: [],
+    };
+    const api = {
+      statuses: [personalConnection("needs_reauth", 4), personalConnection("active", 5)],
+      repositories: () => ({ repositories: [], nextCursor: null, selection }),
+      oauthStarts: 0,
+    };
+    const rendered = await openWorkspace(personalGitHubHost(api));
+    try {
+      const refresh = () =>
+        actRun(() => rendered.result.current.appContext!.refreshPersonalGitHub(WORKSPACE_ID));
+      await refresh();
+      await flush(10);
+      expect(toastWarning).toHaveBeenCalledTimes(1);
+      await refresh();
+      await flush(10);
+      expect(toastDismiss).toHaveBeenCalledWith(PERSONAL_GITHUB_RECONNECT_TOAST_ID);
+      expect(rendered.result.current.appContext!.personalGitHubSelection).toEqual(selection);
+    } finally {
+      await rendered.unmount();
+    }
+  });
+
+  test("disconnecting instead of reconnecting clears the toast", async () => {
+    const toastWarning = spyOn(Sonner.toast, "warning");
+    const toastDismiss = spyOn(Sonner.toast, "dismiss");
+    const api = {
+      statuses: [personalConnection("needs_reauth", 4), personalConnection("revoked", 5)],
+      repositories: () => ({ repositories: [], nextCursor: null, selection: null }),
+      oauthStarts: 0,
+    };
+    const rendered = await openWorkspace(personalGitHubHost(api));
+    try {
+      const refresh = () =>
+        actRun(() => rendered.result.current.appContext!.refreshPersonalGitHub(WORKSPACE_ID));
+      await refresh();
+      await flush(10);
+      expect(toastWarning).toHaveBeenCalledTimes(1);
+      await refresh();
+      await flush(10);
+      expect(toastDismiss).toHaveBeenCalledWith(PERSONAL_GITHUB_RECONNECT_TOAST_ID);
+    } finally {
+      await rendered.unmount();
+    }
+  });
+
+  test("a background read that needs nothing from the person shows no toast", async () => {
+    const toastError = spyOn(Sonner.toast, "error");
+    const toastWarning = spyOn(Sonner.toast, "warning");
+    const api = {
+      statuses: [personalConnection("active", 3)],
+      repositories: () => {
+        throw new OpenGeniApiError(
+          409,
+          "personal GitHub connection changed; refresh and try again",
+          { correlationId: crypto.randomUUID() },
+        );
+      },
+      oauthStarts: 0,
+    };
+    const rendered = await openWorkspace(personalGitHubHost(api));
+    try {
+      await actRun(() => rendered.result.current.appContext!.refreshPersonalGitHub(WORKSPACE_ID));
+      await flush(10);
+      expect(toastError).not.toHaveBeenCalled();
+      expect(toastWarning).not.toHaveBeenCalled();
+    } finally {
+      await rendered.unmount();
+    }
+  });
+});
+
+// Bendik reconnected and then pressed Disconnect in the dialog that was still
+// open: the page held the connection version from before the reconnect
+// finished, and Disconnect failed with "changed; refresh before
+// disconnecting". Removing your own GitHub must always work.
+describe("disconnecting your GitHub", () => {
+  afterEach(() => {
+    for (const method of ["error", "success"] as const) {
+      (Sonner.toast[method] as unknown as { mockRestore?: () => void }).mockRestore?.();
+    }
+  });
+
+  test("a connection that changed while the page held it is still disconnected", async () => {
+    const toastError = spyOn(Sonner.toast, "error");
+    const toastSuccess = spyOn(Sonner.toast, "success");
+    const api = {
+      statuses: [personalConnection("needs_reauth", 4)],
+      repositories: () => ({ repositories: [], nextCursor: null, selection: null }),
+      oauthStarts: 0,
+      disconnects: [] as Array<{ connectionId: string; expectedVersion: number }>,
+      liveVersion: 4,
+    };
+    const rendered = await openWorkspace(personalGitHubHost(api));
+    try {
+      await actRun(() => rendered.result.current.appContext!.refreshPersonalGitHub(WORKSPACE_ID));
+      await flush(10);
+      expect(rendered.result.current.appContext!.personalGitHubStatus?.connection?.version).toBe(4);
+
+      // A reconnect finishes elsewhere: the live connection is now version 5.
+      api.statuses.splice(0, api.statuses.length, personalConnection("active", 5));
+      api.liveVersion = 5;
+
+      let disconnected = false;
+      await actRun(async () => {
+        disconnected =
+          await rendered.result.current.appContext!.disconnectPersonalGitHub(WORKSPACE_ID);
+      });
+      await flush(10);
+
+      expect(disconnected).toBe(true);
+      expect(api.disconnects).toEqual([
+        { connectionId: "personal-1", expectedVersion: 4 },
+        { connectionId: "personal-1", expectedVersion: 5 },
+      ]);
+      expect(toastError).not.toHaveBeenCalled();
+      expect(toastSuccess).toHaveBeenCalledWith("Your GitHub account was disconnected");
+    } finally {
+      await rendered.unmount();
+    }
+  });
+});

package/src/app/routes/artifacts.tsx

@@ -66,7 +66,6 @@ import {
 } from "../lib/artifact-library-navigation";
 import type { ArtifactCatalogFilters } from "../lib/artifact-catalog";
 import type { ArtifactReturnSearch, SiteDetailTab } from "../lib/routes";
-import { errorMessage } from "@opengeni/contracts/values";
 
 // The Site view opens the same publish form through this route's code,
 // loaded when needed, so the form stays with the Site's Settings tab.
@@ -566,7 +565,7 @@ function ArtifactDetailPage({
       await load();
     } catch (nextError) {
       toast.error("Couldn't restore version", {
-        description: errorMessage(nextError),
+        description: userErrorText(nextError),
       });
     } finally {
       setBusyVersion(null);

package/src/components/tool-action-review.tsx

@@ -82,6 +82,10 @@ const toneText: Record<Tone, string> = {
 };
 /** Shown when an older request's saved values are gone: approval is impossible, decline is not. */
 export const UNRECOVERABLE_TEXT = (t: OpenGeniText) => t("toolActionReview.theDetailsOfThisOlder");
+const ACCOUNT_OWNER_TEXT = (t: OpenGeniText, name: string | undefined) =>
+  name
+    ? t("toolActionReview.onlyNameCanApprove", { name })
+    : t("toolActionReview.onlyTheAccountOwnerCanApprove");
 
 function StatusIcon({ status, busy }: { status: ToolReviewStatus; busy?: boolean }) {
   const className = "size-4";
@@ -459,7 +463,16 @@ export function ToolActionReviewCard({
       }
     >
       {actionable && !canApprove ? (
-        <p className="m-0 mb-3 text-og-sm leading-relaxed text-og-fg">{UNRECOVERABLE_TEXT(t)}</p>
+        <p className="m-0 mb-3 text-og-sm leading-relaxed text-og-fg">
+          {review.approvedBy === "account_owner"
+            ? ACCOUNT_OWNER_TEXT(t, review.accountOwnerLabel)
+            : UNRECOVERABLE_TEXT(t)}
+        </p>
+      ) : null}
+      {actionable && canApprove && review.approvedBy === "you" ? (
+        <p className="m-0 mb-3 text-og-sm leading-relaxed text-og-fg">
+          {t("toolActionReview.onlyYouCanApprove")}
+        </p>
       ) : null}
       <ReviewFacts
         review={review}

package/src/meetings/delete-meeting-dialog.tsx

@@ -1,6 +1,7 @@
 import type { ComponentProps } from "react";
 import { useOpenGeniText } from "../messages/runtime";
 import { toast } from "sonner";
+import { userErrorText } from "../ui/api-error";
 import type { Recording } from "@opengeni/contracts";
 
 import { ConfirmDialog } from "../ui/confirm-dialog";
@@ -38,7 +39,7 @@ function DeleteMeetingDialogContent({
           await onDelete(recording.id);
         } catch (error) {
           toast.error(msg("meetings.deleteDialog.couldnTDeleteThisMeeting"), {
-            description: error instanceof Error ? error.message : undefined,
+            description: error instanceof Error ? userErrorText(error) : undefined,
           });
           return false;
         }

package/src/meetings/meeting-ask.tsx

@@ -7,6 +7,7 @@ import { useOpenGeniText } from "../messages/runtime";
 import { useEffect, useId, useRef, useState } from "react";
 import { ArrowUpIcon, LoaderCircleIcon } from "lucide-react";
 import { toast } from "sonner";
+import { userErrorText } from "../ui/api-error";
 
 import { Button } from "../ui/button";
 import { TextInput } from "../ui/field";
@@ -48,7 +49,7 @@ export function MeetingAsk({
       if ((await onAsk(text)) !== false) setQuestion("");
     } catch (error) {
       toast.error(msg("meetings.ask.couldNotAsk"), {
-        description: error instanceof Error ? error.message : undefined,
+        description: error instanceof Error ? userErrorText(error) : undefined,
       });
     } finally {
       setAsking(false);

package/src/meetings/meeting-detail-page.tsx

@@ -30,6 +30,7 @@ import {
   Trash2Icon,
 } from "lucide-react";
 import { toast } from "sonner";
+import { userErrorText } from "../ui/api-error";
 import type {
   Recording,
   RecordingNote,
@@ -130,7 +131,7 @@ import { StickyBarEdge, useStuckToTop } from "./sticky-bar-edge";
 const defaultText = createOpenGeniText();
 
 function errorText(error: unknown): string | undefined {
-  return error instanceof Error ? error.message : undefined;
+  return error instanceof Error ? userErrorText(error) : undefined;
 }
 
 function isNotFound(error: Error | null): boolean {

package/src/meetings/meeting-notes.tsx

@@ -12,6 +12,7 @@ import { useOpenGeniText } from "../messages/runtime";
 import { useEffect, useId, useMemo, useRef, useState, type ComponentProps } from "react";
 import { BotIcon, CheckIcon, CopyIcon, LoaderCircleIcon, PencilIcon } from "lucide-react";
 import { toast } from "sonner";
+import { userErrorText } from "../ui/api-error";
 import type { RecordingNote } from "@opengeni/contracts";
 import { OpenGeniApiError } from "@opengeni/sdk";
 import { Markdown } from "../components/markdown";
@@ -47,7 +48,7 @@ function isNotesChanged(error: unknown): boolean {
 }
 
 function errorText(error: unknown): string | undefined {
-  return error instanceof Error ? error.message : undefined;
+  return error instanceof Error ? userErrorText(error) : undefined;
 }
 
 function MeetingNotesContent({

package/src/meetings/meeting-settings.tsx

@@ -6,6 +6,7 @@ import { useOpenGeniText, createOpenGeniText, type OpenGeniText } from "../messa
 import { regionRestrictedText } from "../inference-region";
 import { useState, type ComponentProps } from "react";
 import { toast } from "sonner";
+import { userErrorText } from "../ui/api-error";
 
 import {
   type RecordingPerson,
@@ -652,7 +653,9 @@ function VoiceRows({
       await work();
       toast.success(success);
     } catch (error) {
-      toast.error(failure, { description: error instanceof Error ? error.message : undefined });
+      toast.error(failure, {
+        description: error instanceof Error ? userErrorText(error) : undefined,
+      });
     } finally {
       setBusy(false);
     }

package/src/meetings/meeting-transcript.tsx

@@ -28,6 +28,7 @@ import {
   XIcon,
 } from "lucide-react";
 import { toast } from "sonner";
+import { userErrorText } from "../ui/api-error";
 import type {
   RecordingPerson,
   RecordingSpeaker,
@@ -178,7 +179,9 @@ async function withToast(failure: string, work: () => Promise<void>): Promise<bo
     await work();
     return true;
   } catch (error) {
-    toast.error(failure, { description: error instanceof Error ? error.message : undefined });
+    toast.error(failure, {
+      description: error instanceof Error ? userErrorText(error) : undefined,
+    });
     return false;
   }
 }

package/src/meetings/recorder-context.tsx

@@ -290,6 +290,16 @@ function useDesktopMeetingRequests(
       }
       const recordingId = recorder?.recordingId ?? null;
       const recordingWorkspaceId = store.workspaceId?.() ?? null;
+      if (request.kind === "open") {
+        // The app's menu: show the meeting this page records, its live transcript.
+        const opened =
+          recordingId && recordingWorkspaceId && capturing(recorder?.state)
+            ? store.openMeeting?.(recordingId, recordingWorkspaceId)
+            : false;
+        if (!opened) latest.current.onOpenMeetings?.();
+        return;
+      }
+      if (request.kind !== "stop") return;
       if (!recorder || (recorder.state !== "recording" && recorder.state !== "paused")) return;
       void recorder.stop().then(() => {
         if (recordingId && recordingWorkspaceId) {

package/src/meetings/recorder-host.test.tsx

@@ -18,10 +18,20 @@ afterAll(() => {
   GlobalRegistrator.unregister();
 });
 
+/** What the fake recorder says, for the test that sets it; idle otherwise. */
+let recorderNow: { state: string; title?: string | null; elapsedMilliseconds?: number } = {
+  state: "idle",
+};
+
 mock.module("../recordings", () => ({
-  useRecorder: ({ workspaceId }: { workspaceId: string }) =>
+  useRecorder: ({ workspaceId }: { workspaceId: string }) => {
+    const now = recorderNow;
     // oxlint-disable-next-line react-hooks/rules-of-hooks -- the fake is a hook
-    useMemo(() => ({ state: "idle", recordingId: null, workspaceId }), [workspaceId]),
+    return useMemo(
+      () => ({ recordingId: null, elapsedMilliseconds: 0, ...now, workspaceId }),
+      [workspaceId, now],
+    );
+  },
 }));
 
 const { default: RecorderHost } = await import("./recorder-host");
@@ -58,4 +68,52 @@ describe("The recorder host", () => {
       container.remove();
     }
   });
+
+  test("tells the desktop app what it records, again when the title or a pause changes", async () => {
+    const calls: unknown[][] = [];
+    (globalThis as Record<string, unknown>).opengeniDesktop = {
+      version: 1,
+      capabilities: ["meetingDetection"],
+      meetingDetection: {
+        status: async () => ({}),
+        update: async () => ({}),
+        setRecording: (...args: unknown[]) => void calls.push(args),
+        onRequest: () => () => {},
+        onChange: () => () => {},
+      },
+    };
+    const store = createMeetingRecorderStore(() => {});
+    const container = document.createElement("div");
+    document.body.append(container);
+    const root = createRoot(container);
+    const render = (next: typeof recorderNow) =>
+      act(async () => {
+        recorderNow = next;
+        root.render(<RecorderHost store={store} workspaceId="workspace-a" />);
+      });
+    try {
+      await render({ state: "idle" });
+      expect(calls).toEqual([[false]]);
+      await render({ state: "recording", title: null, elapsedMilliseconds: 1_000 });
+      await render({ state: "recording", title: "Planning", elapsedMilliseconds: 5_000 });
+      await render({ state: "paused", title: "Planning", elapsedMilliseconds: 9_000 });
+      // Only a change it shows is sent: the time moves on in the app.
+      await render({ state: "paused", title: "Planning", elapsedMilliseconds: 9_500 });
+      await render({ state: "stopped", title: "Planning", elapsedMilliseconds: 9_500 });
+      // Never a stop between: the app would think the recording ended.
+      expect(calls).toEqual([
+        [false],
+        [true, { title: null, elapsedMilliseconds: 1_000, paused: false }],
+        [true, { title: "Planning", elapsedMilliseconds: 5_000, paused: false }],
+        [true, { title: "Planning", elapsedMilliseconds: 9_000, paused: true }],
+        [false],
+        [false],
+      ]);
+    } finally {
+      await act(async () => root.unmount());
+      container.remove();
+      recorderNow = { state: "idle" };
+      delete (globalThis as Record<string, unknown>).opengeniDesktop;
+    }
+  });
 });

package/src/meetings/recorder-host.tsx

@@ -49,12 +49,25 @@ export default function RecorderHost({
   }, [capturing]);
 
   // The desktop app doesn't offer to record a call while this page records
-  // one, and offers to stop when the recorded call ends.
+  // one, and offers to stop when the recorded call ends. Its menu bar shows
+  // the meeting, so it hears again when the title or a pause changes.
+  const recordedRef = useRef(recorder.elapsedMilliseconds);
+  recordedRef.current = recorder.elapsedMilliseconds;
+  const title = recorder.title ?? null;
+  const paused = recorder.state === "paused";
   useEffect(() => {
     const detection = getDesktopMeetingDetection();
-    if (!detection) return;
-    detection.setRecording(capturing);
+    if (!detection || !capturing) return;
     return () => detection.setRecording(false);
   }, [capturing]);
+  useEffect(() => {
+    const detection = getDesktopMeetingDetection();
+    if (!detection) return;
+    if (capturing) {
+      detection.setRecording(true, { title, elapsedMilliseconds: recordedRef.current, paused });
+    } else {
+      detection.setRecording(false);
+    }
+  }, [capturing, title, paused]);
   return null;
 }

package/src/meetings/recorder-panel.tsx

@@ -28,6 +28,7 @@ import {
   SquareIcon,
 } from "lucide-react";
 import { toast } from "sonner";
+import { userErrorText } from "../ui/api-error";
 
 import { Button } from "../ui/button";
 import {
@@ -349,7 +350,7 @@ function RecordingTitle({ recorder }: { recorder: MeetingRecorder }) {
         setEditing(false);
       } catch (error) {
         toast.error(msg("meetings.recorderPanel.couldnTRenameThisMeeting"), {
-          description: error instanceof Error ? error.message : undefined,
+          description: error instanceof Error ? userErrorText(error) : undefined,
         });
       } finally {
         setSaving(false);