@stigmer/react 0.2.2 → 0.3.0

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

@@ -0,0 +1,258 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { renderHook, act } from "@testing-library/react";
+import { DEFAULT_MODEL_ID, DEFAULT_CURSOR_MODEL_ID } from "../../models/registry";
+import type { UseCreateSessionReturn } from "../useCreateSession";
+
+const mockCreateSession = vi.fn<UseCreateSessionReturn["create"]>();
+vi.mock("../useCreateSession", () => ({
+  useCreateSession: () => ({
+    create: mockCreateSession,
+    isCreating: false,
+    error: null,
+    clearError: vi.fn(),
+  }),
+}));
+
+const mockCreateExecution = vi.fn();
+vi.mock("../../execution/useCreateAgentExecution", () => ({
+  useCreateAgentExecution: () => ({
+    create: mockCreateExecution,
+    isCreating: false,
+    error: null,
+    clearError: vi.fn(),
+  }),
+}));
+
+const mockDefaultAgent = {
+  agent: null as { status?: { defaultInstanceId?: string } } | null,
+  isLoading: false,
+  error: null,
+  refetch: vi.fn(),
+};
+vi.mock("../../agent", () => ({
+  useDefaultAgent: () => mockDefaultAgent,
+}));
+
+const mockWorkspace = {
+  entries: [],
+  hasEntries: false,
+  toInput: vi.fn().mockReturnValue([]),
+  addGitRepo: vi.fn(),
+  addLocalPath: vi.fn(),
+  removeEntry: vi.fn(),
+  clear: vi.fn(),
+};
+vi.mock("../../workspace", () => ({
+  useWorkspaceEntries: () => mockWorkspace,
+}));
+
+const mockSessionVariables = {
+  variables: [],
+  hasVariables: false,
+  setVariable: vi.fn(),
+  removeVariable: vi.fn(),
+  clear: vi.fn(),
+  toMap: vi.fn().mockReturnValue(new Map()),
+};
+vi.mock("../../execution/useSessionVariables", () => ({
+  useSessionVariables: () => mockSessionVariables,
+}));
+
+import { useNewSessionFlow } from "../useNewSessionFlow";
+
+const STORAGE_KEY_HARNESS = "stigmer:session:harness";
+const STORAGE_KEY_MODEL_NATIVE = "stigmer:session:model";
+const STORAGE_KEY_MODEL_CURSOR = "stigmer:session:model:cursor";
+
+function defaultOptions() {
+  return {
+    org: "acme",
+    onSessionCreated: vi.fn(),
+    onError: vi.fn(),
+  };
+}
+
+describe("useNewSessionFlow", () => {
+  beforeEach(() => {
+    localStorage.clear();
+    mockDefaultAgent.agent = {
+      status: { defaultInstanceId: "default-inst" },
+    };
+    mockDefaultAgent.isLoading = false;
+    mockDefaultAgent.error = null;
+    mockCreateSession.mockResolvedValue({ sessionId: "sess-new" });
+    mockCreateExecution.mockResolvedValue({});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    localStorage.clear();
+  });
+
+  describe("harness state", () => {
+    it("defaults to native when localStorage is empty", () => {
+      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()));
+      expect(result.current.harness).toBe("native");
+    });
+
+    it("restores cursor harness from localStorage", () => {
+      localStorage.setItem(STORAGE_KEY_HARNESS, "cursor");
+      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()));
+      expect(result.current.harness).toBe("cursor");
+    });
+
+    it("falls back to native for unknown localStorage values", () => {
+      localStorage.setItem(STORAGE_KEY_HARNESS, "unknown-value");
+      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()));
+      expect(result.current.harness).toBe("native");
+    });
+
+    it("persists harness to localStorage on change", () => {
+      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()));
+
+      act(() => result.current.setHarness("cursor"));
+
+      expect(localStorage.getItem(STORAGE_KEY_HARNESS)).toBe("cursor");
+      expect(result.current.harness).toBe("cursor");
+    });
+
+    it("persists native harness to localStorage", () => {
+      localStorage.setItem(STORAGE_KEY_HARNESS, "cursor");
+      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()));
+
+      act(() => result.current.setHarness("native"));
+
+      expect(localStorage.getItem(STORAGE_KEY_HARNESS)).toBe("native");
+    });
+  });
+
+  describe("per-harness model persistence", () => {
+    it("uses separate storage keys for native and cursor models", () => {
+      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()));
+
+      act(() => result.current.setModelId(DEFAULT_MODEL_ID));
+
+      expect(localStorage.getItem(STORAGE_KEY_MODEL_NATIVE)).toBe(
+        DEFAULT_MODEL_ID,
+      );
+      expect(localStorage.getItem(STORAGE_KEY_MODEL_CURSOR)).toBeNull();
+    });
+
+    it("persists cursor model to cursor-specific key", () => {
+      localStorage.setItem(STORAGE_KEY_HARNESS, "cursor");
+      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()));
+
+      act(() => result.current.setModelId(DEFAULT_CURSOR_MODEL_ID));
+
+      expect(localStorage.getItem(STORAGE_KEY_MODEL_CURSOR)).toBe(
+        DEFAULT_CURSOR_MODEL_ID,
+      );
+    });
+
+    it("restores per-harness model when switching harness", () => {
+      localStorage.setItem(STORAGE_KEY_MODEL_CURSOR, DEFAULT_CURSOR_MODEL_ID);
+
+      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()));
+
+      act(() => result.current.setHarness("cursor"));
+
+      expect(result.current.modelId).toBe(DEFAULT_CURSOR_MODEL_ID);
+    });
+
+    it("clears modelId when switching to a harness with no stored model", () => {
+      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()));
+
+      act(() => result.current.setModelId(DEFAULT_MODEL_ID));
+      expect(result.current.modelId).toBe(DEFAULT_MODEL_ID);
+
+      act(() => result.current.setHarness("cursor"));
+
+      // No stored cursor model → modelId should be undefined
+      // (unless the model happens to be valid in the cursor registry)
+      if (result.current.modelId !== undefined) {
+        // If it has a value, it must be valid for cursor harness
+        expect(result.current.modelId).toBe(
+          localStorage.getItem(STORAGE_KEY_MODEL_CURSOR),
+        );
+      }
+    });
+
+    it("invalidates modelId when it is not in the active harness registry", () => {
+      const { result } = renderHook(() => useNewSessionFlow(defaultOptions()));
+
+      // Set a native-only model
+      act(() => result.current.setModelId(DEFAULT_MODEL_ID));
+      expect(result.current.modelId).toBe(DEFAULT_MODEL_ID);
+
+      // Switch to cursor → native model should be invalidated
+      act(() => result.current.setHarness("cursor"));
+
+      // DEFAULT_MODEL_ID (anthropic) is not in cursor registry
+      expect(result.current.modelId).not.toBe(DEFAULT_MODEL_ID);
+    });
+  });
+
+  describe("submit with harness", () => {
+    it("passes harness field to createSession", async () => {
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts));
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      expect(mockCreateSession).toHaveBeenCalledOnce();
+      const sessionInput = mockCreateSession.mock.calls[0][0];
+      expect(sessionInput.harness).toBe("native");
+    });
+
+    it("passes cursor harness to createSession after switching", async () => {
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts));
+
+      act(() => result.current.setHarness("cursor"));
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      const sessionInput = mockCreateSession.mock.calls[0][0];
+      expect(sessionInput.harness).toBe("cursor");
+    });
+
+    it("calls onSessionCreated on success", async () => {
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts));
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      expect(opts.onSessionCreated).toHaveBeenCalledWith("sess-new");
+    });
+
+    it("sets submitError and calls onError on failure", async () => {
+      mockCreateSession.mockRejectedValueOnce(new Error("RPC fail"));
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts));
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      expect(result.current.submitError).not.toBeNull();
+      expect(opts.onError).toHaveBeenCalled();
+    });
+
+    it("resets isSubmitting after completion", async () => {
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts));
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      expect(result.current.isSubmitting).toBe(false);
+    });
+  });
+});

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

@@ -302,4 +302,57 @@ describe("useSessionConversation", () => {
       expect(result.current.pendingUserMessage).toBeNull();
     });
   });
+
+  it("full follow-up lifecycle: active execution completes → canSendFollowUp → sendFollowUp succeeds", async () => {
+    // Start with one IN_PROGRESS execution (simulates a Cursor execution running)
+    const activeExec = makeExecution("exec-1", ExecutionPhase.EXECUTION_IN_PROGRESS);
+    methods.listBySession.mockResolvedValue({ entries: [activeExec] });
+
+    const execStream = createControllableStream<AgentExecution>();
+    methods.subscribe.mockReturnValue(execStream.generator);
+
+    const { result } = renderHook(
+      () => useSessionConversation("session-1", "org"),
+      { wrapper: createWrapper(mockStigmer) },
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    // Initially canSendFollowUp should be false (execution is active)
+    expect(result.current.canSendFollowUp).toBe(false);
+
+    // Stream delivers EXECUTION_COMPLETED — simulating Cursor run finishing
+    const completedExec = makeExecution("exec-1", ExecutionPhase.EXECUTION_COMPLETED);
+    act(() => {
+      execStream.push(completedExec);
+    });
+
+    // After stream completes, the hook should refetch executions.
+    // Mock the refetch to return the completed execution.
+    methods.listBySession.mockResolvedValue({ entries: [completedExec] });
+
+    // Wait for canSendFollowUp to become true
+    await waitFor(() => {
+      expect(result.current.canSendFollowUp).toBe(true);
+    });
+
+    // Now send a follow-up message
+    const followUpExec = makeExecution("exec-2", ExecutionPhase.EXECUTION_PENDING);
+    followUpExec.metadata!.id = "exec-2";
+    methods.executionCreate.mockResolvedValue(followUpExec);
+
+    await act(async () => {
+      await result.current.sendFollowUp("Follow-up message", { modelName: "default" });
+    });
+
+    // Verify the create call was made with the correct session and message
+    expect(methods.executionCreate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        org: "org",
+        sessionId: "session-1",
+        message: "Follow-up message",
+        executionConfig: expect.objectContaining({ modelName: "default" }),
+      }),
+    );
+  });
 });

package/src/session/index.ts

@@ -61,7 +61,7 @@ export type {
 } from "./useSessionPageFlow";
 
 export { usePersistedModel } from "./usePersistedModel";
-export type { UsePersistedModelReturn } from "./usePersistedModel";
+export type { UsePersistedModelReturn, UsePersistedModelOptions } from "./usePersistedModel";
 
 export { useEditSessionPrep } from "./useEditSessionPrep";
 export type { UseEditSessionPrepReturn } from "./useEditSessionPrep";

package/src/session/useCreateSession.ts

@@ -9,6 +9,7 @@ import {
 } from "@stigmer/sdk";
 import { useStigmer } from "../hooks";
 import { toError } from "../internal/toError";
+import { toProtoHarness, type HarnessOption } from "../models/harness";
 
 /** Shared fields present in both variants of {@link CreateSessionInput}. */
 export interface SharedSessionFields {
@@ -30,6 +31,13 @@ export interface SharedSessionFields {
    * auto-bind in OSS, cloud auto-provisioning in Cloud).
    */
   readonly runnerId?: string;
+  /**
+   * Execution harness for this session.
+   *
+   * Determines which execution engine processes agent activities.
+   * Immutable after the first execution runs. Defaults to `"native"`.
+   */
+  readonly harness?: HarnessOption;
 }
 
 /**
@@ -157,6 +165,7 @@ export function useCreateSession(): UseCreateSessionReturn {
           skillRefs: input.skillRefs,
           runnerId: input.runnerId,
           agentInstanceId: resolvedInstanceId,
+          harness: input.harness ? toProtoHarness(input.harness) : undefined,
         });
 
         return { sessionId: session.metadata!.id };

package/src/session/useNewSessionFlow.ts

@@ -5,15 +5,22 @@ import { getUserMessage, type McpServerUsageInput, type ResourceRef } from "@sti
 import type { AgentResolution } from "../agent";
 import { useDefaultAgent } from "../agent";
 import { useModelRegistry } from "../models";
+import { DEFAULT_HARNESS, type HarnessOption } from "../models/harness";
 import { useWorkspaceEntries, type UseWorkspaceEntriesReturn } from "../workspace";
 import { useSessionVariables, type UseSessionVariablesReturn } from "../execution/useSessionVariables";
 import type { SessionComposerSubmitContext } from "../composer";
 import { useCreateSession } from "./useCreateSession";
 import { useCreateAgentExecution } from "../execution/useCreateAgentExecution";
 
-const STORAGE_KEY_MODEL = "stigmer:session:model";
+const STORAGE_KEY_HARNESS = "stigmer:session:harness";
 const STORAGE_KEY_RUNNER = "stigmer:session:runner";
 
+function modelStorageKey(harness: HarnessOption): string {
+  return harness === "cursor"
+    ? "stigmer:session:model:cursor"
+    : "stigmer:session:model";
+}
+
 /** Options for {@link useNewSessionFlow}. */
 export interface UseNewSessionFlowOptions {
   /** Organization slug. Required for session and execution creation. */
@@ -33,7 +40,12 @@ export interface UseNewSessionFlowOptions {
 
 /** Return value of {@link useNewSessionFlow}. */
 export interface UseNewSessionFlowReturn {
-  /** Currently selected model ID (persisted to localStorage). */
+  /** Currently selected harness (persisted to localStorage). */
+  readonly harness: HarnessOption;
+  /** Switch the harness. Resets the model if invalid for the new harness. */
+  readonly setHarness: (harness: HarnessOption) => void;
+
+  /** Currently selected model ID (persisted per-harness to localStorage). */
   readonly modelId: string | undefined;
   /** Update the selected model. Automatically persists to localStorage. */
   readonly setModelId: (id: string) => void;
@@ -136,7 +148,13 @@ export function useNewSessionFlow(
 ): UseNewSessionFlowReturn {
   const { org, onSessionCreated, onError } = options;
 
-  const { getModel } = useModelRegistry();
+  const [harness, setHarnessRaw] = useState<HarnessOption>(() => {
+    if (typeof window === "undefined") return DEFAULT_HARNESS;
+    const stored = localStorage.getItem(STORAGE_KEY_HARNESS);
+    return stored === "cursor" ? "cursor" : DEFAULT_HARNESS;
+  });
+
+  const { getModel } = useModelRegistry({ harness });
   const { create: createSession } = useCreateSession();
   const { create: createExecution } = useCreateAgentExecution();
   const {
@@ -158,20 +176,35 @@ export function useNewSessionFlow(
 
   const validModelId = modelId && getModel(modelId) ? modelId : undefined;
 
-  // Restore persisted model on mount
+  // Persist harness on change
+  useEffect(() => {
+    localStorage.setItem(STORAGE_KEY_HARNESS, harness);
+  }, [harness]);
+
+  const setHarness = useCallback(
+    (h: HarnessOption) => {
+      setHarnessRaw(h);
+      // Restore per-harness model preference, or clear if none stored
+      const storedModel = localStorage.getItem(modelStorageKey(h));
+      setModelId(storedModel ?? undefined);
+    },
+    [],
+  );
+
+  // Restore persisted model on mount (using current harness key)
   useEffect(() => {
-    const stored = localStorage.getItem(STORAGE_KEY_MODEL);
+    const stored = localStorage.getItem(modelStorageKey(harness));
     if (stored && getModel(stored)) {
       setModelId(stored);
     }
-  }, [getModel]);
+  }, [getModel, harness]);
 
-  // Persist model on change
+  // Persist model on change (using current harness key)
   useEffect(() => {
     if (modelId) {
-      localStorage.setItem(STORAGE_KEY_MODEL, modelId);
+      localStorage.setItem(modelStorageKey(harness), modelId);
     }
-  }, [modelId]);
+  }, [modelId, harness]);
 
   // Restore persisted runner on mount
   useEffect(() => {
@@ -216,6 +249,7 @@ export function useNewSessionFlow(
           mcpServerUsages: mcpServerUsages.length > 0 ? mcpServerUsages : undefined,
           skillRefs: skillRefs.length > 0 ? skillRefs : undefined,
           runnerId: runnerId ?? undefined,
+          harness,
         };
 
         const executionFields = {
@@ -277,6 +311,7 @@ export function useNewSessionFlow(
     [
       isSubmitting,
       org,
+      harness,
       validModelId,
       workspace,
       mcpServerUsages,
@@ -296,6 +331,8 @@ export function useNewSessionFlow(
   );
 
   return {
+    harness,
+    setHarness,
     modelId: validModelId,
     setModelId,
     agentRef,

package/src/session/usePersistedModel.ts

@@ -2,8 +2,19 @@
 
 import { useEffect, useState } from "react";
 import { useModelRegistry } from "../models";
+import type { HarnessOption } from "../models/harness";
 
-const STORAGE_KEY_MODEL = "stigmer:session:model";
+/** Options for {@link usePersistedModel}. */
+export interface UsePersistedModelOptions {
+  /**
+   * Filter the model registry by harness before validating the stored model.
+   *
+   * When `"cursor"`, the persisted model is read from a cursor-specific
+   * localStorage key and validated against cursor-provider models.
+   * When `"native"` or omitted, the default key and registry apply.
+   */
+  readonly harness?: HarnessOption;
+}
 
 /** Return value of {@link usePersistedModel}. */
 export type UsePersistedModelReturn = readonly [
@@ -11,6 +22,12 @@ export type UsePersistedModelReturn = readonly [
   setModelId: (id: string) => void,
 ];
 
+function storageKey(harness?: HarnessOption): string {
+  return harness === "cursor"
+    ? "stigmer:session:model:cursor"
+    : "stigmer:session:model";
+}
+
 /**
  * Model selection with localStorage persistence.
  *
@@ -19,22 +36,29 @@ export type UsePersistedModelReturn = readonly [
  * `undefined`). On change, persists the new selection to localStorage so
  * it survives page reloads and navigation.
  *
+ * When `options.harness` is provided, the stored model is read from a
+ * harness-specific key and validated against the harness-filtered registry.
+ *
  * Used by both the session launcher (new session) and session page
  * (follow-up messages) to maintain a consistent model preference.
  */
-export function usePersistedModel(): UsePersistedModelReturn {
-  const { getModel } = useModelRegistry();
+export function usePersistedModel(
+  options?: UsePersistedModelOptions,
+): UsePersistedModelReturn {
+  const harness = options?.harness;
+  const { getModel } = useModelRegistry({ harness });
+  const key = storageKey(harness);
 
   const [modelId, setModelId] = useState<string | undefined>(() => {
     if (typeof window === "undefined") return undefined;
-    return localStorage.getItem(STORAGE_KEY_MODEL) ?? undefined;
+    return localStorage.getItem(key) ?? undefined;
   });
 
   useEffect(() => {
     if (modelId) {
-      localStorage.setItem(STORAGE_KEY_MODEL, modelId);
+      localStorage.setItem(key, modelId);
     }
-  }, [modelId]);
+  }, [modelId, key]);
 
   const validModelId = modelId && getModel(modelId) ? modelId : undefined;
   return [validModelId, setModelId] as const;

package/src/session/useSessionConversation.ts

@@ -354,8 +354,11 @@ export function useSessionConversation(
         });
         setPendingExecutionId(result.executionId);
         refetch();
-      } catch {
+      } catch (err) {
         setPendingUserMessage(null);
+        if (process.env.NODE_ENV !== "production") {
+          console.error("[useSessionConversation] sendFollowUp failed:", err);
+        }
       }
     },
     [sessionId, session, org, stigmer, create, updateSession, refetch, refetchSession],
@@ -455,6 +458,8 @@ function buildUpdateInput(
     subject: spec?.subject || undefined,
     threadId: spec?.threadId || undefined,
     sandboxId: spec?.sandboxId || undefined,
+    runnerId: spec?.runnerId || undefined,
+    harness: spec?.harness,
     metadata:
       spec?.metadata && Object.keys(spec.metadata).length > 0
         ? { ...spec.metadata }

package/src/session/useSessionPageFlow.ts

@@ -8,6 +8,8 @@ import { useStigmer } from "../hooks";
 import { useWorkspaceEntries, type UseWorkspaceEntriesReturn } from "../workspace";
 import { useSessionVariables, type UseSessionVariablesReturn } from "../execution/useSessionVariables";
 import type { SessionComposerSubmitContext } from "../composer";
+import { fromProtoHarness, type HarnessOption } from "../models/harness";
+import { Harness } from "@stigmer/protos/ai/stigmer/agentic/session/v1/enum_pb";
 import { useSessionConversation, type UseSessionConversationReturn } from "./useSessionConversation";
 import { useAgentRefFromSession } from "./useAgentRefFromSession";
 import { usePersistedModel, type UsePersistedModelReturn } from "./usePersistedModel";
@@ -31,6 +33,17 @@ export interface UseSessionPageFlowReturn {
   /** Full conversation state from `useSessionConversation`. */
   readonly conv: UseSessionConversationReturn;
 
+  /**
+   * Session's execution harness (read-only, derived from session spec).
+   *
+   * Use this to:
+   * - Filter the model selector for follow-up messages
+   * - Render a harness badge in the session header
+   *
+   * Defaults to `"native"` while the session is loading.
+   */
+  readonly harness: HarnessOption;
+
   /** Persisted model selection: `[modelId, setModelId]`. */
   readonly model: UsePersistedModelReturn;
 
@@ -135,8 +148,18 @@ export function useSessionPageFlow(
 
   const stigmer = useStigmer();
   const conv = useSessionConversation(sessionId, org);
-  const model = usePersistedModel();
-  const [modelId] = model;
+  const harness: HarnessOption = fromProtoHarness(
+    conv.session?.spec?.harness ?? Harness.UNSPECIFIED,
+  );
+  const [persistedModelId, setPersistedModelId] = usePersistedModel({ harness });
+
+  const lastExecModelId = useMemo(() => {
+    const lastExec = conv.completedExecutions.at(-1);
+    return lastExec?.spec?.executionConfig?.modelName || undefined;
+  }, [conv.completedExecutions]);
+
+  const modelId = persistedModelId ?? lastExecModelId;
+  const model: UsePersistedModelReturn = [modelId, setPersistedModelId] as const;
 
   const workspace = useWorkspaceEntries();
   const sessionVariables = useSessionVariables();
@@ -261,6 +284,7 @@ export function useSessionPageFlow(
 
   return {
     conv,
+    harness,
     model,
     agentRef,
     setAgentRef,

package/src/settings/MembersSection.tsx

@@ -4,12 +4,23 @@ import { OrgMembersPanel } from "../iam-policy/OrgMembersPanel";
 import { useResourceAvailable, ApiResourceKind } from "../deployment-mode";
 import { CloudFeatureNotice } from "../internal/CloudFeatureNotice";
 import { useOrg } from "../organization/OrgProvider";
+import { useIdentityProviderList } from "../identity-provider/useIdentityProviderList";
 
 /** Settings section for organization membership and role management. */
 export function MembersSection() {
   const { activeOrg } = useOrg();
   const membersAvailable = useResourceAvailable(ApiResourceKind.iam_policy);
+  const idpAvailable = useResourceAvailable(ApiResourceKind.identity_provider);
   const orgId = activeOrg?.metadata?.id ?? "";
+  const orgSlug = activeOrg?.metadata?.slug ?? "";
+
+  const { identityProviders } = useIdentityProviderList(
+    idpAvailable && orgSlug ? orgSlug : null,
+  );
+
+  const hasJitProviders = identityProviders.some(
+    (idp) => idp.spec?.autoProvisionAccounts || idp.spec?.isSsoProvider,
+  );
 
   return (
     <section aria-labelledby="members-heading">
@@ -34,7 +45,18 @@ export function MembersSection() {
           Select an organization to manage members.
         </p>
       ) : (
-        <OrgMembersPanel orgId={orgId} />
+        <>
+          {hasJitProviders && (
+            <div className="mb-3 rounded-md border border-border-muted bg-muted-faint px-3 py-2">
+              <p className="text-[0.65rem] text-muted-foreground">
+                This organization has identity providers with auto-provisioning
+                enabled. Members may appear here automatically when users
+                authenticate via federated identity.
+              </p>
+            </div>
+          )}
+          <OrgMembersPanel orgId={orgId} />
+        </>
       )}
     </section>
   );