@stigmer/react 3.1.7 → 3.1.9

package/src/library/visibilityLevels.ts

@@ -143,6 +143,42 @@ export const INSTANCE_VISIBILITY_LEVELS: readonly VisibilityLevelOption[] = [
   },
 ];
 
+/**
+ * The levels an environment selector offers, in escalation order:
+ * Private / Organization. Broader levels are structurally absent —
+ * secret values never leave the org boundary (the backend rejects
+ * public/platform via the kind's VisibilityConfig).
+ *
+ * Org sharing on an environment carries credential semantics, so the
+ * copy names both effects: members get redacted view, and executions
+ * in the org (teammate-run agents AND shared-agent visitors) can use
+ * the values at runtime. Secret reveal stays creator-only at every
+ * level.
+ *
+ * In `local` mode (OSS Go backend, single-user) sharing has no
+ * enforcement meaning, so no interactive levels are offered —
+ * {@link ResourceVisibilityControl} degrades to a read-only badge.
+ */
+export function environmentVisibilityLevels(
+  deploymentMode: "cloud" | "local",
+): readonly VisibilityLevelOption[] {
+  if (deploymentMode === "local") {
+    return [PRIVATE_OPTION];
+  }
+  return [
+    {
+      ...PRIVATE_OPTION,
+      description: "Only you can view and use these credentials",
+    },
+    {
+      ...ORG_OPTION,
+      description:
+        "Agents run in your org — including shared-agent visitors — can use these credentials. Members see names only; secret values stay hidden.",
+      confirmPrompt: "Let agents run in your org use these credentials?",
+    },
+  ];
+}
+
 /**
  * Canonical option for a visibility value, independent of any kind's offered
  * list. Used to render the current level even when it is not offerable in

package/src/session/NewSessionViewer.tsx

@@ -1,6 +1,6 @@
 "use client";
 
-import { useCallback, useMemo, useState, type ReactNode } from "react";
+import { useCallback, useEffect, useMemo, useState, type ReactNode } from "react";
 import { cn } from "@stigmer/theme";
 import type { ResourceRef } from "@stigmer/sdk";
 import type { UseGitHubConnectionReturn } from "../github/useGitHubConnection.js";
@@ -83,7 +83,17 @@ export interface NewSessionViewerProps {
    * server, skill, and session-variable pickers — for product-embedded
    * chat where the agent is configured upstream by the platform. The
    * model selector, interaction mode, harness selector, attachments,
-   * and workspace picker remain. See {@link SessionAudience}.
+   * and workspace picker remain.
+   *
+   * `"guest"` (anonymous visitor with a guest token) is pure chat: it
+   * additionally hides the model/harness/mode pickers, attachments,
+   * the workspace picker, and the session panel, binds the session to
+   * `initialAgentRef` + `initialInstanceId` without any picker
+   * machinery, and skips the org-level reads a guest principal cannot
+   * make. Requires both `initialAgentRef` and `initialInstanceId` —
+   * a guest launcher never falls back to the org default agent.
+   *
+   * See {@link SessionAudience}.
    *
    * @default "integrator"
    */
@@ -198,9 +208,26 @@ export function NewSessionViewer({
     onError,
     getRuntimeEnv,
     defaultHarness,
+    audience,
   });
   const [interactionMode, setInteractionMode] = useState<InteractionModeOption>("agent");
-  const isEndUser = audience === "endUser";
+  const isGuest = audience === "guest";
+  // Both curated audiences (endUser, guest) lock the agent and hide the
+  // integrator pickers; guest adds its own restrictions below.
+  const isCurated = audience !== "integrator";
+
+  // Guest agent binding is host configuration, not a picker interaction:
+  // the composer's agent machinery (picker, env-collection, personal
+  // environments — all org reads a guest token cannot make) stays fully
+  // unwired, and the launcher pins the flow to the shared agent's
+  // instance directly. Without the pin, submission fails closed in
+  // useNewSessionFlow rather than falling back to the org default agent.
+  const { setAgentRef, setResolution } = flow;
+  useEffect(() => {
+    if (!isGuest || !initialAgentRef || !initialInstanceId) return;
+    setAgentRef(initialAgentRef);
+    setResolution({ mode: "saved", instanceId: initialInstanceId });
+  }, [isGuest, initialAgentRef, initialInstanceId, setAgentRef, setResolution]);
 
   // The unified-panel controller (shared with SessionViewer, DD-016). The
   // launcher has no execution yet, so the FSM inputs are static. It has no
@@ -259,9 +286,9 @@ export function NewSessionViewer({
       harness: flow.harness,
       executionTarget: undefined,
       modelId: flow.modelId,
-      // End users see the configuration but cannot strip it — the Setup
-      // tab renders read-only without mutation callbacks (DD-011).
-      mutations: isEndUser
+      // Curated audiences see the configuration but cannot strip it — the
+      // Setup tab renders read-only without mutation callbacks (DD-011).
+      mutations: isCurated
         ? undefined
         : {
             onRemoveAgent: flow.agentRef ? handleRemoveAgent : undefined,
@@ -272,7 +299,7 @@ export function NewSessionViewer({
     [
       flow.agentRef, flow.mcpServerUsages, flow.skillRefs,
       flow.sessionVariables, flow.harness, flow.modelId,
-      isEndUser, handleRemoveAgent, handleRemoveMcp, handleRemoveSkill,
+      isCurated, handleRemoveAgent, handleRemoveMcp, handleRemoveSkill,
     ],
   );
 
@@ -312,29 +339,33 @@ export function NewSessionViewer({
           onSubmit={flow.submit}
           isSubmitting={flow.isSubmitting}
           org={org}
-          workspace={flow.workspace}
-          gitHubConnection={enableGitHub ? gitHubConnection : undefined}
-          enableGitHub={enableGitHub}
-          enableLocal={enableLocal}
+          workspace={isGuest ? undefined : flow.workspace}
+          gitHubConnection={enableGitHub && !isGuest ? gitHubConnection : undefined}
+          enableGitHub={enableGitHub && !isGuest}
+          enableLocal={enableLocal && !isGuest}
           onBrowseLocalFolder={onBrowseLocalFolder}
           agentRef={flow.agentRef}
-          onAgentRefChange={flow.setAgentRef}
-          onAgentResolutionChange={flow.setResolution}
-          initialAgentRef={initialAgentRef}
-          initialInstanceId={initialInstanceId}
-          initialAttachments={initialAttachments}
-          lockAgent={isEndUser && initialAgentRef != null}
-          mcpServerUsages={isEndUser ? undefined : flow.mcpServerUsages}
-          onMcpServerUsagesChange={isEndUser ? undefined : flow.setMcpServerUsages}
-          skillRefs={isEndUser ? undefined : flow.skillRefs}
-          onSkillRefsChange={isEndUser ? undefined : flow.setSkillRefs}
-          sessionVariables={isEndUser ? undefined : flow.sessionVariables}
-          showHarnessSelector
+          // Guests get no agent machinery at all — the binding is applied
+          // by the launcher's pin effect above, not by picker resolution.
+          onAgentRefChange={isGuest ? undefined : flow.setAgentRef}
+          onAgentResolutionChange={isGuest ? undefined : flow.setResolution}
+          initialAgentRef={isGuest ? undefined : initialAgentRef}
+          initialInstanceId={isGuest ? undefined : initialInstanceId}
+          initialAttachments={isGuest ? undefined : initialAttachments}
+          lockAgent={isCurated && initialAgentRef != null}
+          mcpServerUsages={isCurated ? undefined : flow.mcpServerUsages}
+          onMcpServerUsagesChange={isCurated ? undefined : flow.setMcpServerUsages}
+          skillRefs={isCurated ? undefined : flow.skillRefs}
+          onSkillRefsChange={isCurated ? undefined : flow.setSkillRefs}
+          sessionVariables={isCurated ? undefined : flow.sessionVariables}
+          showHarnessSelector={!isGuest}
           harness={flow.harness}
           onHarnessChange={flow.setHarness}
           interactionMode={interactionMode}
           onInteractionModeChange={setInteractionMode}
-          showInteractionModePicker
+          showInteractionModePicker={!isGuest}
+          showModelSelector={!isGuest}
+          enableAttachments={!isGuest}
           defaultModelId={flow.modelId}
           onModelChange={flow.setModelId}
           placeholder={placeholder}
@@ -360,13 +391,18 @@ export function NewSessionViewer({
           reads as instability and, worse, unmounts the open panel's only
           collapse control when the last context item is removed. Always-on is
           the predictable, discoverable shape; opening homes on the Config
-          facet, which carries useful defaults (harness/model) pre-session. */}
-      <div className="absolute top-2 right-6 z-10">
-        <SessionPanelChip
-          isOpen={panel.isOpen}
-          onToggle={panel.isOpen ? panel.closePanel : panel.openPanel}
-        />
-      </div>
+          facet, which carries useful defaults (harness/model) pre-session.
+          Guests are the exception: the panel exposes configuration a visitor
+          has no business with, so the chip (the panel's only toggle) is
+          simply absent and the panel can never open. */}
+      {!isGuest && (
+        <div className="absolute top-2 right-6 z-10">
+          <SessionPanelChip
+            isOpen={panel.isOpen}
+            onToggle={panel.isOpen ? panel.closePanel : panel.openPanel}
+          />
+        </div>
+      )}
 
       {/* Same unified-panel layout as SessionViewer (DD-016): collapsed by
           default (composer fills the row); opening makes the composer the

package/src/session/SessionViewer.tsx

@@ -209,8 +209,15 @@ export interface SessionViewerProps {
    * session-variable configuration in both the composer and the
    * inspector's Setup tab — for product-embedded chat where the agent
    * is configured upstream by the platform. The model selector,
-   * interaction mode, attachments, and workspace picker remain. See
-   * {@link SessionAudience}.
+   * interaction mode, attachments, and workspace picker remain.
+   *
+   * `"guest"` (anonymous visitor with a guest token) is pure chat: it
+   * additionally hides the model/mode pickers, attachments, the
+   * workspace picker, and the session panel, and skips the org-level
+   * reads a guest principal cannot make — follow-ups simply continue
+   * on the session's bound agent instance.
+   *
+   * See {@link SessionAudience}.
    *
    * @default "integrator"
    */
@@ -303,9 +310,12 @@ export function SessionViewer({
   threadSlots,
   className,
 }: SessionViewerProps) {
-  const flow = useSessionPageFlow({ sessionId, org, getRuntimeEnv });
+  const flow = useSessionPageFlow({ sessionId, org, getRuntimeEnv, audience });
   const { conv } = flow;
-  const isEndUser = audience === "endUser";
+  const isGuest = audience === "guest";
+  // Both curated audiences (endUser, guest) lock the agent and hide the
+  // integrator configuration; guest adds its own restrictions below.
+  const isCurated = audience !== "integrator";
 
   const [modelId, setModelId] = flow.model;
   const [interactionMode, setInteractionMode] = flow.interactionMode;
@@ -391,7 +401,9 @@ export function SessionViewer({
   const panel = useSessionPanel({
     phase: hasPhase ? phase : null,
     hasChanges: hasWriteBacks,
-    planKey: panelPlanKey,
+    // A streaming plan auto-opens the panel via its key — but guests have
+    // no panel, so the trigger is suppressed along with the chip.
+    planKey: isGuest ? null : panelPlanKey,
   });
 
   const handleBuildFromPlan = useCallback(() => {
@@ -504,6 +516,10 @@ export function SessionViewer({
   // (which subscribes), never this streaming column.
   const handleTranscriptFilePathClick = useCallback(
     (path: string): boolean => {
+      // Guests have no panel (and no file viewer), so paths keep their
+      // default copy behavior instead of opening a surface that cannot
+      // render.
+      if (isGuest) return false;
       const selection = resolveWorkspaceFileSelection(
         path,
         flow.workspace.entries,
@@ -513,7 +529,7 @@ export function SessionViewer({
       panel.openFile(selection.entryId, selection.path);
       return true;
     },
-    [flow.workspace.entries, flow.sandboxWorkspaceRoot, panel.openFile],
+    [isGuest, flow.workspace.entries, flow.sandboxWorkspaceRoot, panel.openFile],
   );
 
   if (conv.isLoading) {
@@ -537,14 +553,18 @@ export function SessionViewer({
       {/* Top-right controls: host actions + the panel chip. The chip is the
           panel's always-mounted toggle; while collapsed it carries only the
           pending-item count. Execution status is never surfaced as header
-          chrome — the thread itself communicates run state. */}
+          chrome — the thread itself communicates run state. Guests get no
+          chip: the panel exposes session configuration a visitor has no
+          business with, so its only toggle is simply absent. */}
       <div className="absolute top-2 right-6 z-10 flex items-center gap-2">
         {headerActions}
-        <SessionPanelChip
-          isOpen={panel.isOpen}
-          onToggle={panel.isOpen ? panel.closePanel : panel.openPanel}
-          badgeCount={writeBackCount + artifactCount}
-        />
+        {!isGuest && (
+          <SessionPanelChip
+            isOpen={panel.isOpen}
+            onToggle={panel.isOpen ? panel.closePanel : panel.openPanel}
+            badgeCount={writeBackCount + artifactCount}
+          />
+        )}
       </div>
 
       <ThreadSelectionContext.Provider value={selectionStore}>
@@ -583,12 +603,13 @@ export function SessionViewer({
               planAttachFailed={planAttachFailed}
               onDismissPlanAttachFailed={() => setPlanAttachFailed(false)}
               onFilePathClick={handleTranscriptFilePathClick}
-              isEndUser={isEndUser}
+              isCurated={isCurated}
+              isGuest={isGuest}
               threadSlots={threadSlots}
             />
           }
           secondary={
-            panel.isOpen ? (
+            panel.isOpen && !isGuest ? (
               <SessionPanelRegion
                 flow={flow}
                 org={org}
@@ -609,7 +630,7 @@ export function SessionViewer({
                 workspaceFileLister={workspaceFileLister}
                 workspaceFileReader={workspaceFileReader}
                 workspaceContentSearcher={workspaceContentSearcher}
-                isEndUser={isEndUser}
+                isCurated={isCurated}
               />
             ) : null
           }
@@ -649,7 +670,10 @@ interface ConversationColumnProps {
    * let the path keep its copy / GitHub-link behavior.
    */
   readonly onFilePathClick: (path: string) => boolean;
-  readonly isEndUser: boolean;
+  /** Curated audience (endUser or guest): locked agent, no integrator pickers. */
+  readonly isCurated: boolean;
+  /** Guest audience: pure chat — additionally no model picker, mode picker, attachments, or workspace. */
+  readonly isGuest: boolean;
   readonly threadSlots?: MessageThreadSlots;
 }
 
@@ -671,7 +695,8 @@ const ConversationColumn = memo(function ConversationColumn({
   planAttachFailed,
   onDismissPlanAttachFailed,
   onFilePathClick,
-  isEndUser,
+  isCurated,
+  isGuest,
   threadSlots,
 }: ConversationColumnProps) {
   const { conv } = flow;
@@ -839,22 +864,27 @@ const ConversationColumn = memo(function ConversationColumn({
           onModelChange={setModelId}
           interactionMode={interactionMode}
           onInteractionModeChange={setInteractionMode}
-          showInteractionModePicker
-          workspace={flow.workspace}
-          gitHubConnection={gitHubConnection}
-          enableGitHub={enableGitHub}
-          enableLocal={enableLocal}
+          showInteractionModePicker={!isGuest}
+          showModelSelector={!isGuest}
+          enableAttachments={!isGuest}
+          workspace={isGuest ? undefined : flow.workspace}
+          gitHubConnection={isGuest ? undefined : gitHubConnection}
+          enableGitHub={enableGitHub && !isGuest}
+          enableLocal={enableLocal && !isGuest}
           onBrowseLocalFolder={onBrowseLocalFolder}
           agentRef={flow.agentRef}
-          onAgentRefChange={flow.setAgentRef}
-          onAgentResolutionChange={flow.setResolution}
+          // Guests get no agent machinery: the session's agent is already
+          // bound server-side, and the picker's resolution path performs
+          // org reads a guest token cannot make.
+          onAgentRefChange={isGuest ? undefined : flow.setAgentRef}
+          onAgentResolutionChange={isGuest ? undefined : flow.setResolution}
           isDefaultAgent={flow.isDefaultAgent}
-          lockAgent={isEndUser}
-          mcpServerUsages={isEndUser ? undefined : flow.mcpServerUsages}
-          onMcpServerUsagesChange={isEndUser ? undefined : flow.setMcpServerUsages}
-          skillRefs={isEndUser ? undefined : flow.skillRefs}
-          onSkillRefsChange={isEndUser ? undefined : flow.setSkillRefs}
-          sessionVariables={isEndUser ? undefined : flow.sessionVariables}
+          lockAgent={isCurated}
+          mcpServerUsages={isCurated ? undefined : flow.mcpServerUsages}
+          onMcpServerUsagesChange={isCurated ? undefined : flow.setMcpServerUsages}
+          skillRefs={isCurated ? undefined : flow.skillRefs}
+          onSkillRefsChange={isCurated ? undefined : flow.setSkillRefs}
+          sessionVariables={isCurated ? undefined : flow.sessionVariables}
           className="px-4 py-3"
         />
       </div>
@@ -909,7 +939,8 @@ interface SessionPanelRegionProps {
   readonly workspaceFileLister?: WorkspaceFileLister;
   readonly workspaceFileReader?: WorkspaceFileReader;
   readonly workspaceContentSearcher?: WorkspaceContentSearcher;
-  readonly isEndUser: boolean;
+  /** Curated audience (endUser or guest): the Setup facet renders read-only. */
+  readonly isCurated: boolean;
 }
 
 function SessionPanelRegion({
@@ -932,7 +963,7 @@ function SessionPanelRegion({
   workspaceFileLister,
   workspaceFileReader,
   workspaceContentSearcher,
-  isEndUser,
+  isCurated,
 }: SessionPanelRegionProps) {
   const selectedItem = useSelectedThreadItem();
   const { editors, activeKey, activeFile, reveal } = useWorkspaceEditors(
@@ -1108,9 +1139,9 @@ function SessionPanelRegion({
       harness: flow.harness,
       executionTarget: flow.executionTarget,
       modelId: flow.model[0],
-      // End users see the configuration but cannot strip it — the Config
-      // facet renders read-only without mutation callbacks (DD-011).
-      mutations: isEndUser
+      // Curated audiences see the configuration but cannot strip it — the
+      // Config facet renders read-only without mutation callbacks (DD-011).
+      mutations: isCurated
         ? undefined
         : {
             onRemoveAgent: flow.isDefaultAgent ? undefined : handleRemoveAgent,
@@ -1122,7 +1153,7 @@ function SessionPanelRegion({
     [
       flow.agentRef, flow.isDefaultAgent, flow.mcpServerUsages, flow.skillRefs,
       flow.sessionVariables, flow.harness, flow.executionTarget, flow.model,
-      isEndUser, handleRemoveAgent, handleRemoveMcp, handleRemoveSkill,
+      isCurated, handleRemoveAgent, handleRemoveMcp, handleRemoveSkill,
       accessSlot,
     ],
   );

package/src/session/__tests__/audienceWiring.test.tsx

@@ -249,6 +249,75 @@ describe("NewSessionViewer — audience wiring", () => {
       expect.objectContaining({ getRuntimeEnv, defaultHarness: "cursor" }),
     );
   });
+
+  it("guest: pure chat — every picker hidden, attachments and workspace off", () => {
+    render(
+      <NewSessionViewer
+        org="acme"
+        onSessionCreated={vi.fn()}
+        audience="guest"
+        initialAgentRef={AGENT_REF}
+        initialInstanceId="inst_1"
+      />,
+    );
+
+    const props = lastComposerProps();
+    expect(props.lockAgent).toBe(true);
+    expect(props.onMcpServerUsagesChange).toBeUndefined();
+    expect(props.onSkillRefsChange).toBeUndefined();
+    expect(props.sessionVariables).toBeUndefined();
+    // Guest-only restrictions on top of the endUser curation.
+    expect(props.showHarnessSelector).toBe(false);
+    expect(props.showInteractionModePicker).toBe(false);
+    expect(props.showModelSelector).toBe(false);
+    expect(props.enableAttachments).toBe(false);
+    expect(props.enableGitHub).toBe(false);
+    expect(props.workspace).toBeUndefined();
+    // The session panel's only toggle is absent for guests.
+    expect(screen.queryByRole("button", { name: "Show panel" })).toBeNull();
+  });
+
+  it("guest: agent binding bypasses the composer's picker machinery", () => {
+    render(
+      <NewSessionViewer
+        org="acme"
+        onSessionCreated={vi.fn()}
+        audience="guest"
+        initialAgentRef={AGENT_REF}
+        initialInstanceId="inst_1"
+      />,
+    );
+
+    // The composer's agent machinery is fully unwired (no picker, no
+    // resolution flow — those perform org reads a guest token cannot make)…
+    const props = lastComposerProps();
+    expect(props.onAgentRefChange).toBeUndefined();
+    expect(props.onAgentResolutionChange).toBeUndefined();
+    expect(props.initialAgentRef).toBeUndefined();
+    expect(props.initialInstanceId).toBeUndefined();
+    // …and the launcher pins the flow to the shared instance directly.
+    expect(stubNewSessionFlow.setAgentRef).toHaveBeenCalledWith(AGENT_REF);
+    expect(stubNewSessionFlow.setResolution).toHaveBeenCalledWith({
+      mode: "saved",
+      instanceId: "inst_1",
+    });
+  });
+
+  it("guest: forwards the audience to the flow", () => {
+    render(
+      <NewSessionViewer
+        org="acme"
+        onSessionCreated={vi.fn()}
+        audience="guest"
+        initialAgentRef={AGENT_REF}
+        initialInstanceId="inst_1"
+      />,
+    );
+
+    expect(mockUseNewSessionFlow).toHaveBeenCalledWith(
+      expect.objectContaining({ audience: "guest" }),
+    );
+  });
 });
 
 describe("SessionViewer — audience wiring", () => {
@@ -276,6 +345,36 @@ describe("SessionViewer — audience wiring", () => {
     expect(openedConfigFacet().mutations).toBeUndefined();
   });
 
+  it("guest: pure chat — every picker hidden, attachments and workspace off", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" audience="guest" />);
+
+    const props = lastComposerProps();
+    expect(props.lockAgent).toBe(true);
+    expect(props.onMcpServerUsagesChange).toBeUndefined();
+    expect(props.onSkillRefsChange).toBeUndefined();
+    expect(props.sessionVariables).toBeUndefined();
+    // Guest-only restrictions on top of the endUser curation.
+    expect(props.showInteractionModePicker).toBe(false);
+    expect(props.showModelSelector).toBe(false);
+    expect(props.enableAttachments).toBe(false);
+    expect(props.enableGitHub).toBe(false);
+    expect(props.workspace).toBeUndefined();
+    // Agent machinery is fully unwired — the session's agent is bound
+    // server-side and its resolution reads are FGA-denied for guests.
+    expect(props.onAgentRefChange).toBeUndefined();
+    expect(props.onAgentResolutionChange).toBeUndefined();
+    // The session panel's only toggle is absent for guests.
+    expect(screen.queryByRole("button", { name: "Show panel" })).toBeNull();
+  });
+
+  it("guest: forwards the audience to the flow", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" audience="guest" />);
+
+    expect(mockUseSessionPageFlow).toHaveBeenCalledWith(
+      expect.objectContaining({ audience: "guest" }),
+    );
+  });
+
   it("forwards getRuntimeEnv to the flow", () => {
     const getRuntimeEnv = vi.fn();
     render(

package/src/session/__tests__/useNewSessionFlow.test.tsx

@@ -36,8 +36,9 @@ const mockDefaultAgent = {
   refetch: vi.fn(),
   waitForResolution: vi.fn<() => Promise<unknown>>(),
 };
+const useDefaultAgentSpy = vi.fn((_org: string | null) => mockDefaultAgent);
 vi.mock("../../agent", () => ({
-  useDefaultAgent: () => mockDefaultAgent,
+  useDefaultAgent: (org: string | null) => useDefaultAgentSpy(org),
 }));
 
 const mockWorkspace = {
@@ -683,4 +684,77 @@ describe("useNewSessionFlow", () => {
       expect(mockDefaultAgent.waitForResolution).not.toHaveBeenCalled();
     });
   });
+
+  describe("guest audience", () => {
+    it("disables the default-agent lookup (a read guests cannot make)", () => {
+      const opts = { ...defaultOptions(), audience: "guest" as const };
+      renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
+
+      expect(useDefaultAgentSpy).toHaveBeenCalledWith(null);
+    });
+
+    it("keeps the default-agent lookup for other audiences", () => {
+      renderHook(() => useNewSessionFlow(defaultOptions()), { wrapper: createWrapper() });
+
+      expect(useDefaultAgentSpy).toHaveBeenCalledWith("acme");
+    });
+
+    it("creates the session against the pinned resolution", async () => {
+      const opts = { ...defaultOptions(), audience: "guest" as const };
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
+
+      act(() => {
+        result.current.setAgentRef({ org: "acme", slug: "support-bot" });
+        result.current.setResolution({ mode: "saved", instanceId: "shared-inst" });
+      });
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      expect(mockCreateSession).toHaveBeenCalledOnce();
+      expect(mockCreateSession.mock.calls[0][0].agentInstanceId).toBe("shared-inst");
+      expect(opts.onSessionCreated).toHaveBeenCalledWith("sess-new");
+    });
+
+    it("fails closed on submit without a resolution — never the default agent", async () => {
+      // A default agent exists (the beforeEach seeds one); a guest must
+      // still never fall back to it.
+      const opts = { ...defaultOptions(), audience: "guest" as const };
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      expect(mockCreateSession).not.toHaveBeenCalled();
+      expect(mockCreateExecution).not.toHaveBeenCalled();
+      expect(result.current.submitError).toContain("still loading");
+      expect(opts.onError).toHaveBeenCalled();
+    });
+
+    it("surfaces launch-gate refusal copy verbatim from the status description", async () => {
+      // The backend resolves owner-customizable refusal copy server-side and
+      // carries it in the gRPC status description — the flow must hand it to
+      // onError untouched (no client-side mapping exists by design).
+      const ownerCopy = "This agent is currently unavailable. Please check back later.";
+      const { ConnectError, Code } = await import("@connectrpc/connect");
+      mockCreateExecution.mockRejectedValueOnce(
+        new ConnectError(ownerCopy, Code.FailedPrecondition),
+      );
+
+      const opts = { ...defaultOptions(), audience: "guest" as const };
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
+
+      act(() => {
+        result.current.setAgentRef({ org: "acme", slug: "support-bot" });
+        result.current.setResolution({ mode: "saved", instanceId: "shared-inst" });
+      });
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      expect(result.current.submitError).toBe(ownerCopy);
+      expect(opts.onError).toHaveBeenCalledWith(ownerCopy);
+    });
+  });
 });