@opengeni/react 6.7.0 → 6.8.0

package/src/app/routes/session.tsx

@@ -51,6 +51,11 @@ import {
   failureFallbackReason,
 } from "../lib/failed-session-copy";
 import { coveredModelChoice, creditRefusalGap, freeCreditGap } from "../lib/free-credit-gap";
+import {
+  pickerPolicyRunnable,
+  ComposerSendBlockerNotice,
+  composerSendBlockerNotice,
+} from "../lib/composer-send-blocking";
 import { ChatPaymentPages } from "../components/chat-payment-pages";
 import { creditRefusalRecord, type CreditRefusalRecord } from "../lib/model-access";
 import { timelineShowsFailure } from "../lib/timeline-failure-owner";
@@ -257,11 +262,7 @@ import {
   type ComposerLaunchSearch,
 } from "../lib/composer-launch";
 import { connectableSubscriptions, isDeploymentFreeModel } from "../lib/deployment-free-model";
-import {
-  effortOptionsForModel,
-  findPickerRow,
-  runnableLatencyModesForModel,
-} from "../lib/model-policy";
+import { findPickerRow } from "../lib/model-policy";
 import { sessionTimelineEmptyStateCopy } from "../lib/session-empty-state";
 import {
   isCodexUsageLimitFailure,
@@ -2936,7 +2937,14 @@ function SessionChatPane(props: {
       personalAttachment.loading ||
       personalAttachment.refreshing ||
       connectionAccounts.loading,
-    loadFailed: connectionAccounts.error !== null,
+    loadFailed:
+      connectionAccounts.error === null
+        ? false
+        : connectionAccounts.accessDenied
+          ? "denied"
+          : connectionAccounts.unavailable
+            ? "updating"
+            : "failed",
   };
   const composerSendBlocker = () => sendGate.blocker(sendState);
   const workspaceAccountId = context.workspaces.find(
@@ -3166,12 +3174,7 @@ function SessionChatPane(props: {
     composerPolicy.reasoningEffort === props.session.reasoningEffort &&
     composerPolicy.latencyMode === props.session.latencyMode,
   );
-  const catalogComboValid = Boolean(
-    selectedPolicyRow?.selectable &&
-    effortOptionsForModel(selectedPolicyRow.catalog).includes(reasoningEffort) &&
-    (latencyMode === "standard" ||
-      runnableLatencyModesForModel(selectedPolicyRow.catalog).includes(latencyMode)),
-  );
+  const catalogComboValid = pickerPolicyRunnable(selectedPolicyRow, reasoningEffort, latencyMode);
   // A model the catalog no longer lists (retired or removed) is refused by the
   // API, so the frozen session policy stops counting as sendable for it.
   const refusedSessionModel =
@@ -3272,6 +3275,34 @@ function SessionChatPane(props: {
       />
     ) : null;
 
+  // Send's blocker as one visible line, unless the composer is still
+  // preparing or the unavailable-model notice or picker already explains it.
+  const sendBlocker = composerSendBlocker();
+  const visibleSendBlocker =
+    terminal || composerDelivery.preparing
+      ? null
+      : sendBlocker === "policy" && (unavailableModelNotice || noRunnableModel || !composerPolicy)
+        ? null
+        : sendBlocker === "policy" && selectedPolicyRow?.selectable !== true
+          ? "model_unavailable"
+          : sendBlocker;
+  const sendBlockerNotice = composerSendBlockerNotice(visibleSendBlocker) ? (
+    <ComposerSendBlockerNotice
+      blocker={visibleSendBlocker}
+      className="px-2 pt-2"
+      // While the picker is locked (sending, draft loading) the fix can't
+      // apply, so the line shows no action rather than one that does nothing.
+      onAction={
+        modelPickerDisabled && visibleSendBlocker === "policy"
+          ? undefined
+          : (action) => {
+              if (action === "fix_model_settings") chooseCoveredModel(model);
+              else if (visibleSendBlocker === "accounts") void connectionAccounts.refresh();
+            }
+      }
+    />
+  ) : null;
+
   useEffect(() => {
     if (
       !launchKey ||
@@ -4491,6 +4522,7 @@ function SessionChatPane(props: {
                   modelSwitchHeadsUp ||
                   usageLimitNotice ||
                   creditRefusalNotice ||
+                  sendBlockerNotice ||
                   showMachineAccess ? (
                     <>
                       {!sessionAdmissionNeedsDifferentMachine(
@@ -4520,6 +4552,7 @@ function SessionChatPane(props: {
                         <div className="px-2 pt-2">{creditRefusalNotice}</div>
                       ) : null}
                       {ownLoginsHeadsUp}
+                      {sendBlockerNotice}
                     </>
                   ) : null
                 }

package/src/app/routes/sessions-index.tsx

@@ -110,7 +110,26 @@ import { sessionDisplayTitle } from "../lib/session-rename";
 import { Notice } from "../../ui/notice";
 import { CreditRefusalNotice } from "../components/credits/credit-refusal-notice";
 import { coveredModelChoice, creditRefusalGap, freeCreditGap } from "../lib/free-credit-gap";
-import { creditRefusalRecord, type CreditRefusalRecord } from "../lib/model-access";
+import {
+  pickerPolicyRunnable,
+  ComposerSendBlockerNotice,
+  composerSendBlockerIsLoading,
+  composerSendBlockerNotice,
+  getNewSessionSendBlocker,
+  NewSessionCreateFailureNotice,
+  newSessionCreateFailureRecord,
+  newSessionSendSignature,
+  newSessionStartBlockerReason,
+  visibleNewSessionCreateFailure,
+  type NewSessionCreateFailure,
+  type NewSessionSendState,
+} from "../lib/composer-send-blocking";
+import {
+  creditRefusalRecord,
+  isPaymentRequiredError,
+  type CreditRefusalRecord,
+} from "../lib/model-access";
+import { composerSubmissionErrorMessage } from "../../lib/format";
 import { isTransientServiceFailure, OPENGENI_UPDATING_NOTICE } from "../lib/transient-retry";
 import { useConnectionAccounts } from "../components/capabilities/use-connection-accounts";
 import { StatusDot } from "../../ui/status-dot";
@@ -134,13 +153,7 @@ import {
   isMachineComputeSelectable,
   resolveSelectableMachineSandboxId,
 } from "../lib/machine-selectability";
-import {
-  effortOptionsForModel,
-  findPickerRow,
-  modelUsesCredits,
-  runnableLatencyModesForModel,
-  type PickerModelRow,
-} from "../lib/model-policy";
+import { findPickerRow, modelUsesCredits, type PickerModelRow } from "../lib/model-policy";
 import { isPersonalWorkspace } from "../lib/managed-self-context";
 import { attachManualRepository } from "../lib/manual-repositories";
 import { hasAccountPermission, hasWorkspacePermission } from "../lib/permissions";
@@ -688,6 +701,7 @@ function SessionsIndexRouteContent({
   const [createCreditRefusal, setCreateCreditRefusal] = useState<CreditRefusalRecord<{
     workspaceId: string;
   }> | null>(null);
+  const [createFailure, setCreateFailure] = useState<NewSessionCreateFailure | null>(null);
   const [createdSessionAuthority, setCreatedSessionAuthority] =
     useState<CreatedSessionRouteAuthority | null>(null);
   const composerRegionRef = useRef<HTMLDivElement | null>(null);
@@ -1079,6 +1093,33 @@ function SessionsIndexRouteContent({
     void modelCatalog.refresh();
     return true;
   };
+  // What this Send carries; a refused start stays visible until it changes.
+  const sendSignature = newSessionSendSignature({
+    text: message,
+    model: context.model,
+    reasoningEffort: context.reasoningEffort,
+    latencyMode: context.latencyMode,
+  });
+  const createFailureMessage = visibleNewSessionCreateFailure(createFailure, {
+    workspaceId,
+    signature: sendSignature,
+  });
+  const currentSendSignature = useLatestCallback(() => sendSignature);
+  // Any other refused start is shown under the composer instead of a toast:
+  // the chat was never created, so nothing else would say why.
+  const noteCreateFailure = (error: Error, sentSignature: string): boolean => {
+    // A payment refusal keeps its own dialog.
+    if (isPaymentRequiredError(error)) return false;
+    const failure = newSessionCreateFailureRecord({
+      workspaceId,
+      sent: sentSignature,
+      current: currentSendSignature(),
+      message: composerSubmissionErrorMessage(t, error),
+    });
+    if (!failure) return false;
+    setCreateFailure(failure);
+    return true;
+  };
   const chooseCoveredModel = (id: string) => {
     const row = findPickerRow(modelCatalog.rows, id);
     const choice = row
@@ -1090,11 +1131,10 @@ function SessionsIndexRouteContent({
     context.setReasoningEffort(choice.effort);
     if (choice.latencyMode !== null) context.setLatencyMode(choice.latencyMode);
   };
-  const newSessionPolicyValid = Boolean(
-    selectedPolicyRow?.selectable &&
-    effortOptionsForModel(selectedPolicyRow.catalog).includes(context.reasoningEffort) &&
-    (context.latencyMode === "standard" ||
-      runnableLatencyModesForModel(selectedPolicyRow.catalog).includes(context.latencyMode)),
+  const newSessionPolicyValid = pickerPolicyRunnable(
+    selectedPolicyRow,
+    context.reasoningEffort,
+    context.latencyMode,
   );
   const noRunnableModel =
     !modelCatalog.loading &&
@@ -1132,34 +1172,63 @@ function SessionsIndexRouteContent({
     if (!next) return;
     setModel(next.id);
     setReasoningEffort(next.effort);
+    // The replacement keeps the speed only where it runs it (a Free ChatGPT
+    // plan's GPT-6 Luna has no Ultrafast), so the swap never leaves a choice
+    // that cannot send.
+    const row = findPickerRow(modelCatalog.rows, next.id);
+    const fitted = row ? coveredModelChoice(row, next.effort, context.latencyMode) : null;
+    if (fitted?.latencyMode) setLatencyMode(fitted.latencyMode);
     // An automatic replacement is not the person's choice.
     setModelProvided((current) => (current === undefined ? current : false));
-  }, [pendingFallbackModel, setModel, setReasoningEffort]);
+  }, [
+    context.latencyMode,
+    modelCatalog.rows,
+    pendingFallbackModel,
+    setLatencyMode,
+    setModel,
+    setReasoningEffort,
+  ]);
   const codexConnected = modelCatalog.models.some(
     (candidate) =>
       candidate.provider === "codex-subscription" &&
       candidate.credentialReadiness.status === "ready",
   );
-  const startBlocker =
-    modelCatalog.loading || newSessionDraft.loading
-      ? null
-      : modelCatalog.error
-        ? "model_catalog_unavailable"
-        : !newSessionPolicyValid
-          ? !modelCatalog.rows.some((row) => row.selectable)
-            ? "no_model_connected"
-            : selectedPolicyRow &&
-                selectedPolicyRow.billingClass !== "opengeni_credits" &&
-                selectedPolicyRow.catalog.credentialReadiness.status !== "ready"
-              ? "selected_model_not_connected"
-              : "model_policy_unavailable"
-          : privateCreateUnavailable
-            ? "private_session_unavailable"
-            : attachments.hasUnresolved
-              ? "attachments_pending"
-              : !computeReady
-                ? "compute_unavailable"
-                : null;
+  // Send's one guard: its enabled state, the early-Send hold, the guard Send
+  // runs and the visible line below the composer all read it.
+  const sendState: NewSessionSendState = {
+    created: createdSessionAuthority !== null,
+    draftLoading: newSessionDraft.loading,
+    catalogLoading: modelCatalog.loading,
+    catalogFailed: Boolean(modelCatalog.error),
+    replacingModel: pendingFallbackModel !== null,
+    policyValid: newSessionPolicyValid,
+    anyModelSelectable: modelCatalog.rows.some((row) => row.selectable),
+    selectedModelNotConnected: Boolean(
+      selectedPolicyRow &&
+      selectedPolicyRow.billingClass !== "opengeni_credits" &&
+      selectedPolicyRow.catalog.credentialReadiness.status !== "ready",
+    ),
+    selectedModelSelectable: selectedPolicyRow?.selectable === true,
+    // Null capabilities only mean the request is still in flight.
+    privateSessionLoading:
+      tenancyCapabilities === null && (personalWorkspace || draft.visibility === "private"),
+    privateSessionUnavailable: privateCreateUnavailable,
+    toolsLoading: !context.workspaceMcpCatalogReady || personalResourceCatalogRefreshPending,
+    accountsLoading: connectionAccounts.loading,
+    accountsFailed: connectionAccounts.error !== null,
+    accountChoice: connectionAccounts.requiresAccountChoice,
+    resourcesLoading:
+      fixedResourceCatalogEnabled && (rigs.loading || !personalResourceEligibilitySettled),
+    resourcesResolved: fixedResourceSelection.selectionResolved,
+    uploadPending: attachments.hasUnresolved,
+    computeLoading: draft.compute.kind === "machine" && fleet.loading,
+    computeReady,
+  };
+  const sendBlocker = getNewSessionSendBlocker(sendState);
+  // Voice skips the connected-tool accounts; its control and URL launch read
+  // the same guard so a voice start can't be dropped silently either.
+  const voiceSendBlocker = getNewSessionSendBlocker({ ...sendState, voice: true });
+  const startBlocker = newSessionStartBlockerReason(sendBlocker);
   useEffect(() => {
     const record = () => {
       if (startBlocker)
@@ -1202,20 +1271,9 @@ function SessionsIndexRouteContent({
         : attachments.readyResources.length > 0
           ? FILE_ONLY_MESSAGE_TEXT(t)
           : "";
-      if (
-        busy ||
-        !context.workspaceMcpCatalogReady ||
-        newSessionDraft.loading ||
-        !newSessionPolicyValid ||
-        privateCreateUnavailable ||
-        personalResourceCatalogRefreshPending ||
-        (!realtimeModel &&
-          createdSessionAuthority === null &&
-          (connectionAccounts.loading ||
-            connectionAccounts.error !== null ||
-            connectionAccounts.requiresAccountChoice)) ||
-        (createdSessionAuthority === null && !fixedResourceSelection.selectionResolved)
-      )
+      // The same guard as Send's enabled state and the visible line, so a
+      // Send that runs here was shown as available and a refusal is explained.
+      if (busy || getNewSessionSendBlocker({ ...sendState, voice: realtimeModel !== null }))
         return false;
       if (createdSessionAuthority === null) {
         const unavailable = unavailableSessionMcpServerIds(
@@ -1243,12 +1301,7 @@ function SessionsIndexRouteContent({
         });
         return false;
       }
-      if (
-        createdSessionAuthority === null &&
-        ((!text && !realtimeModel) || attachments.hasUnresolved || !computeReady)
-      ) {
-        return false;
-      }
+      if (createdSessionAuthority === null && !text && !realtimeModel) return false;
       // A chosen limit must be a valid amount; an older server never gets one.
       const usageLimit =
         usageLimitCapability === "enabled" ? parseSessionUsageLimitDraft(usageLimitDraft) : null;
@@ -1263,6 +1316,13 @@ function SessionsIndexRouteContent({
       const model = policy?.model ?? persistedValue.model;
       const reasoningEffort = policy?.effort ?? persistedValue.reasoningEffort;
       const latencyMode = policy?.latency ?? persistedValue.latencyMode;
+      // What this request carries, so its refusal is matched to the composer.
+      const sentSignature = newSessionSendSignature({
+        text: persistedValue.text,
+        model,
+        reasoningEffort,
+        latencyMode,
+      });
       // One Send always refers to one visible snapshot, even if a sibling edit
       // forces a draft save or create retry while the user continues typing.
       const visibleSignature = stableJson(persistedValue);
@@ -1347,7 +1407,8 @@ function SessionsIndexRouteContent({
                       return (
                         draftConflict ||
                         newSessionDraft.reportUnavailable(error) ||
-                        noteCreditRefusal(error, request)
+                        noteCreditRefusal(error, request) ||
+                        noteCreateFailure(error, sentSignature)
                       );
                     },
                   },
@@ -1359,6 +1420,7 @@ function SessionsIndexRouteContent({
                 }
                 setUsageLimitDraft(NO_SESSION_USAGE_LIMIT);
                 setCreateCreditRefusal(null);
+                setCreateFailure(null);
                 setUsageLimitSendBlocked(false);
                 return {
                   sessionId: created.id,
@@ -1428,7 +1490,8 @@ function SessionsIndexRouteContent({
                     return (
                       draftConflict ||
                       newSessionDraft.reportUnavailable(error) ||
-                      noteCreditRefusal(error, request)
+                      noteCreditRefusal(error, request) ||
+                      noteCreateFailure(error, sentSignature)
                     );
                   },
                 },
@@ -1441,6 +1504,7 @@ function SessionsIndexRouteContent({
               // The limit belongs to the chat just created; the next starts with none.
               setUsageLimitDraft(NO_SESSION_USAGE_LIMIT);
               setCreateCreditRefusal(null);
+              setCreateFailure(null);
               setUsageLimitSendBlocked(false);
               return {
                 sessionId: created.id,
@@ -1662,15 +1726,7 @@ function SessionsIndexRouteContent({
       });
       return;
     }
-    if (
-      busy ||
-      !computeReady ||
-      !newSessionPolicyValid ||
-      !context.workspaceMcpCatalogReady ||
-      attachments.hasUnresolved
-    ) {
-      return;
-    }
+    if (busy || voiceSendBlocker !== null) return;
     handledLaunchKeyRef.current = launchKey;
     void submitNewSession(launchRealtime, {
       model: launchModel,
@@ -1680,10 +1736,7 @@ function SessionsIndexRouteContent({
       if (!ok) handledLaunchKeyRef.current = null;
     });
   }, [
-    attachments.hasUnresolved,
     busy,
-    computeReady,
-    context.workspaceMcpCatalogReady,
     launchEffort,
     launchFollowDefault,
     launchLatency,
@@ -1695,11 +1748,11 @@ function SessionsIndexRouteContent({
     launch.channelId,
     navigate,
     newSessionDraft.loading,
-    newSessionPolicyValid,
     setLatencyMode,
     setModel,
     setReasoningEffort,
     submitNewSession,
+    voiceSendBlocker,
     workspaceId,
   ]);
 
@@ -1721,26 +1774,11 @@ function SessionsIndexRouteContent({
         message.trim().length > 0 ||
         attachments.readyResources.length > 0) &&
       !busy &&
-      !newSessionDraft.loading &&
-      newSessionPolicyValid &&
-      !personalResourceCatalogRefreshPending &&
-      (createdSessionAuthority !== null ||
-        (!connectionAccounts.loading &&
-          connectionAccounts.error === null &&
-          !connectionAccounts.requiresAccountChoice)) &&
-      (createdSessionAuthority !== null || fixedResourceSelection.selectionResolved) &&
-      (createdSessionAuthority !== null || (!attachments.hasUnresolved && computeReady)),
+      sendBlocker === null,
     // What Send needs right after the page opens is still loading: an early
-    // Send waits for it instead of doing nothing.
-    preparing:
-      modelCatalog.loading ||
-      newSessionDraft.loading ||
-      pendingFallbackModel !== null ||
-      personalResourceCatalogRefreshPending ||
-      (createdSessionAuthority === null &&
-        (connectionAccounts.loading ||
-          (fixedResourceCatalogEnabled && (rigs.loading || !personalResourceEligibilitySettled)) ||
-          (draft.compute.kind === "machine" && fleet.loading))),
+    // Send waits for it instead of doing nothing. Any other blocker shows its
+    // line below the composer.
+    preparing: composerSendBlockerIsLoading(sendBlocker),
     pause: async () => {},
     pausing: false,
     resume: async () => {},
@@ -2166,27 +2204,22 @@ function SessionsIndexRouteContent({
                       : voiceSelection.loadState
                   }
                   modelMenu="split"
-                  disabled={
-                    busy ||
-                    newSessionDraft.loading ||
-                    attachments.hasUnresolved ||
-                    !newSessionPolicyValid ||
-                    !computeReady ||
-                    personalMachineSelected ||
-                    !context.workspaceMcpCatalogReady
-                  }
+                  disabled={busy || voiceSendBlocker !== null || personalMachineSelected}
                   disabledReason={
-                    attachments.hasUnresolved
+                    voiceSendBlocker === "upload"
                       ? "Wait for attachments to finish before starting voice."
-                      : !newSessionPolicyValid
+                      : voiceSendBlocker === "policy"
                         ? "Choose supported model settings before starting voice."
-                        : !computeReady
+                        : voiceSendBlocker === "compute"
                           ? "Choose where this session should run first."
-                          : personalMachineSelected
-                            ? "Start with a message so personal machine access can attach to an accepted turn."
-                            : !context.workspaceMcpCatalogReady
-                              ? "Wait for session tools to finish loading."
-                              : null
+                          : voiceSendBlocker !== null &&
+                              composerSendBlockerIsLoading(voiceSendBlocker)
+                            ? "Wait for the chat to finish loading."
+                            : voiceSendBlocker !== null
+                              ? (composerSendBlockerNotice(voiceSendBlocker)?.message ?? null)
+                              : personalMachineSelected
+                                ? "Start with a message so personal machine access can attach to an accepted turn."
+                                : null
                   }
                   onStart={async (model) => await submitNewSession(model)}
                 />
@@ -2241,6 +2274,29 @@ function SessionsIndexRouteContent({
             </div>
           ) : null}
 
+          {/* A refused start, until the person changes what they send. */}
+          <NewSessionCreateFailureNotice
+            message={createFailureMessage}
+            onDismiss={() => setCreateFailure(null)}
+            className="mt-3"
+          />
+
+          {/* Send's blocker, when no other surface already explains it. */}
+          <ComposerSendBlockerNotice
+            blocker={sendBlocker}
+            explained={
+              fixedResourceCatalogError
+                ? [...NEW_SESSION_EXPLAINED_BLOCKERS, "resources"]
+                : NEW_SESSION_EXPLAINED_BLOCKERS
+            }
+            className="mt-3"
+            onAction={(action) => {
+              if (action === "fix_model_settings") chooseCoveredModel(context.model);
+              else if (sendBlocker === "model_catalog") void modelCatalog.refresh();
+              else if (sendBlocker === "accounts") void connectionAccounts.refresh();
+            }}
+          />
+
           {/* Accounts load quietly with the composer: only a problem shows here,
               never a loading line behind an open menu. */}
           {accountsFailure || connectionAccounts.accountChoiceMessage ? (
@@ -2501,6 +2557,9 @@ function RecentSessionRow({
   );
 }
 
+/** The accounts notice below the new-chat composer explains these itself. */
+const NEW_SESSION_EXPLAINED_BLOCKERS = ["accounts", "account_choice"] as const;
+
 /** Keep model policy adjacent to voice/send in the bottom action row. */
 function SessionModelControl({
   hasImageAttachments,

package/src/app/routes/site-view.test.tsx

@@ -1007,6 +1007,12 @@ test("Edit with Opengeni on a Site already open starts a new conversation once",
 
 const publicationSlot = (container: HTMLElement) =>
   container.querySelector<HTMLElement>("[data-live-status-slot]")!;
+/** The publication control's own text, without the Site's "…" menu beside it. */
+const publicationText = (container: HTMLElement) => {
+  const slot = publicationSlot(container).cloneNode(true) as HTMLElement;
+  for (const menu of slot.querySelectorAll("[data-site-actions-root]")) menu.remove();
+  return slot.textContent;
+};
 const siteHidden = (container: HTMLElement) =>
   container.querySelector("[data-site-view]")!.parentElement!.classList.contains("hidden");
 
@@ -1015,7 +1021,7 @@ test("an unpublished Site offers Publish, which opens its publish form beside th
   permissions = ["sessions:create", "artifacts:publish"];
   publicationLink = notPublished;
   const { container } = await render();
-  expect(publicationSlot(container).textContent).toBe("Publish");
+  expect(publicationText(container)).toBe("Publish");
   expect(container.querySelector("[data-publish-page]")).toBeNull();
 
   await act(async () => button(container, "Publish")!.click());
@@ -1048,8 +1054,8 @@ test("an unpublished Site offers Publish, which opens its publish form beside th
   expect(container.querySelector("[data-publish-page]")).toBeNull();
   expect(siteHidden(container)).toBe(false);
   expect(publications).toHaveLength(1);
-  expect(publicationSlot(container).textContent).toContain("Published");
-  expect(publicationSlot(container).textContent).toContain("usage-4k9x.sites.example");
+  expect(publicationText(container)).toContain("Published");
+  expect(publicationText(container)).toContain("usage-4k9x.sites.example");
   // Focus goes back to the control that opened the form.
   expect(document.activeElement?.getAttribute("data-site-publication")).toBe("published");
 });
@@ -1117,12 +1123,12 @@ test("people who can't publish see Published and its address, with no Publish or
   conversations = [];
   publicationLink = async () => published;
   const { container } = await render();
-  expect(publicationSlot(container).textContent).toContain("Published");
+  expect(publicationText(container)).toContain("Published");
   expect(button(container, "Publishing settings")).toBeUndefined();
   act(() => root?.unmount());
   publicationLink = notPublished;
   const next = await render();
-  expect(publicationSlot(next.container).textContent).toBe("");
+  expect(publicationText(next.container)).toBe("");
   expect(managementArgs).toHaveLength(0);
 });
 
@@ -1132,7 +1138,7 @@ test("the header never says Live, also where publishing isn't available", async
   const { container } = await render();
   // A replacement is always given, so the frame's plain "Live" never shows.
   expect(siteViewProps.at(-1)!.liveStatus).toBeDefined();
-  expect(publicationSlot(container).textContent).toBe("");
+  expect(publicationText(container)).toBe("");
 });
 
 const menuItem = (container: HTMLElement, text: string) =>
@@ -1272,3 +1278,65 @@ test("with the chat hidden, or no chat to take files, the Site keeps its drops",
   await act(async () => void fireFileDrag(document.body, "dragenter", [shot]));
   expect(cover(empty.container)).toBeNull();
 });
+
+const siteActions = (container: HTMLElement) =>
+  [
+    ...container.querySelectorAll<HTMLElement>(
+      "[data-site-actions-root] [role='menuitem'], [data-site-actions-root] a",
+    ),
+  ].map((item) => item.textContent);
+
+test("the Site's own menu copies its title, duplicates it and opens its details", async () => {
+  permissions = ["sessions:create", "artifacts:publish"];
+  conversations = [conversation(1, "Time filters across all graphs", 2)];
+  const { container } = await render();
+  expect(container.querySelector("[data-site-actions-menu]")?.getAttribute("aria-label")).toBe(
+    "More Site actions",
+  );
+  // Without a sidebar listing the Site, its Pin and Archive have nowhere to act.
+  expect(siteActions(container)).toEqual(["Copy title", "Duplicate", "Site details"]);
+  // The chat's menu keeps to the chat.
+  const chatMenu = [...container.querySelectorAll("[role='menu']")].filter(
+    (menu) => !menu.closest("[data-site-actions-root]"),
+  );
+  for (const menu of chatMenu) expect(menu.textContent).not.toContain("Site details");
+});
+
+test("people who can't publish get no Duplicate in the Site's menu", async () => {
+  permissions = ["sessions:create"];
+  const { container } = await render();
+  expect(siteActions(container)).toEqual(["Copy title", "Site details"]);
+});
+
+test("the Site's menu pins and archives through the sidebar's own actions", async () => {
+  const { publishSiteSidebarBridge } = await import("../lib/site-sidebar-bridge");
+  const pins: [string, boolean][] = [];
+  const archived: string[] = [];
+  const withdraw = publishSiteSidebarBridge({
+    workspaceId,
+    pinnedSiteIds: new Set([siteId]),
+    pin: (origin, pinned) => void pins.push([origin.siteId, pinned]),
+    archive: (origin) => void archived.push(origin.siteId),
+  });
+  try {
+    const { container } = await render();
+    expect(siteActions(container)).toEqual(["Copy title", "Unpin", "Site details", "Archive"]);
+    await act(async () => button(container, "Unpin")!.click());
+    await act(async () => button(container, "Archive")!.click());
+    expect(pins).toEqual([[siteId, false]]);
+    expect(archived).toEqual([siteId]);
+  } finally {
+    act(() => withdraw());
+  }
+});
+
+test("a Site with nothing published yet offers no Duplicate", async () => {
+  permissions = ["sessions:create", "artifacts:publish"];
+  siteDetails = async () => ({
+    artifact: { title: "Opengeni usage", status: "active", currentVersion: null },
+    versions: [],
+    events: [],
+  });
+  const { container } = await render();
+  expect(siteActions(container)).toEqual(["Copy title", "Site details"]);
+});