Keep a ready login form when the prime step is dismissed

startFlow assumed discovery was still running and forced the UI into a
loading state. When the session had already reached AWAITING_INPUT while
the consent step was on screen, that hid a ready form behind a spinner
the backend had no further transition to clear. Derive the UI state from
the session state we already hold.

Author: ehfeng

.changeset/quiet-moons-return.md

@@ -0,0 +1,5 @@
+---
+"@onkernel/managed-auth-react": patch
+---
+
+Keep an already-ready login form visible when the consent step is dismissed, instead of replacing it with a loading state that no later event will clear.

packages/managed-auth-react/src/session/useManagedAuthSession.test.ts

@@ -180,6 +180,52 @@ describe("useManagedAuthSession initialization", () => {
     expect(value!.isInitializing).toBe(false);
   });
 
+  test("keeps a ready form when the prime step is dismissed", async () => {
+    let value: ManagedAuthSessionValue | null = null;
+    let retrieveRequests = 0;
+
+    const fetchImpl = (async (
+      input: RequestInfo | URL,
+      init?: RequestInit,
+    ): Promise<Response> => {
+      const url = String(input);
+      if (url.endsWith("/exchange")) return response({ jwt: "jwt" });
+      if (url.endsWith("/events")) return new Promise<Response>(() => {});
+      if (init?.method === "GET") {
+        retrieveRequests++;
+        return response(awaitingInputState());
+      }
+      throw new Error(`Unexpected request: ${init?.method} ${url}`);
+    }) as typeof fetch;
+
+    function Harness() {
+      value = useManagedAuthSession({
+        sessionId: "session-id",
+        handoffCode: "handoff-code",
+        fetch: fetchImpl,
+      });
+      return null;
+    }
+
+    await act(async () => {
+      renderer = create(createElement(Harness));
+      await flushPromises();
+    });
+
+    expect(value!.uiState).toBe("prime");
+
+    // Discovery finished while the prime step was on screen. Continuing has
+    // to show the fields that are already waiting: the session has no further
+    // transition to publish, so nothing would ever clear a spinner here.
+    await act(async () => {
+      value!.startFlow();
+      await flushPromises();
+    });
+
+    expect(value!.uiState).toBe("awaiting_input");
+    expect(retrieveRequests).toBe(1);
+  });
+
   test("leaves initialization when the handoff exchange fails", async () => {
     let value: ManagedAuthSessionValue | null = null;
     const fetchImpl = (async (_input: RequestInfo | URL, _init?: RequestInit) =>

packages/managed-auth-react/src/session/useManagedAuthSession.ts

@@ -382,7 +382,12 @@ export function useManagedAuthSession(
 
   const startFlow = useCallback(() => {
     if (!jwt) return;
-    setUIState("discovering");
+    // The prime step can outlive discovery: the session may already be
+    // awaiting input by the time the user clicks through. Derive from the
+    // state we hold instead of assuming discovery is still running, or a
+    // ready form is replaced by a spinner with no event left to clear it.
+    const current = stateRef.current;
+    setUIState(current ? deriveUIState(current) : "discovering");
     connectStream(jwt);
   }, [jwt, connectStream]);