diff --git a/src/components/RecoveryAlertsCard.css b/src/components/RecoveryAlertsCard.css
index 38b042e..45fd275 100644
--- a/src/components/RecoveryAlertsCard.css
+++ b/src/components/RecoveryAlertsCard.css
@@ -28,6 +28,25 @@
 .recovery-alerts .auth-alert {
   overflow-wrap: anywhere;
 }
+.recovery-feedback,
+.recovery-focus-target {
+  scroll-margin-top: 90px;
+  scroll-margin-bottom: 20px;
+}
+.recovery-feedback:focus-visible,
+.recovery-focus-target:focus-visible {
+  outline: 2px solid var(--accent);
+  outline-offset: 4px;
+}
+.recovery-verification {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 10px;
+}
+.recovery-verification p {
+  margin: 0;
+}
 .recovery-email {
   overflow-wrap: anywhere;
 }
@@ -144,6 +163,23 @@
 .recovery-link-details[open] summary {
   margin-bottom: 12px;
 }
+.recovery-review {
+  border-top: 1px solid var(--panel-outline);
+  padding-top: 12px;
+}
+.recovery-review ol {
+  margin: 0 0 12px;
+  padding-left: 22px;
+  color: var(--muted);
+  font-size: 0.85rem;
+  line-height: 1.6;
+}
+.recovery-review li + li {
+  margin-top: 8px;
+}
+.recovery-history .recovery-operation + .recovery-operation {
+  margin-top: 12px;
+}
 .recovery-disable,
 .recovery-refresh {
   align-self: flex-start;
diff --git a/src/components/RecoveryAlertsCard.js b/src/components/RecoveryAlertsCard.js
index f186959..1d52e29 100644
--- a/src/components/RecoveryAlertsCard.js
+++ b/src/components/RecoveryAlertsCard.js
@@ -110,13 +110,51 @@ function AccountAddress({ address }) {
   );
 }
 
+const TERMINAL_RECOVERIES = new Set(['expired', 'canceled', 'invalidated']);
+
+function RecoveryOperation({ operation }) {
+  const pending = ['pending', 'ready', 'scheduled'].includes(operation.status);
+  return (
+    <div className="recovery-operation">
+      <strong>
+        {{
+          scheduled: 'Recovery pending',
+          pending: 'Recovery pending',
+          ready: 'Recovery can be executed',
+          expired: 'Recovery expired',
+          executed: 'Recovery executed',
+          canceled: 'Recovery canceled or invalidated',
+          invalidated: 'Recovery no longer pending',
+          orphaned: 'Recovery observation no longer canonical',
+          unknown: 'Recovery status unavailable',
+        }[operation.status] || 'Recovery observed'}
+      </strong>
+      <span>
+        {pending ? 'Can execute from' : 'Original execution time'}{' '}
+        {datetime(operation.executableAt)}
+      </span>
+      {Number(operation.expiresAt) > 0 && (
+        <span>
+          {pending ? 'Expires' : 'Original expiry'}{' '}
+          {datetime(operation.expiresAt)}
+        </span>
+      )}
+      {pending && (
+        <span className="recovery-note">
+          Passing the deadline does not mean it has executed.
+        </span>
+      )}
+    </div>
+  );
+}
+
 export default function RecoveryAlertsCard({
   service = recoveryAlertsService,
   authService = defaultAuthService,
   defaultOpen = false,
   discover = discoverWallets,
 }) {
-  const { user, handleAuthLost } = useAuth();
+  const { user, handleAuthLost, refresh } = useAuth();
   const userId = user && user.id;
   const [open, setOpen] = useState(
     defaultOpen ||
@@ -134,21 +172,51 @@ export default function RecoveryAlertsCard({
   const [loading, setLoading] = useState(false);
   const [phase, setPhase] = useState('');
   const [error, setError] = useState(null);
+  const [errorScope, setErrorScope] = useState('general');
+  const [errorFocus, setErrorFocus] = useState(0);
   const [notice, setNotice] = useState(null);
   const [removing, setRemoving] = useState(null);
   const [password, setPassword] = useState('');
   const [code, setCode] = useState('');
   const [needTotp, setNeedTotp] = useState(false);
+  const [verificationChecked, setVerificationChecked] = useState(false);
   const generation = useRef(0);
   const fetchGeneration = useRef(0);
   const userRef = useRef(userId);
   userRef.current = userId;
   const mounted = useRef(true);
   const busy = useRef(false);
+  const errorRef = useRef(null);
+  const removalHeadingRef = useRef(null);
   const wallet = wallets.find((item) => item.id === walletId);
   const walletRef = useRef(wallet);
   walletRef.current = wallet;
 
+  // Only an explicit failed action requests focus. Background refreshes and
+  // typing must never move the viewport or steal keyboard focus.
+  useEffect(() => {
+    if (!errorFocus || !errorRef.current) return;
+    // A user may collapse the enrollment details while the wallet is open.
+    // Reveal this action's error before focusing; never do this for polling.
+    const disclosure = errorRef.current.closest('details');
+    if (disclosure) disclosure.open = true;
+    errorRef.current.focus({ preventScroll: true });
+    // Instant explicitly bypasses the site's smooth-scroll preference, including
+    // when the user has requested reduced motion.
+    errorRef.current.scrollIntoView?.({
+      block: 'nearest',
+      behavior: 'instant',
+    });
+  }, [errorFocus]);
+  useEffect(() => {
+    if (!removing || !removalHeadingRef.current) return;
+    removalHeadingRef.current.focus({ preventScroll: true });
+    removalHeadingRef.current.scrollIntoView?.({
+      block: 'nearest',
+      behavior: 'instant',
+    });
+  }, [removing]);
+
   useEffect(() => {
     mounted.current = true;
     return () => {
@@ -168,16 +236,64 @@ export default function RecoveryAlertsCard({
   );
 
   const handleError = useCallback(
-    (err) => {
+    (err, scope = 'general', focus = false) => {
       if (err && err.code === 'unauthorized') {
         handleAuthLost();
         return;
       }
+      setErrorScope(scope);
       setError(errorText(err));
+      if (focus) {
+        setErrorFocus((current) => current + 1);
+      }
     },
     [handleAuthLost]
   );
 
+  function renderError(scope) {
+    return error && errorScope === scope ? (
+      <div
+        ref={errorRef}
+        className="auth-alert auth-alert--error recovery-feedback"
+        role="alert"
+        tabIndex={-1}
+      >
+        {error}
+      </div>
+    ) : null;
+  }
+
+  async function checkVerification() {
+    if (busy.current) return;
+    busy.current = true;
+    setPhase('checking-email');
+    setError(null);
+    setNotice(null);
+    const id = userId;
+    try {
+      const updated = await refresh({ preserveSessionOnTransientError: true });
+      if (
+        !mounted.current ||
+        userRef.current !== id ||
+        !updated ||
+        updated.id !== id
+      )
+        return;
+      setVerificationChecked(!updated.emailVerified);
+      setNotice(
+        updated.emailVerified
+          ? 'Email verified. You can now link your smart account.'
+          : null
+      );
+    } catch (err) {
+      if (mounted.current && userRef.current === id)
+        handleError(err, 'enroll', true);
+    } finally {
+      busy.current = false;
+      if (mounted.current) setPhase('');
+    }
+  }
+
   const load = useCallback(async () => {
     const id = userRef.current;
     if (id == null) return;
@@ -205,10 +321,12 @@ export default function RecoveryAlertsCard({
         userRef.current === id &&
         fetchGeneration.current === request
       ) {
-        setSubscriptions((current) => current.map((subscription) => ({
-          ...subscription,
-          monitoring: { ...subscription.monitoring, status: 'degraded' },
-        })));
+        setSubscriptions((current) =>
+          current.map((subscription) => ({
+            ...subscription,
+            monitoring: { ...subscription.monitoring, status: 'degraded' },
+          }))
+        );
         handleError(err);
       }
     } finally {
@@ -235,6 +353,7 @@ export default function RecoveryAlertsCard({
     setPassword('');
     setCode('');
     setNeedTotp(false);
+    setVerificationChecked(false);
     setLabel('');
     setLoading(false);
     if (open && userId != null) load();
@@ -264,6 +383,7 @@ export default function RecoveryAlertsCard({
       setSelection(null);
       setAccount('');
       setNotice(null);
+      setErrorScope('general');
       setError(ERROR_COPY.wallet_changed);
     };
     provider.on?.('accountsChanged', changed);
@@ -304,7 +424,7 @@ export default function RecoveryAlertsCard({
         walletRef.current?.provider === provider &&
         userRef.current === id
       )
-        handleError(err);
+        handleError(err, 'enroll', true);
     } finally {
       busy.current = false;
       if (mounted.current) setPhase('');
@@ -344,7 +464,8 @@ export default function RecoveryAlertsCard({
       setLabel('');
       await load();
     } catch (err) {
-      if (mounted.current && userRef.current === id) handleError(err);
+      if (mounted.current && userRef.current === id)
+        handleError(err, 'enroll', true);
     } finally {
       busy.current = false;
       if (mounted.current) setPhase('');
@@ -387,7 +508,7 @@ export default function RecoveryAlertsCard({
     } catch (err) {
       if (mounted.current && userRef.current === id) {
         if (err && err.code === 'totp_required') setNeedTotp(true);
-        handleError(err);
+        handleError(err, 'remove', true);
       }
     } finally {
       busy.current = false;
@@ -403,7 +524,8 @@ export default function RecoveryAlertsCard({
       (item) =>
         item.chainId === selection.chainId &&
         chain &&
-        item.recoveryModule?.toLowerCase() === chain.recoveryModule?.toLowerCase() &&
+        item.recoveryModule?.toLowerCase() ===
+          chain.recoveryModule?.toLowerCase() &&
         item.account.toLowerCase() === account.toLowerCase()
     );
   const phaseLabel = {
@@ -412,6 +534,7 @@ export default function RecoveryAlertsCard({
     signing: 'Confirm in wallet…',
     saving: 'Saving alerts…',
     removing: 'Disabling alerts…',
+    'checking-email': 'Checking verification…',
   }[phase];
 
   return (
@@ -437,6 +560,7 @@ export default function RecoveryAlertsCard({
           className="auth-card__disclosure-toggle"
           aria-expanded={open}
           aria-controls="recovery-alerts-body"
+          disabled={!!phase}
           aria-label={
             open ? 'Collapse recovery alerts' : 'Expand recovery alerts'
           }
@@ -458,11 +582,7 @@ export default function RecoveryAlertsCard({
             Alerts may be delayed and cannot cancel recovery. Keep access to
             your wallet.
           </p>
-          {error && (
-            <div className="auth-alert auth-alert--error" role="alert">
-              {error}
-            </div>
-          )}
+          {renderError('general')}
           {notice && (
             <div className="auth-alert auth-alert--success" role="status">
               {notice}
@@ -476,11 +596,23 @@ export default function RecoveryAlertsCard({
               );
               const monitor = monitoringCopy(
                 subscription.monitoring?.status === 'active' &&
-                (!subscription.monitoring.lastCheckedAt ||
-                  Date.now() - subscription.monitoring.lastCheckedAt > 60000)
+                  (!subscription.monitoring.lastCheckedAt ||
+                    Date.now() - subscription.monitoring.lastCheckedAt > 60000)
                   ? 'degraded'
                   : subscription.monitoring?.status
               );
+              const currentOperations = (subscription.pending || []).filter(
+                (operation) => !TERMINAL_RECOVERIES.has(operation.status)
+              );
+              const pastOperations = (subscription.pending || []).filter(
+                (operation) => TERMINAL_RECOVERIES.has(operation.status)
+              );
+              const hasPendingRecovery = currentOperations.some((operation) =>
+                ['pending', 'ready', 'scheduled'].includes(operation.status)
+              );
+              const hasExecutedRecovery = currentOperations.some(
+                (operation) => operation.status === 'executed'
+              );
               return (
                 <article
                   className="recovery-subscription"
@@ -506,48 +638,68 @@ export default function RecoveryAlertsCard({
                       true
                     )}
                   </p>
-                  {(subscription.pending || []).map((operation) => (
-                    <div
+                  {currentOperations.map((operation) => (
+                    <RecoveryOperation
                       key={operation.operationId}
-                      className="recovery-operation"
-                    >
-                      <strong>
-                        {{
-                          scheduled: 'Recovery pending',
-                          pending: 'Recovery pending',
-                          ready: 'Recovery can be executed',
-                          expired: 'Recovery expired',
-                          executed: 'Recovery executed',
-                          canceled: 'Recovery canceled or invalidated',
-                          invalidated: 'Recovery no longer pending',
-                          orphaned: 'Recovery observation no longer canonical',
-                          unknown: 'Recovery status unavailable',
-                        }[operation.status] || 'Recovery observed'}
-                      </strong>
-                      <span>
-                        {['pending', 'ready', 'scheduled'].includes(
-                          operation.status
-                        )
-                          ? 'Can execute from'
-                          : 'Original execution time'}{' '}
-                        {datetime(operation.executableAt)}
-                      </span>
-                      {Number(operation.expiresAt) > 0 && (
-                        <span>
-                          {['pending', 'ready', 'scheduled'].includes(
-                            operation.status
-                          )
-                            ? 'Expires'
-                            : 'Original expiry'}{' '}
-                          {datetime(operation.expiresAt)}
-                        </span>
-                      )}
-                      <span className="recovery-note">
-                        Review this operation in your wallet. Passing the
-                        deadline does not mean it has executed.
-                      </span>
-                    </div>
+                      operation={operation}
+                    />
                   ))}
+                  {currentOperations.length > 0 && (
+                    <div className="recovery-review">
+                      <p className="recovery-note">
+                        {hasPendingRecovery
+                          ? 'If you did not request recovery, review it in your wallet now. Disabling emails below does not stop recovery.'
+                          : hasExecutedRecovery
+                          ? 'Recovery has executed. Review this account’s current approval methods and activity in Pali. Disabling emails cannot undo it.'
+                          : 'The recovery state needs review. Check this account’s current status and approval methods in Pali.'}
+                      </p>
+                      <details className="recovery-link-details">
+                        <summary>How to review in Pali</summary>
+                        <ol>
+                          <li>
+                            Open Pali and select this account on{' '}
+                            {network
+                              ? network.name
+                              : `chain ${subscription.chainId}`}
+                            .
+                          </li>
+                          <li>
+                            Open <strong>Smart account</strong>, then choose{' '}
+                            <strong>Manage</strong> beside{' '}
+                            <strong>Recovery guardian</strong>.
+                          </li>
+                          {hasPendingRecovery && (
+                            <li>
+                              If recovery is unexpected, use{' '}
+                              <strong>Disable guardian recovery</strong>. This
+                              needs your current approval method and a network
+                              fee.
+                            </li>
+                          )}
+                        </ol>
+                        <a
+                          href="https://docs.paliwallet.com/docs/users/recovery-and-backups"
+                          target="_blank"
+                          rel="noopener noreferrer"
+                        >
+                          Read the recovery guide
+                        </a>
+                      </details>
+                    </div>
+                  )}
+                  {pastOperations.length > 0 && (
+                    <details className="recovery-link-details recovery-history">
+                      <summary>
+                        Past recovery activity ({pastOperations.length})
+                      </summary>
+                      {pastOperations.map((operation) => (
+                        <RecoveryOperation
+                          key={operation.operationId}
+                          operation={operation}
+                        />
+                      ))}
+                    </details>
+                  )}
                   <button
                     type="button"
                     className="auth-linklike recovery-disable"
@@ -574,7 +726,11 @@ export default function RecoveryAlertsCard({
           </div>
           {removing ? (
             <form className="recovery-remove" onSubmit={remove}>
-              <h3>
+              <h3
+                ref={removalHeadingRef}
+                tabIndex={-1}
+                className="recovery-focus-target"
+              >
                 Disable alerts for {removing.label || 'this smart account'}?
               </h3>
               <AccountAddress address={removing.account} />
@@ -586,6 +742,7 @@ export default function RecoveryAlertsCard({
                 This stops its emails only. Any pending recovery remains
                 on-chain. Confirm with your Sysnode password.
               </p>
+              {renderError('remove')}
               <div className="auth-field">
                 <label className="auth-label" htmlFor="recovery-password">
                   Current Sysnode password
@@ -660,30 +817,58 @@ export default function RecoveryAlertsCard({
                   An off-chain signature links this account address to your
                   Sysnode email. No private keys or funds are sent.
                 </p>
+                {renderError('enroll')}
+                {user && !user.emailVerified && (
+                  <div className="auth-alert auth-alert--warning recovery-verification">
+                    <p>
+                      {verificationChecked
+                        ? 'Your email is not verified yet.'
+                        : 'Verify your email before linking a smart account.'}{' '}
+                      Open the verification link sent to{' '}
+                      <strong>{user.email}</strong>, then check again here.
+                    </p>
+                    <button
+                      type="button"
+                      className="auth-linklike"
+                      disabled={!!phase}
+                      onClick={checkVerification}
+                    >
+                      {phase === 'checking-email'
+                        ? phaseLabel
+                        : 'Check verification status'}
+                    </button>
+                  </div>
+                )}
                 {wallets.length > 0 ? (
                   <>
-                    <div className="auth-field">
-                      <label className="auth-label" htmlFor="recovery-wallet">
-                        Wallet
-                      </label>
-                      <select
-                        id="recovery-wallet"
-                        className="auth-input"
-                        value={walletId}
-                        onChange={(event) => {
-                          generation.current += 1;
-                          setWalletId(event.target.value);
-                          setError(null);
-                        }}
-                        disabled={!!phase}
-                      >
-                        {wallets.map((item) => (
-                          <option key={item.id} value={item.id}>
-                            {item.name}
-                          </option>
-                        ))}
-                      </select>
-                    </div>
+                    {wallets.length > 1 ? (
+                      <div className="auth-field">
+                        <label className="auth-label" htmlFor="recovery-wallet">
+                          Wallet
+                        </label>
+                        <select
+                          id="recovery-wallet"
+                          className="auth-input"
+                          value={walletId}
+                          onChange={(event) => {
+                            generation.current += 1;
+                            setWalletId(event.target.value);
+                            setError(null);
+                          }}
+                          disabled={!!phase}
+                        >
+                          {wallets.map((item) => (
+                            <option key={item.id} value={item.id}>
+                              {item.name}
+                            </option>
+                          ))}
+                        </select>
+                      </div>
+                    ) : (
+                      <p className="recovery-network">
+                        Wallet: {wallets[0].name}
+                      </p>
+                    )}
                     <button
                       type="button"
                       className="button button--ghost"
@@ -732,28 +917,35 @@ export default function RecoveryAlertsCard({
                       {chain && chain.name}
                       {chain && chain.testnet ? ' · Testnet' : ''}
                     </p>
-                    <div className="auth-field">
-                      <label className="auth-label" htmlFor="recovery-account">
-                        Smart account
-                      </label>
-                      <select
-                        id="recovery-account"
-                        className="auth-input recovery-account-select"
-                        value={account}
-                        disabled={!!phase}
-                        onChange={(event) => {
-                          generation.current += 1;
-                          setAccount(event.target.value);
-                          setNotice(null);
-                        }}
-                      >
-                        {selection.accounts.map((address) => (
-                          <option key={address} value={address}>
-                            {address}
-                          </option>
-                        ))}
-                      </select>
-                    </div>
+                    {selection.accounts.length > 1 ? (
+                      <div className="auth-field">
+                        <label
+                          className="auth-label"
+                          htmlFor="recovery-account"
+                        >
+                          Smart account
+                        </label>
+                        <select
+                          id="recovery-account"
+                          className="auth-input recovery-account-select"
+                          value={account}
+                          disabled={!!phase}
+                          onChange={(event) => {
+                            generation.current += 1;
+                            setAccount(event.target.value);
+                            setNotice(null);
+                          }}
+                        >
+                          {selection.accounts.map((address) => (
+                            <option key={address} value={address}>
+                              {address}
+                            </option>
+                          ))}
+                        </select>
+                      </div>
+                    ) : (
+                      <p className="auth-label">Smart account</p>
+                    )}
                     <AccountAddress address={account} />
                     <div className="auth-field">
                       <label className="auth-label" htmlFor="recovery-label">
diff --git a/src/components/RecoveryAlertsCard.test.js b/src/components/RecoveryAlertsCard.test.js
index 46adeec..d555a98 100644
--- a/src/components/RecoveryAlertsCard.test.js
+++ b/src/components/RecoveryAlertsCard.test.js
@@ -7,7 +7,12 @@ import { AuthProvider } from '../context/AuthContext';
 
 const ACCOUNT = `0x${'12'.repeat(20)}`;
 const CHAIN_ID = 57057;
-const CHAIN = { chainId: CHAIN_ID, name: 'zkTanenbaum', testnet: true, recoveryModule: `0x${'45'.repeat(20)}` };
+const CHAIN = {
+  chainId: CHAIN_ID,
+  name: 'zkTanenbaum',
+  testnet: true,
+  recoveryModule: `0x${'45'.repeat(20)}`,
+};
 const SIGNATURE = `0x${'ab'.repeat(24000)}`;
 const SUBSCRIPTION = {
   id: 1,
@@ -33,6 +38,9 @@ function setup({
   open = true,
   hasWallet = true,
   totp = false,
+  emailVerified = true,
+  accounts = [ACCOUNT],
+  walletNames = ['Pali'],
   service: overrides = {},
 } = {}) {
   const handlers = {};
@@ -42,7 +50,7 @@ function setup({
         ? `0x${CHAIN_ID.toString(16)}`
         : method === 'personal_sign'
         ? SIGNATURE
-        : [ACCOUNT]
+        : accounts
     ),
     on: jest.fn((name, fn) => {
       handlers[name] = fn;
@@ -50,7 +58,15 @@ function setup({
     removeListener: jest.fn(),
   };
   const discover = jest.fn((cb) => {
-    cb(hasWallet ? [{ id: 'pali', name: 'Pali', provider }] : []);
+    cb(
+      hasWallet
+        ? walletNames.map((name, index) => ({
+            id: `wallet-${index}`,
+            name,
+            provider: index === 0 ? provider : { ...provider },
+          }))
+        : []
+    );
     return () => {};
   });
   const service = {
@@ -71,7 +87,7 @@ function setup({
       user: {
         id: 1,
         email: 'qa@example.test',
-        emailVerified: true,
+        emailVerified,
         totpEnabled: totp,
       },
     }),
@@ -275,10 +291,14 @@ test('a successful disable removes the active card even when refresh fails', asy
 });
 
 test('a failed status refresh preserves history but no longer claims active monitoring', async () => {
-  const { service } = setup({ subscriptions: [{
-    ...SUBSCRIPTION,
-    monitoring: { status: 'active', lastCheckedAt: Date.now() },
-  }] });
+  const { service } = setup({
+    subscriptions: [
+      {
+        ...SUBSCRIPTION,
+        monitoring: { status: 'active', lastCheckedAt: Date.now() },
+      },
+    ],
+  });
   await screen.findByText('Monitoring active');
   service.subscriptions.mockRejectedValue({ code: 'network_error' });
   await click(screen.getByRole('button', { name: 'Refresh status' }));
@@ -288,17 +308,27 @@ test('a failed status refresh preserves history but no longer claims active moni
 });
 
 test('an old module subscription does not block enrolling the current module', async () => {
-  setup({ subscriptions: [{ ...SUBSCRIPTION, recoveryModule: `0x${'67'.repeat(20)}` }] });
+  setup({
+    subscriptions: [
+      { ...SUBSCRIPTION, recoveryModule: `0x${'67'.repeat(20)}` },
+    ],
+  });
   await screen.findByText('Savings');
   await click(screen.getByRole('button', { name: 'Connect wallet' }));
-  expect(await screen.findByRole('button', { name: 'Enable recovery alerts' })).toBeEnabled();
+  expect(
+    await screen.findByRole('button', { name: 'Enable recovery alerts' })
+  ).toBeEnabled();
 });
 
 test('an old active snapshot is not displayed as current monitoring', async () => {
-  setup({ subscriptions: [{
-    ...SUBSCRIPTION,
-    monitoring: { status: 'active', lastCheckedAt: Date.now() - 120000 },
-  }] });
+  setup({
+    subscriptions: [
+      {
+        ...SUBSCRIPTION,
+        monitoring: { status: 'active', lastCheckedAt: Date.now() - 120000 },
+      },
+    ],
+  });
   expect(await screen.findByText('Monitoring delayed')).toBeInTheDocument();
   expect(screen.queryByText('Monitoring active')).not.toBeInTheDocument();
 });
@@ -341,3 +371,278 @@ test('no wallet and load failure show retryable honest states', async () => {
   ).toBeInTheDocument();
   expect(screen.getByRole('button', { name: 'Refresh status' })).toBeEnabled();
 });
+
+test('a single wallet and account keep identity visible without redundant pickers', async () => {
+  setup();
+  await screen.findByText(/No smart accounts linked yet/);
+  await screen.findByText('Wallet: Pali');
+  expect(screen.queryByRole('combobox')).not.toBeInTheDocument();
+  await click(screen.getByRole('button', { name: 'Connect wallet' }));
+  await screen.findByText('Smart account');
+  expect(screen.getByText(ACCOUNT)).toBeVisible();
+  expect(screen.queryByRole('combobox')).not.toBeInTheDocument();
+});
+
+test('multiple wallets and accounts remain explicitly selectable', async () => {
+  const second = `0x${'34'.repeat(20)}`;
+  setup({ walletNames: ['Pali', 'Other wallet'], accounts: [ACCOUNT, second] });
+  await screen.findByText(/No smart accounts linked yet/);
+  expect(await screen.findByLabelText('Wallet')).toBeEnabled();
+  await click(screen.getByRole('button', { name: 'Connect wallet' }));
+  const account = await screen.findByLabelText('Smart account');
+  fireEvent.change(account, { target: { value: second } });
+  expect(account).toHaveValue(second);
+  expect(
+    screen.getByRole('button', { name: `Copy account address ${second}` })
+  ).toBeInTheDocument();
+});
+
+test('unverified email explains the gate and checks the existing account without signing', async () => {
+  const { authService, provider, service } = setup({ emailVerified: false });
+  await screen.findByText(/Verify your email before linking/);
+  expect(screen.getByRole('button', { name: 'Connect wallet' })).toBeDisabled();
+  authService.me.mockResolvedValue({
+    user: { id: 1, email: 'qa@example.test', emailVerified: true },
+  });
+  await click(
+    screen.getByRole('button', { name: 'Check verification status' })
+  );
+  expect(
+    await screen.findByRole('button', { name: 'Connect wallet' })
+  ).toBeEnabled();
+  expect(screen.getByText(/Email verified. You can now link/)).toBeVisible();
+  expect(provider.request).not.toHaveBeenCalled();
+  expect(service.challenge).not.toHaveBeenCalled();
+});
+
+test('an unverified recheck keeps the explanation and does not claim verification', async () => {
+  setup({ emailVerified: false });
+  await click(
+    await screen.findByRole('button', { name: 'Check verification status' })
+  );
+  expect(
+    await screen.findByText(/Your email is not verified yet/)
+  ).toBeVisible();
+  expect(screen.getByRole('button', { name: 'Connect wallet' })).toBeDisabled();
+});
+
+test.each([
+  { status: 503, code: 'http_error' },
+  { status: 0, code: 'network_error' },
+])(
+  'verification $status failure keeps the real authenticated card with focused retryable error',
+  async (failure) => {
+    const { authService, provider } = setup({ emailVerified: false });
+    await screen.findByRole('button', { name: 'Check verification status' });
+    authService.me.mockRejectedValueOnce(failure);
+    await click(
+      screen.getByRole('button', { name: 'Check verification status' })
+    );
+    const error = await screen.findByRole('alert');
+    expect(error).toHaveFocus();
+    expect(error).toBeVisible();
+    expect(
+      screen.getByRole('button', { name: 'Check verification status' })
+    ).toBeEnabled();
+    expect(
+      screen.getByRole('button', { name: 'Connect wallet' })
+    ).toBeDisabled();
+    authService.me.mockResolvedValueOnce({
+      user: { id: 1, email: 'qa@example.test', emailVerified: true },
+    });
+    await click(
+      screen.getByRole('button', { name: 'Check verification status' })
+    );
+    expect(
+      screen.getByRole('button', { name: 'Connect wallet' })
+    ).toBeEnabled();
+    expect(provider.request).not.toHaveBeenCalled();
+  }
+);
+
+test('only nonurgent terminal history collapses, while pending deadlines and unknown states remain visible', async () => {
+  setup({
+    subscriptions: [
+      {
+        ...SUBSCRIPTION,
+        pending: [
+          {
+            operationId: 'pending',
+            status: 'pending',
+            executableAt: 1792700000,
+          },
+          {
+            operationId: 'canceled',
+            status: 'canceled',
+            executableAt: 1792600000,
+          },
+          {
+            operationId: 'unknown',
+            status: 'unknown',
+            executableAt: 1792500000,
+          },
+        ],
+      },
+    ],
+  });
+  expect(await screen.findByText('Recovery pending')).toBeVisible();
+  expect(screen.getByText(/Can execute from/)).toBeVisible();
+  expect(screen.getByText('Recovery status unavailable')).toBeVisible();
+  const past = screen.getByText('Recovery canceled or invalidated');
+  expect(past).not.toBeVisible();
+  await click(screen.getByText('Past recovery activity (1)'));
+  expect(past).toBeVisible();
+  await click(screen.getByText('How to review in Pali'));
+  expect(screen.getByText('Disable guardian recovery')).toBeVisible();
+  expect(
+    screen.getByRole('link', { name: 'Read the recovery guide' })
+  ).toHaveAttribute(
+    'href',
+    'https://docs.paliwallet.com/docs/users/recovery-and-backups'
+  );
+});
+
+test('executed recovery stays visible and never offers pending-recovery cancellation instructions', async () => {
+  setup({
+    subscriptions: [
+      {
+        ...SUBSCRIPTION,
+        pending: [
+          {
+            operationId: 'executed',
+            status: 'executed',
+            executableAt: 1792700000,
+          },
+          {
+            operationId: 'canceled',
+            status: 'canceled',
+            executableAt: 1792600000,
+          },
+        ],
+      },
+    ],
+  });
+  expect(await screen.findByText('Recovery executed')).toBeVisible();
+  expect(
+    screen.getByText(/Recovery has executed. Review this account/)
+  ).toBeVisible();
+  expect(
+    screen.getByText('Recovery canceled or invalidated')
+  ).not.toBeVisible();
+  await click(screen.getByText('How to review in Pali'));
+  expect(
+    screen.queryByText('Disable guardian recovery')
+  ).not.toBeInTheDocument();
+  expect(screen.getByText(/Disabling emails cannot undo it/)).toBeVisible();
+});
+
+test.each(['enroll', 'remove'])(
+  'a failed %s action focuses its local error without animated scrolling',
+  async (operation) => {
+    const original = HTMLElement.prototype.scrollIntoView;
+    const scroll = jest.fn();
+    HTMLElement.prototype.scrollIntoView = scroll;
+    try {
+      const { provider } = setup({
+        subscriptions: operation === 'remove' ? [SUBSCRIPTION] : [],
+        service: {
+          remove: jest.fn().mockRejectedValue({ code: 'invalid_credentials' }),
+        },
+      });
+      await screen.findByRole('button', { name: 'Refresh status' });
+      if (operation === 'remove') {
+        await click(
+          await screen.findByRole('button', { name: 'Disable these alerts…' })
+        );
+        await type(
+          screen.getByLabelText('Current Sysnode password'),
+          'wrong-password'
+        );
+        scroll.mockClear();
+        await click(
+          screen.getByRole('button', { name: 'Disable alerts', exact: true })
+        );
+      } else {
+        await screen.findByText(/No smart accounts linked yet/);
+        await click(
+          await screen.findByRole('button', { name: 'Connect wallet' })
+        );
+        provider.request.mockImplementation(async ({ method }) => {
+          if (method === 'personal_sign') throw { code: 4001 };
+          return method === 'eth_chainId'
+            ? `0x${CHAIN_ID.toString(16)}`
+            : [ACCOUNT];
+        });
+        await click(
+          await screen.findByRole('button', { name: 'Enable recovery alerts' })
+        );
+      }
+      const error = await screen.findByRole('alert');
+      expect(error).toHaveFocus();
+      expect(error.closest('form')).toHaveClass(
+        operation === 'remove' ? 'recovery-remove' : 'recovery-enroll'
+      );
+      expect(scroll).toHaveBeenLastCalledWith({
+        block: 'nearest',
+        behavior: 'instant',
+      });
+    } finally {
+      HTMLElement.prototype.scrollIntoView = original;
+    }
+  }
+);
+
+test('background status failure and typing never steal focus or scroll', async () => {
+  const original = HTMLElement.prototype.scrollIntoView;
+  const scroll = jest.fn();
+  HTMLElement.prototype.scrollIntoView = scroll;
+  try {
+    const { service } = setup();
+    await screen.findByText(/No smart accounts linked yet/);
+    await click(await screen.findByRole('button', { name: 'Connect wallet' }));
+    const label = screen.getByLabelText('Account label (optional)');
+    label.focus();
+    await type(label, 'My savings');
+    service.subscriptions.mockRejectedValue({ code: 'network_error' });
+    await act(async () => {
+      document.dispatchEvent(new Event('visibilitychange'));
+    });
+    expect(await screen.findByRole('alert')).toHaveTextContent(
+      /could not reach Sysnode/
+    );
+    expect(label).toHaveFocus();
+    expect(scroll).not.toHaveBeenCalled();
+  } finally {
+    HTMLElement.prototype.scrollIntoView = original;
+  }
+});
+
+test('a rejected pending signature reopens enrollment details before focusing its error', async () => {
+  const { provider, service } = setup();
+  await screen.findByText(/No smart accounts linked yet/);
+  await click(screen.getByRole('button', { name: 'Connect wallet' }));
+  let rejectSignature;
+  provider.request.mockImplementation(async ({ method }) => {
+    if (method === 'personal_sign')
+      return new Promise((_resolve, reject) => {
+        rejectSignature = reject;
+      });
+    return method === 'eth_chainId' ? `0x${CHAIN_ID.toString(16)}` : [ACCOUNT];
+  });
+  await click(screen.getByRole('button', { name: 'Enable recovery alerts' }));
+  await waitFor(() => expect(rejectSignature).toBeDefined());
+  expect(
+    screen.getByRole('button', { name: 'Collapse recovery alerts' })
+  ).toBeDisabled();
+  const disclosure = screen
+    .getByText('Link a smart account')
+    .closest('details');
+  disclosure.open = false;
+  await act(async () => {
+    rejectSignature({ code: 4001 });
+  });
+  const error = await screen.findByRole('alert');
+  expect(error).toBeVisible();
+  expect(error).toHaveFocus();
+  expect(service.subscribe).not.toHaveBeenCalled();
+});
diff --git a/src/context/AuthContext.js b/src/context/AuthContext.js
index c880482..fe690e6 100644
--- a/src/context/AuthContext.js
+++ b/src/context/AuthContext.js
@@ -136,25 +136,63 @@ export function AuthProvider({ children, authService = defaultAuthService }) {
     fn();
   }, []);
 
-  const refresh = useCallback(async () => {
-    const myGen = nextGen();
-    try {
-      const { user: u } = await authService.me();
-      safeSet(() => {
-        setUser(u);
-        commitStatus(AUTHENTICATED);
-      }, myGen);
-      return u;
-    } catch (err) {
-      safeSet(() => {
-        setUser(null);
-        commitStatus(ANONYMOUS);
-      }, myGen);
-      // 401 is expected (no session) — don't re-throw that.
-      if (err.status === 401) return null;
-      throw err;
-    }
-  }, [authService, safeSet, nextGen, commitStatus]);
+  const refresh = useCallback(
+    async ({ preserveSessionOnTransientError = false } = {}) => {
+      const preserve = preserveSessionOnTransientError === true;
+      // Profile-only checks must not compete with a sign-out already in flight.
+      if (preserve && logoutPendingRef.current) return null;
+      const wasAuthenticated = statusRef.current === AUTHENTICATED;
+      const myGen = nextGen();
+      try {
+        const { user: u } = await authService.me();
+        if (
+          preserve &&
+          (!mountedRef.current ||
+            myGen !== genRef.current ||
+            logoutPendingRef.current)
+        )
+          return null;
+        safeSet(() => {
+          setUser(u);
+          commitStatus(AUTHENTICATED);
+        }, myGen);
+        return u;
+      } catch (err) {
+        if (
+          preserve &&
+          (!mountedRef.current ||
+            myGen !== genRef.current ||
+            logoutPendingRef.current)
+        )
+          return null;
+        const status = Number(err && err.status);
+        const expired =
+          err && (status === 401 || status === 403 || err.code === 'unauthorized');
+        const transient =
+          !expired &&
+          err &&
+          ((err.code === 'network_error' &&
+            (status === 0 || !Number.isFinite(status))) ||
+            status === 408 ||
+            status === 429 ||
+            (status >= 500 && status <= 599));
+        // Opt-in only: a failed read does not prove an established session ended.
+        // Bootstrap, ordinary refreshes and all non-transient/auth failures keep
+        // their original fail-closed behavior. The caller still receives the
+        // transient error so it can show a focused, retryable explanation.
+        if (!(preserve && wasAuthenticated && transient)) {
+          safeSet(() => {
+            setUser(null);
+            commitStatus(ANONYMOUS);
+          }, myGen);
+        }
+        // 401 is expected (no session) — don't re-throw that.
+        if (err.status === 401) return null;
+        throw err;
+      }
+    },
+    [authService, safeSet, nextGen, commitStatus]
+  );
 
   useEffect(() => {
     refresh().catch(() => {
diff --git a/src/context/AuthContext.test.js b/src/context/AuthContext.test.js
index c39c8ae..da37a06 100644
--- a/src/context/AuthContext.test.js
+++ b/src/context/AuthContext.test.js
@@ -59,6 +59,196 @@ function makeService(overrides = {}) {
   };
 }
 
+function captureAuth(service) {
+  let current;
+  function Probe() {
+    current = useAuth();
+    return <span>{current.status}</span>;
+  }
+  render(
+    <AuthProvider authService={service}>
+      <Probe />
+    </AuthProvider>
+  );
+  return () => current;
+}
+
+test.each([
+  { code: 'network_error', status: 0 },
+  { code: 'http_error', status: 503 },
+  { code: 'http_error', status: 408 },
+  { code: 'http_error', status: 429 },
+])(
+  'opt-in profile refresh preserves authenticated state on $code/$status and permits a retry',
+  async (failure) => {
+    const oldUser = { id: 1, email: 'user@example.test', emailVerified: false };
+    const service = makeService({
+      me: jest.fn().mockResolvedValue({ user: oldUser }),
+    });
+    const auth = captureAuth(service);
+    await waitFor(() => expect(auth().isAuthenticated).toBe(true));
+    service.me.mockRejectedValueOnce(failure);
+    await act(async () => {
+      await expect(
+        auth().refresh({ preserveSessionOnTransientError: true })
+      ).rejects.toBe(failure);
+    });
+    expect(auth().isAuthenticated).toBe(true);
+    expect(auth().user).toEqual(oldUser);
+    service.me.mockResolvedValueOnce({
+      user: { ...oldUser, emailVerified: true },
+    });
+    await act(async () => {
+      await auth().refresh({ preserveSessionOnTransientError: true });
+    });
+    expect(auth().user.emailVerified).toBe(true);
+  }
+);
+
+test.each([
+  { code: 'unauthorized', status: 401 },
+  { code: 'forbidden', status: 403 },
+  { code: 'network_error', status: 401 },
+  { code: 'network_error', status: 403 },
+  { code: 'network_error', status: 400 },
+  { code: 'unauthorized', status: 503 },
+])(
+  'opt-in profile refresh still clears real auth or non-transient failure $code/$status',
+  async (failure) => {
+    const service = makeService({
+      me: jest
+        .fn()
+        .mockResolvedValue({ user: { id: 1, email: 'user@example.test' } }),
+    });
+    const auth = captureAuth(service);
+    await waitFor(() => expect(auth().isAuthenticated).toBe(true));
+    service.me.mockRejectedValueOnce(failure);
+    await act(async () => {
+      await auth()
+        .refresh({ preserveSessionOnTransientError: true })
+        .catch(() => {});
+    });
+    expect(auth().status).toBe('anonymous');
+    expect(auth().user).toBeNull();
+  }
+);
+
+test('default refresh still clears authenticated state on a transient error', async () => {
+  const service = makeService({
+    me: jest.fn().mockResolvedValue({ user: { id: 1 } }),
+  });
+  const auth = captureAuth(service);
+  await waitFor(() => expect(auth().isAuthenticated).toBe(true));
+  service.me.mockRejectedValueOnce({ status: 503 });
+  await act(async () => {
+    await auth()
+      .refresh()
+      .catch(() => {});
+  });
+  expect(auth().status).toBe('anonymous');
+});
+
+test.each([1, 2])(
+  'opt-in refresh ignores an old response after newer login session for user%d',
+  async (nextId) => {
+    const oldUser = { id: 1, email: 'old@example.test', emailVerified: false };
+    const nextUser = {
+      id: nextId,
+      email: 'new@example.test',
+      emailVerified: true,
+    };
+    const service = makeService({
+      me: jest.fn().mockResolvedValue({ user: oldUser }),
+      login: jest.fn().mockResolvedValue({ user: nextUser }),
+    });
+    const auth = captureAuth(service);
+    await waitFor(() => expect(auth().isAuthenticated).toBe(true));
+    let finish;
+    service.me.mockImplementationOnce(
+      () =>
+        new Promise((resolve) => {
+          finish = resolve;
+        })
+    );
+    let pending;
+    await act(async () => {
+      pending = auth().refresh({ preserveSessionOnTransientError: true });
+    });
+    service.me.mockResolvedValueOnce({ user: nextUser });
+    await act(async () => {
+      await auth().login({ email: 'new@example.test', password: 'pw' });
+    });
+    await act(async () => {
+      finish({ user: oldUser });
+      expect(await pending).toBeNull();
+    });
+    expect(auth().user).toEqual(nextUser);
+  }
+);
+
+test('opt-in refresh cannot restore a user during or after logout', async () => {
+  const oldUser = { id: 1, email: 'old@example.test' };
+  let finishLogout;
+  const service = makeService({
+    me: jest.fn().mockResolvedValue({ user: oldUser }),
+    logout: jest.fn().mockImplementation(
+      () =>
+        new Promise((resolve) => {
+          finishLogout = resolve;
+        })
+    ),
+  });
+  const auth = captureAuth(service);
+  await waitFor(() => expect(auth().isAuthenticated).toBe(true));
+  let finishRefresh;
+  service.me.mockImplementationOnce(
+    () =>
+      new Promise((resolve) => {
+        finishRefresh = resolve;
+      })
+  );
+  let pending;
+  let logout;
+  await act(async () => {
+    pending = auth().refresh({ preserveSessionOnTransientError: true });
+    logout = auth().logout();
+  });
+  await act(async () => {
+    finishRefresh({ user: oldUser });
+    expect(await pending).toBeNull();
+  });
+  expect(service.me).toHaveBeenCalledTimes(2);
+  await act(async () => {
+    expect(
+      await auth().refresh({ preserveSessionOnTransientError: true })
+    ).toBeNull();
+  });
+  expect(service.me).toHaveBeenCalledTimes(2);
+  await act(async () => {
+    finishLogout();
+    await logout;
+  });
+  expect(auth().user).toBeNull();
+});
+
+test('a stale opt-in 401 cannot sign out a newer successful login', async () => {
+  const nextUser = { id: 2, email: 'new@example.test', emailVerified: true };
+  const service = makeService({
+    me: jest.fn().mockResolvedValue({ user: { id: 1 } }),
+    login: jest.fn().mockResolvedValue({ user: nextUser }),
+  });
+  const auth = captureAuth(service);
+  await waitFor(() => expect(auth().isAuthenticated).toBe(true));
+  let rejectRefresh;
+  service.me.mockImplementationOnce(() => new Promise((_resolve, reject) => { rejectRefresh = reject; }));
+  let pending;
+  await act(async () => { pending = auth().refresh({ preserveSessionOnTransientError: true }); });
+  service.me.mockResolvedValueOnce({ user: nextUser });
+  await act(async () => { await auth().login({ email: 'new@example.test', password: 'pw' }); });
+  await act(async () => { rejectRefresh({ status: 401, code: 'unauthorized' }); expect(await pending).toBeNull(); });
+  expect(auth().user).toEqual(nextUser);
+});
+
 test('starts in booting, transitions to anonymous when /me returns 401', async () => {
   const service = makeService();
   render(
diff --git a/tests/browser/recovery-alerts.spec.cjs b/tests/browser/recovery-alerts.spec.cjs
index eb311e5..4fa91c1 100644
--- a/tests/browser/recovery-alerts.spec.cjs
+++ b/tests/browser/recovery-alerts.spec.cjs
@@ -9,7 +9,17 @@ const CHAIN = {
 };
 const signature = `0x${'ab'.repeat(24000)}`;
 
-async function fixtures(page, { monitored = false, degraded = false } = {}) {
+async function fixtures(
+  page,
+  {
+    monitored = false,
+    degraded = false,
+    emailVerified = true,
+    subscribeError = null,
+    withHistory = false,
+    deferSignature = false,
+  } = {}
+) {
   let subscriptions = monitored
     ? [
         {
@@ -31,13 +41,24 @@ async function fixtures(page, { monitored = false, degraded = false } = {}) {
               expiresAt: Math.floor(Date.now() / 1000) + 864000,
               status: 'pending',
             },
+            ...(withHistory
+              ? [
+                  {
+                    operationId: `0x${'bc'.repeat(32)}`,
+                    executableAt: Math.floor(Date.now() / 1000) - 3600,
+                    status: 'canceled',
+                  },
+                ]
+              : []),
           ],
         },
       ]
     : [];
   const writes = [];
+  let verified = emailVerified;
+  let verificationFailure = null;
   await page.addInitScript(
-    ({ ACCOUNT, signature }) => {
+    ({ ACCOUNT, signature, deferSignature }) => {
       const listeners = new Map();
       window.__walletCalls = [];
       const provider = {
@@ -54,28 +75,43 @@ async function fixtures(page, { monitored = false, degraded = false } = {}) {
           if (method === 'eth_chainId') return '0xdee1';
           if (method === 'eth_accounts' || method === 'eth_requestAccounts')
             return [ACCOUNT];
-          if (method === 'personal_sign') return signature;
+          if (method === 'personal_sign') {
+            if (deferSignature)
+              return new Promise((_resolve, reject) => {
+                window.__rejectRecoverySignature = () => reject({ code: 4001 });
+              });
+            return signature;
+          }
           throw new Error(`Unexpected wallet method: ${method}`);
         },
       };
       window.ethereum = provider;
     },
-    { ACCOUNT, signature }
+    { ACCOUNT, signature, deferSignature }
   );
-  await page.route('**/auth/me', (route) =>
-    route.fulfill({
+  await page.route('**/auth/me', (route) => {
+    if (verificationFailure !== null) {
+      const failure = verificationFailure;
+      verificationFailure = null;
+      if (failure === 'network') return route.abort('failed');
+      return route.fulfill({
+        status: failure,
+        json: { error: failure === 401 ? 'unauthorized' : 'http_error' },
+      });
+    }
+    return route.fulfill({
       json: {
         user: {
           id: 1,
           email: 'recovery.alerts.qa@example.test',
-          emailVerified: true,
+          emailVerified: verified,
           saltV: 'ab'.repeat(32),
           notificationPrefs: {},
           totpEnabled: true,
         },
       },
-    })
-  );
+    });
+  });
   await page.route('**/vault', (route) =>
     route.fulfill({ json: { empty: true } })
   );
@@ -106,6 +142,8 @@ async function fixtures(page, { monitored = false, degraded = false } = {}) {
         signature,
         label: 'Savings',
       });
+      if (subscribeError)
+        return route.fulfill({ status: 400, json: { error: subscribeError } });
       const subscription = {
         id: 1,
         account: ACCOUNT,
@@ -124,7 +162,15 @@ async function fixtures(page, { monitored = false, degraded = false } = {}) {
       });
     throw new Error(`Unexpected API: ${path}`);
   });
-  return { writes };
+  return {
+    writes,
+    verifyEmail: () => {
+      verified = true;
+    },
+    failVerification: (failure) => {
+      verificationFailure = failure;
+    },
+  };
 }
 
 async function noHorizontalOverflow(page) {
@@ -153,6 +199,7 @@ test('320px recovery enrollment uses standard wallet signing and shows catch-up
   await page
     .getByRole('button', { name: 'Connect wallet', exact: true })
     .click();
+  await expect(page.getByRole('combobox')).toHaveCount(0);
   await page.getByLabel('Account label (optional)').fill('Savings');
   await page
     .getByRole('button', { name: 'Enable recovery alerts', exact: true })
@@ -172,14 +219,81 @@ test('320px recovery enrollment uses standard wallet signing and shows catch-up
     false
   );
   await noHorizontalOverflow(page);
+  await page.locator('#recovery-alerts').screenshot({
+    path: testInfo.outputPath('recovery-enrollment-320.png'),
+    style: '.site-header { visibility: hidden !important; }',
+  });
+});
+
+test('a signature rejection reveals a collapsed enrollment and focuses its error', async ({
+  page,
+}) => {
+  await page.setViewportSize({ width: 390, height: 500 });
+  const fixture = await fixtures(page, { deferSignature: true });
+  await page.goto('/account#recovery-alerts');
   await page
-    .locator('#recovery-alerts')
-    .screenshot({
-      path: testInfo.outputPath('recovery-enrollment-320.png'),
-      style: '.site-header { visibility: hidden !important; }',
-    });
+    .getByRole('button', { name: 'Connect wallet', exact: true })
+    .click();
+  await page
+    .getByRole('button', { name: 'Enable recovery alerts', exact: true })
+    .click();
+  await expect(
+    page.getByRole('button', { name: 'Confirm in wallet…' })
+  ).toBeVisible();
+  await expect(
+    page.getByRole('button', { name: 'Collapse recovery alerts' })
+  ).toBeDisabled();
+  await page.getByText('Link a smart account', { exact: true }).click();
+  await expect(page.locator('.recovery-enroll')).toBeHidden();
+  await page.evaluate(() => window.__rejectRecoverySignature());
+  await expect(page.getByRole('alert')).toHaveText(
+    /signature request was canceled/
+  );
+  await expect(page.getByRole('alert')).toBeVisible();
+  await expect(page.getByRole('alert')).toBeFocused();
+  expect(fixture.writes).toHaveLength(1);
 });
 
+for (const failure of [503, 'network', 401]) {
+  test(`verification ${failure} uses the real auth guard and preserves only transient sessions`, async ({
+    page,
+  }, testInfo) => {
+    await page.setViewportSize({ width: 390, height: 500 });
+    const fixture = await fixtures(page, { emailVerified: false });
+    await page.goto('/account#recovery-alerts');
+    await expect(
+      page.getByRole('button', { name: 'Check verification status' })
+    ).toBeVisible();
+    fixture.failVerification(failure);
+    await page
+      .getByRole('button', { name: 'Check verification status' })
+      .click();
+    if (failure === 401) {
+      await expect(page).toHaveURL(/\/login/);
+      await expect(page.locator('#recovery-alerts')).toHaveCount(0);
+    } else {
+      await expect(page).toHaveURL(/\/account#recovery-alerts/);
+      await expect(page.getByRole('alert')).toBeFocused();
+      await expect(
+        page.getByRole('button', { name: 'Check verification status' })
+      ).toBeEnabled();
+      await noHorizontalOverflow(page);
+      await page.screenshot({
+        path: testInfo.outputPath(`recovery-verification-error-${failure}.png`),
+      });
+      fixture.verifyEmail();
+      await page
+        .getByRole('button', { name: 'Check verification status' })
+        .click();
+      await expect(
+        page.getByRole('button', { name: 'Connect wallet', exact: true })
+      ).toBeEnabled();
+    }
+    expect(fixture.writes).toHaveLength(0);
+    expect(await page.evaluate(() => window.__walletCalls)).toEqual([]);
+  });
+}
+
 test('small-window pending recovery and disable confirmation remain readable with correct account and network', async ({
   page,
 }, testInfo) => {
@@ -192,12 +306,10 @@ test('small-window pending recovery and disable confirmation remain readable wit
   await expect(
     page.getByText('Recovery pending', { exact: true })
   ).toBeVisible();
-  await page
-    .locator('#recovery-alerts')
-    .screenshot({
-      path: testInfo.outputPath('recovery-pending-360.png'),
-      style: '.site-header { visibility: hidden !important; }',
-    });
+  await page.locator('#recovery-alerts').screenshot({
+    path: testInfo.outputPath('recovery-pending-360.png'),
+    style: '.site-header { visibility: hidden !important; }',
+  });
   await page.getByRole('button', { name: 'Disable these alerts…' }).click();
   await expect(
     page.getByRole('heading', {
@@ -212,14 +324,126 @@ test('small-window pending recovery and disable confirmation remain readable wit
   await expect(page.getByRole('alert')).toHaveText(
     /current Sysnode password is incorrect/
   );
+  await expect(page.getByRole('alert')).toBeFocused();
   expect(fixture.writes.at(-1).body.code).toBe('123456');
   await noHorizontalOverflow(page);
-  await page
-    .locator('.recovery-remove')
-    .screenshot({
-      path: testInfo.outputPath('recovery-disable-360.png'),
-      style: '.site-header { visibility: hidden !important; }',
-    });
+  await page.locator('.recovery-remove').screenshot({
+    path: testInfo.outputPath('recovery-disable-360.png'),
+    style: '.site-header { visibility: hidden !important; }',
+  });
   await page.getByRole('button', { name: 'Keep alerts' }).click();
   await expect(page.getByLabel('Current Sysnode password')).toHaveCount(0);
 });
+
+for (const width of [320, 390]) {
+  test(`${width}px disable errors stay beside the password confirmation and in view`, async ({
+    page,
+  }, testInfo) => {
+    await page.setViewportSize({ width, height: 500 });
+    await page.emulateMedia({ reducedMotion: 'reduce' });
+    const fixture = await fixtures(page, { monitored: true });
+    await page.goto('/account#recovery-alerts');
+    await page.getByRole('button', { name: 'Disable these alerts…' }).click();
+    await page.getByLabel('Current Sysnode password').fill('wrong-password');
+    await page.getByLabel('Authenticator code').fill('123456');
+    await page
+      .getByRole('button', { name: 'Disable alerts', exact: true })
+      .click();
+    const error = page.getByRole('alert');
+    await expect(error).toHaveText(/current Sysnode password is incorrect/);
+    await expect(error).toBeFocused();
+    await expect
+      .poll(async () => {
+        const bounds = await error.boundingBox();
+        return bounds.y >= 70 && bounds.y + bounds.height <= 500;
+      })
+      .toBe(true);
+    expect(fixture.writes).toHaveLength(1);
+    expect(fixture.writes[0].path).toBe('/api/recovery/subscriptions/1');
+    await noHorizontalOverflow(page);
+    await page.screenshot({
+      path: testInfo.outputPath(`recovery-disable-error-${width}.png`),
+    });
+    await page.locator('.recovery-remove').screenshot({
+      path: testInfo.outputPath(`recovery-disable-${width}.png`),
+      style: '.site-header { visibility: hidden !important; }',
+    });
+  });
+
+  test(`${width}px enrollment failure stays in view below long recovery status`, async ({
+    page,
+  }, testInfo) => {
+    await page.setViewportSize({ width, height: 500 });
+    await page.emulateMedia({ reducedMotion: 'reduce' });
+    const fixture = await fixtures(page, {
+      monitored: true,
+      withHistory: true,
+      subscribeError: 'invalid_signature',
+    });
+    await page.goto('/account#recovery-alerts');
+    await expect(
+      page.getByText('Recovery pending', { exact: true })
+    ).toBeVisible();
+    await expect(
+      page.getByText('Recovery canceled or invalidated')
+    ).toBeHidden();
+    await page.getByText('How to review in Pali', { exact: true }).click();
+    await expect(
+      page.getByText('Disable guardian recovery', { exact: true })
+    ).toBeVisible();
+    await page.locator('#recovery-alerts').screenshot({
+      path: testInfo.outputPath(`recovery-pending-${width}.png`),
+      style: '.site-header { visibility: hidden !important; }',
+    });
+    await page.getByText('Link another smart account', { exact: true }).click();
+    await page
+      .getByRole('button', { name: 'Connect wallet', exact: true })
+      .click();
+    await page.getByLabel('Account label (optional)').fill('Savings');
+    await page
+      .getByRole('button', { name: 'Enable recovery alerts', exact: true })
+      .click();
+    const error = page.getByRole('alert');
+    await expect(error).toHaveText(/could not verify this signature/);
+    await expect(error).toBeFocused();
+    await expect
+      .poll(async () => {
+        const bounds = await error.boundingBox();
+        return bounds.y >= 70 && bounds.y + bounds.height <= 500;
+      })
+      .toBe(true);
+    expect(fixture.writes).toHaveLength(2);
+    await noHorizontalOverflow(page);
+    await page.screenshot({
+      path: testInfo.outputPath(`recovery-enrollment-error-${width}.png`),
+    });
+  });
+
+  test(`${width}px unverified email has a read-only next step and no wallet request`, async ({
+    page,
+  }, testInfo) => {
+    await page.setViewportSize({ width, height: 500 });
+    const fixture = await fixtures(page, { emailVerified: false });
+    await page.goto('/account#recovery-alerts');
+    await expect(
+      page.getByRole('button', { name: 'Connect wallet', exact: true })
+    ).toBeDisabled();
+    await expect(
+      page.getByText(/Verify your email before linking/)
+    ).toBeVisible();
+    await noHorizontalOverflow(page);
+    await page.locator('#recovery-alerts').screenshot({
+      path: testInfo.outputPath(`recovery-unverified-${width}.png`),
+      style: '.site-header { visibility: hidden !important; }',
+    });
+    fixture.verifyEmail();
+    await page
+      .getByRole('button', { name: 'Check verification status' })
+      .click();
+    await expect(
+      page.getByRole('button', { name: 'Connect wallet', exact: true })
+    ).toBeEnabled();
+    expect(fixture.writes).toHaveLength(0);
+    expect(await page.evaluate(() => window.__walletCalls)).toEqual([]);
+  });
+}