@@ -132,6 +132,37 @@ describe('connected accounts', () => {
     expect(screen.getByText('Provider error')).toBeInTheDocument();
   });
 
+  it('retries a canceled connection from its row instead of offering Connect again', async () => {
+    const canceled = fapiExternalAccount({
+      id: 'idn_google',
+      provider: 'google',
+      verification: fapiVerification({
+        status: 'unverified',
+        strategy: 'oauth_google',
+        error: {
+          code: 'oauth_access_denied',
+          message: 'Access denied',
+          long_message: 'You did not grant access to your Google account',
+        },
+      }),
+    });
+    const { clerk } = await renderSection([canceled]);
+    const navigate = vi.spyOn(clerk, 'navigate').mockImplementation(() => Promise.resolve());
+    const request = holdRequests('post', '/v1/me/external_accounts');
+    const user = userEvent.setup();
+
+    expect(screen.getByText('You did not grant access to your Google account')).toBeInTheDocument();
+    expect(screen.queryByRole('button', { name: 'Connect Google' })).toBeNull();
+    await user.click(screen.getByRole('button', { name: 'Manage Google' }));
+    await user.click(screen.getByRole('menuitem', { name: 'Try again' }));
+
+    await waitFor(() => expect(request.requests).toHaveLength(1));
+    const body = new URLSearchParams(await request.requests[0]?.text());
+    expect(body.get('strategy')).toBe('oauth_google');
+    request.release();
+    await waitFor(() => expect(navigate).toHaveBeenCalledWith('https://accounts.example/authorize'));
+  });
+
   it('sends requested scopes and the current URL to connect', async () => {
     serveFapi(signedIn([]));
     const { clerk } = await renderWithClerk(
 
@@ -31,8 +31,11 @@ export function UserProfileConnectedAccountRowView({
   const m = useMessages('userProfileConnectedAccounts');
   const iconUrl = account.iconUrl?.trim();
   const actions: ActionMenuAction[] = [];
-  if (account.status === 'reconnect' && onReconnect && !isDisabled) {
-    actions.push({ label: m.reconnect, onClick: () => onReconnect(account.id) });
+  if ((account.status === 'reconnect' || account.status === 'error') && onReconnect && !isDisabled) {
+    actions.push({
+      label: account.status === 'reconnect' ? m.reconnect : m.tryAgain,
+      onClick: () => onReconnect(account.id),
+    });
   }
   if (onRemove && account.canRemove !== false) {
     actions.push({ label: m.remove, color: 'negative', onClick: () => onRemove(account) });
 
@@ -3,6 +3,7 @@ export const userProfileConnectedAccountsMessages = {
   connect: 'Connect',
   connectLabel: 'Connect {provider}',
   reconnect: 'Reconnect',
+  tryAgain: 'Try again',
   disconnected: 'Disconnected',
   manageLabel: 'Manage {provider}',
   remove: 'Remove',
 
@@ -6,6 +6,7 @@ import {
   allowsIdentificationCreation,
   getEnabledOAuthStrategies,
   getRecovery,
+  getRetry,
   projectConnectedAccounts,
   useUserProfileConnectedAccountsModel,
 } from './user-profile-connected-accounts-section.model';
@@ -281,17 +282,17 @@ describe('projectConnectedAccounts', () => {
     ]);
   });
 
-  it('offers enabled providers without a verified account, keyed by strategy', () => {
+  it('offers enabled providers that have no account row, keyed by strategy', () => {
     const projection = projectConnectedAccounts({
       user: userWith([
         account({ id: 'idn_google', provider: 'google' }),
         account({ id: 'idn_github', provider: 'github', status: 'unverified', errorCode: 'oauth_access_denied' }),
+        account({ id: 'idn_acme', provider: 'custom_acme', status: 'unverified' }),
       ]),
       social: social('oauth_google', 'oauth_github', 'oauth_custom_acme'),
       allowCreation: true,
     });
     expect(projection.status === 'ready' && projection.availableProviders.map(p => p.id)).toEqual([
-      'oauth_github',
       'oauth_custom_acme',
     ]);
   });
@@ -435,3 +436,24 @@ describe('allowsIdentificationCreation', () => {
     expect(allowsIdentificationCreation(active, { enabled: false } as EnterpriseSSOSettings)).toBe(true);
   });
 });
+
+describe('getRetry', () => {
+  it('retries a failed connection with its strategy and missing scopes', () => {
+    expect(
+      getRetry(
+        account({
+          id: 'idn_1',
+          provider: 'google',
+          status: 'unverified',
+          errorCode: 'oauth_access_denied',
+          approvedScopes: '',
+        }),
+        { google: ['calendar'] },
+      ),
+    ).toEqual({ kind: 'create', strategy: 'oauth_google', additionalScopes: ['calendar'] });
+  });
+
+  it('does not retry an account without an error', () => {
+    expect(getRetry(account({ id: 'idn_1', provider: 'google' }), undefined)).toBeNull();
+  });
+});
@@ -116,6 +116,20 @@ export function getRecovery(
     return null;
   }
 
+  return createRecovery(account, additionalScopes);
+}
+
+export function getRetry(
+  account: ExternalAccountResource,
+  scopes: AdditionalOAuthScopes | undefined,
+): ConnectedAccountRecovery | null {
+  if (!account.verification?.error) {
+    return null;
+  }
+  return createRecovery(account, findAdditionalScopes(account, scopes));
+}
+
+function createRecovery(account: ExternalAccountResource, additionalScopes: string[]): ConnectedAccountRecovery {
   const verificationStrategy = account.verification?.strategy;
   const strategy = (
     verificationStrategy === 'google_one_tap' ? 'oauth_google' : verificationStrategy || `oauth_${account.provider}`
@@ -159,14 +173,14 @@ export function projectConnectedAccounts({
     ...user.verifiedExternalAccounts,
     ...user.unverifiedExternalAccounts.filter(account => account.verification?.error),
   ];
-  const connectedStrategies = user.verifiedExternalAccounts.map(account => `oauth_${account.provider}`);
+  const shownStrategies = displayed.map(account => `oauth_${account.provider}`);
 
   return {
     status: 'ready',
     accounts: displayed.map(account => toAccountRow(account, social, additionalOAuthScopes)),
     availableProviders: allowCreation
       ? getEnabledOAuthStrategies(social)
-          .filter(strategy => !connectedStrategies.includes(strategy))
+          .filter(strategy => !shownStrategies.includes(strategy))
           .map(strategy => ({ id: strategy, ...getProviderDisplay(strategy.replace('oauth_', ''), social) }))
       : [],
   };
@@ -274,7 +288,7 @@ export function useUserProfileConnectedAccountsModel({
       if (!account) {
         throw new ConnectedAccountActionError('unavailable');
       }
-      const recovery = getRecovery(account, additionalOAuthScopes);
+      const recovery = getRecovery(account, additionalOAuthScopes) ?? getRetry(account, additionalOAuthScopes);
       if (!recovery) {
         return;
       }