diff --git a/.gitignore b/.gitignore
index fb7a4a0..6d34c38 100644
--- a/.gitignore
+++ b/.gitignore
@@ -27,3 +27,4 @@ yarn-error.log*
 storybook-static
 
 .cache
+.netlify
diff --git a/AGENTS.md b/AGENTS.md
index c70d3dd..b765fc4 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -1,2 +1,11 @@
 Use space-y instead of mt-2 for better spacing between elements.
 Always use spacing in multiples of 2 unless you need to use odd spacing for a specific reason. This helps maintain visual consistency across the app.
+
+## Branch and deployment workflow
+
+- `main` is the GitHub default branch and Netlify production branch.
+- `beta` is the permanent integration and beta-testing branch.
+- Feature and fix PRs should target `beta`, not `main`.
+- Production releases happen by opening or updating the deploy PR from `beta` into `main`.
+- Use the manual GitHub Actions `Deploy` workflow to create or update the `beta` -> `main` release PR.
+- PRs into `main` are guarded and should only come from `beta`.
diff --git a/netlify/functions/notify-comp-token.js b/netlify/functions/notify-comp-token.js
new file mode 100644
index 0000000..2dd207a
--- /dev/null
+++ b/netlify/functions/notify-comp-token.js
@@ -0,0 +1,182 @@
+const crypto = require('crypto');
+
+const headers = {
+  'Access-Control-Allow-Headers': 'Content-Type',
+  'Access-Control-Allow-Methods': 'POST, OPTIONS',
+  'Access-Control-Allow-Origin': '*',
+  'Content-Type': 'application/json',
+};
+
+const base64Url = (value) => Buffer.from(value).toString('base64url');
+const REMOTE_SCOPE = 'notifycomp.remote';
+const PUSH_SCOPE = 'assignment_notifications';
+const REMOTE_TOKEN_TTL_SECONDS = 12 * 60 * 60;
+const PUSH_TOKEN_TTL_SECONDS = 10 * 60;
+
+const getCompetitionManagers = (competition) => {
+  const data = competition?.competition || competition;
+  return [...(data?.organizers || []), ...(data?.delegates || [])];
+};
+
+const isListedCompetitionManager = (competition, userId) =>
+  getCompetitionManagers(competition).some((user) => Number(user?.id) === Number(userId));
+
+const getManagedCompetitionIds = (competitions, userId) =>
+  competitions
+    .filter((competition) => isListedCompetitionManager(competition, userId))
+    .map((competition) => competition.id)
+    .filter(Boolean);
+
+const signJwt = (claims, secret) => {
+  const encodedHeader = base64Url(JSON.stringify({ alg: 'HS256', typ: 'JWT' }));
+  const encodedPayload = base64Url(JSON.stringify(claims));
+  const signature = crypto
+    .createHmac('sha256', secret)
+    .update(`${encodedHeader}.${encodedPayload}`)
+    .digest('base64url');
+
+  return `${encodedHeader}.${encodedPayload}.${signature}`;
+};
+
+exports.handler = async (event) => {
+  if (event.httpMethod === 'OPTIONS') {
+    return { statusCode: 204, headers };
+  }
+
+  if (event.httpMethod !== 'POST') {
+    return {
+      statusCode: 405,
+      headers,
+      body: JSON.stringify({ message: 'Method not allowed' }),
+    };
+  }
+
+  const secret = process.env.COMPETITION_GROUPS_JWT_SECRET;
+  if (!secret) {
+    return {
+      statusCode: 500,
+      headers,
+      body: JSON.stringify({ message: 'Notification token secret is not configured' }),
+    };
+  }
+
+  let body;
+  try {
+    body = JSON.parse(event.body || '{}');
+  } catch {
+    return {
+      statusCode: 400,
+      headers,
+      body: JSON.stringify({ message: 'Invalid JSON body' }),
+    };
+  }
+
+  const { accessToken, competitionId, scope } = body;
+  const tokenScope = scope === REMOTE_SCOPE ? REMOTE_SCOPE : PUSH_SCOPE;
+  if (!accessToken) {
+    return {
+      statusCode: 400,
+      headers,
+      body: JSON.stringify({ message: 'Missing WCA access token' }),
+    };
+  }
+
+  const wcaOrigin = process.env.WCA_ORIGIN || 'https://www.worldcubeassociation.org';
+  const meParams =
+    tokenScope === REMOTE_SCOPE ? '?upcoming_competitions=true&ongoing_competitions=true' : '';
+  const meResponse = await fetch(`${wcaOrigin}/api/v0/me${meParams}`, {
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+    },
+  });
+
+  if (!meResponse.ok) {
+    return {
+      statusCode: 401,
+      headers,
+      body: JSON.stringify({ message: 'Invalid WCA access token' }),
+    };
+  }
+
+  const { me, ongoing_competitions = [], upcoming_competitions = [] } = await meResponse.json();
+  if (!me?.id) {
+    return {
+      statusCode: 401,
+      headers,
+      body: JSON.stringify({ message: 'Unable to resolve WCA user' }),
+    };
+  }
+
+  const tokenTtlSeconds =
+    tokenScope === REMOTE_SCOPE ? REMOTE_TOKEN_TTL_SECONDS : PUSH_TOKEN_TTL_SECONDS;
+  if (tokenScope === REMOTE_SCOPE && !competitionId) {
+    return {
+      statusCode: 400,
+      headers,
+      body: JSON.stringify({ message: 'Missing competition ID for remote token' }),
+    };
+  }
+
+  let remoteCompetitionIds = [];
+
+  if (tokenScope === REMOTE_SCOPE) {
+    const competitionResponse = await fetch(`${wcaOrigin}/api/v0/competitions/${competitionId}`, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    });
+
+    if (!competitionResponse.ok) {
+      return {
+        statusCode: competitionResponse.status === 404 ? 404 : 502,
+        headers,
+        body: JSON.stringify({ message: 'Unable to verify competition remote access' }),
+      };
+    }
+
+    const competition = await competitionResponse.json();
+    if (!isListedCompetitionManager(competition, me.id)) {
+      return {
+        statusCode: 403,
+        headers,
+        body: JSON.stringify({
+          message:
+            'Only listed competition delegates and organizers can use Live Activities Remote',
+        }),
+      };
+    }
+
+    // Remote tokens are scoped to competitions the WCA API says this user manages. The
+    // NotifyComp API must reject remote mutations for competition IDs outside this claim.
+    remoteCompetitionIds = [
+      ...new Set([
+        competitionId,
+        ...getManagedCompetitionIds([...ongoing_competitions, ...upcoming_competitions], me.id),
+      ]),
+    ];
+  }
+
+  const now = Math.floor(Date.now() / 1000);
+  const token = signJwt(
+    {
+      aud: process.env.COMPETITION_GROUPS_JWT_AUDIENCE || 'notifycomp',
+      competitionIds: tokenScope === REMOTE_SCOPE ? remoteCompetitionIds : undefined,
+      exp: now + tokenTtlSeconds,
+      iat: now,
+      iss: process.env.COMPETITION_GROUPS_JWT_ISSUER || 'competitiongroups.com',
+      name: me.name,
+      scope: tokenScope,
+      scopes: [tokenScope],
+      sub: `wca:${me.id}`,
+      wcaUserId: me.id,
+      wcaUserIds: [me.id],
+    },
+    secret,
+  );
+
+  return {
+    statusCode: 200,
+    headers,
+    body: JSON.stringify({ token }),
+  };
+};
diff --git a/public/notification-sw.js b/public/notification-sw.js
new file mode 100644
index 0000000..e0e0b11
--- /dev/null
+++ b/public/notification-sw.js
@@ -0,0 +1,34 @@
+self.addEventListener('push', (event) => {
+  if (!event.data) {
+    return;
+  }
+
+  const payload = event.data.json();
+  const title = payload.title || 'Assignment update';
+  const options = {
+    body: payload.body,
+    data: payload,
+    tag: payload.dedupeKey || 'assignment-change',
+  };
+
+  event.waitUntil(self.registration.showNotification(title, options));
+});
+
+self.addEventListener('notificationclick', (event) => {
+  event.notification.close();
+
+  const targetUrl = event.notification.data?.url || '/settings';
+  const url = new URL(targetUrl, self.location.origin).href;
+
+  event.waitUntil(
+    self.clients.matchAll({ includeUncontrolled: true, type: 'window' }).then((clients) => {
+      const existingClient = clients.find((client) => client.url === url);
+
+      if (existingClient) {
+        return existingClient.focus();
+      }
+
+      return self.clients.openWindow(url);
+    }),
+  );
+});
diff --git a/src/App.tsx b/src/App.tsx
index 882b13e..648f747 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -5,7 +5,9 @@ import client from './apolloClient';
 import { usePageTracking } from './hooks/usePageTracking';
 import { CompetitionLayout } from './layouts/CompetitionLayout';
 import { RootLayout } from './layouts/RootLayout';
+import { FEATURE_FLAGS } from './lib/featureFlags';
 import About from './pages/About';
+import CompetitionAdmin from './pages/Competition/Admin';
 import CompetitionEvents from './pages/Competition/ByGroup/Events';
 import CompetitionGroup from './pages/Competition/ByGroup/Group';
 import CompetitionGroupList from './pages/Competition/ByGroup/GroupList';
@@ -18,6 +20,8 @@ import CompetitionLive from './pages/Competition/Live';
 import CompetitionPerson from './pages/Competition/Person';
 import CompetitionPersonalBests from './pages/Competition/Person/PersonalBests';
 import { PsychSheetEvent } from './pages/Competition/PsychSheet/PsychSheetEvent';
+import CompetitionRemote from './pages/Competition/Remote';
+import CompetitionResults from './pages/Competition/Results';
 import {
   CompetitionActivity,
   CompetitionRoom,
@@ -27,13 +31,18 @@ import {
 import CompetitionScramblerSchedule from './pages/Competition/ScramblerSchedule';
 import CompetitionStats from './pages/Competition/Stats';
 import CompetitionStreamSchedule from './pages/Competition/StreamSchedule';
+import CompetitionSumOfRanks from './pages/Competition/SumOfRanks';
 import Home from './pages/Home';
+import LiveActivitiesAbout from './pages/LiveActivities/About';
 import Settings from './pages/Settings';
 import Support from './pages/Support';
 import Test from './pages/Test';
+import UserPage from './pages/User';
 import UserLogin from './pages/UserLogin';
 import { AppProvider } from './providers/AppProvider';
 import { AuthProvider, useAuth } from './providers/AuthProvider';
+import { ConfirmProvider } from './providers/ConfirmProvider';
+import { NotifyCompRemoteAuthProvider } from './providers/NotifyCompRemoteAuthProvider';
 import { QueryProvider } from './providers/QueryProvider/QueryProvider';
 import { UserSettingsProvider } from './providers/UserSettingsProvider';
 import { useWCIF } from './providers/WCIFProvider';
@@ -79,6 +88,30 @@ const PsychSheet = () => {
   return null;
 };
 
+const CompetitionPersonByWcaIdRedirect = ({ to }: { to: 'results' | 'records' }) => {
+  const { competitionId, wcaId } = useParams() as { competitionId: string; wcaId: string };
+  const { wcif } = useWCIF();
+  const person = wcif?.persons.find((p) => p.wcaId?.toUpperCase() === wcaId.toUpperCase());
+
+  if (!wcif) {
+    return null;
+  }
+
+  if (!person) {
+    return <Navigate to={`/competitions/${competitionId}`} replace />;
+  }
+
+  return (
+    <Navigate to={`/competitions/${competitionId}/persons/${person.registrantId}/${to}`} replace />
+  );
+};
+
+const CompetitionRedirect = ({ to }: { to: string }) => {
+  const { competitionId } = useParams() as { competitionId: string };
+
+  return <Navigate to={`/competitions/${competitionId}/${to}`} replace />;
+};
+
 const Navigation = () => {
   usePageTracking(import.meta.env.VITE_GA_MEASUREMENT_ID);
 
@@ -90,7 +123,15 @@ const Navigation = () => {
         <Route path="/competitions/:competitionId" element={<CompetitionLayout />}>
           <Route index element={<CompetitionHome />} />
 
-          <Route path="persons/:registrantId" element={<CompetitionPerson />} />
+          <Route
+            path="persons/wca/:wcaId/results"
+            element={<CompetitionPersonByWcaIdRedirect to="results" />}
+          />
+          <Route
+            path="persons/wca/:wcaId/records"
+            element={<CompetitionPersonByWcaIdRedirect to="records" />}
+          />
+          <Route path="persons/:registrantId/*" element={<CompetitionPerson />} />
           <Route path="personal-bests/:wcaId" element={<CompetitionPersonalBests />} />
           <Route path="personal-records/:wcaId" element={<CompetitionPersonalBests />} />
           <Route path="compare-schedules" element={<CompetitionCompareSchedules />} />
@@ -106,8 +147,16 @@ const Navigation = () => {
 
           <Route path="psych-sheet" element={<PsychSheet />} />
           <Route path="psych-sheet/:eventId" element={<PsychSheetEvent />} />
-
-          <Route path="scramblers" element={<CompetitionScramblerSchedule />} />
+          <Route path="results" element={<CompetitionResults />} />
+          <Route path="results/:roundId" element={<CompetitionResults />} />
+
+          <Route path="admin" element={<CompetitionAdmin />} />
+          <Route path="admin/remote" element={<CompetitionRemote />} />
+          <Route path="admin/scramblers" element={<CompetitionScramblerSchedule />} />
+          <Route path="admin/stats" element={<CompetitionStats />} />
+          <Route path="admin/sum-of-ranks" element={<CompetitionSumOfRanks />} />
+          <Route path="remote" element={<CompetitionRedirect to="admin/remote" />} />
+          <Route path="scramblers" element={<CompetitionRedirect to="admin/scramblers" />} />
           <Route path="stream" element={<CompetitionStreamSchedule />} />
           <Route path="information" element={<CompetitionInformation />} />
           <Route path="live" element={<CompetitionLive />} />
@@ -116,11 +165,23 @@ const Navigation = () => {
           <Route path="personal-schedule" element={<PersonalSchedule />} />
           <Route path="explore" element={<CompetitionGroupsOverview />} />
           <Route path="groups-schedule" element={<CompetitionGroupsSchedule />} />
-          <Route path="stats" element={<CompetitionStats />} />
+          <Route path="stats" element={<CompetitionRedirect to="admin/stats" />} />
+          <Route path="sum-of-ranks" element={<CompetitionRedirect to="admin/sum-of-ranks" />} />
           <Route path="*" element={<p>Path not resolved</p>} />
         </Route>
         <Route path="/users/:userId" element={<UserLogin />} />
+        {FEATURE_FLAGS.personalUserPage && (
+          <>
+            <Route path="/me" element={<Navigate to="/me/competitions" replace />} />
+            <Route
+              path="/me/results/:resultsMode"
+              element={<Navigate to="/me/results" replace />}
+            />
+            <Route path="/me/:tab" element={<UserPage />} />
+          </>
+        )}
         <Route path="about" element={<About />} />
+        <Route path="live-activities" element={<LiveActivitiesAbout />} />
         <Route path="settings" element={<Settings />} />
         <Route path="support" element={<Support />} />
       </Route>
@@ -136,9 +197,13 @@ const App = () => (
       <QueryProvider>
         <ApolloProvider client={client}>
           <BrowserRouter>
-            <AuthProvider>
-              <Navigation />
-            </AuthProvider>
+            <ConfirmProvider>
+              <AuthProvider>
+                <NotifyCompRemoteAuthProvider>
+                  <Navigation />
+                </NotifyCompRemoteAuthProvider>
+              </AuthProvider>
+            </ConfirmProvider>
           </BrowserRouter>
         </ApolloProvider>
       </QueryProvider>
diff --git a/src/apolloClient.ts b/src/apolloClient.ts
index e5bdc47..4e33106 100644
--- a/src/apolloClient.ts
+++ b/src/apolloClient.ts
@@ -1,25 +1,58 @@
 import { ApolloClient, createHttpLink, InMemoryCache, split } from '@apollo/client';
+import { setContext } from '@apollo/client/link/context';
 import { GraphQLWsLink } from '@apollo/client/link/subscriptions';
 import { getMainDefinition } from '@apollo/client/utilities';
 import { createClient } from 'graphql-ws';
+import { getNotifyCompRemoteToken } from './lib/notifyCompRemoteAuth';
+import { setNotifyCompWebSocketStatus } from './lib/notifyCompWebSocketStatus';
+import { NOTIFYCOMP_GRAPHQL_ORIGIN, NOTIFYCOMP_WS_ORIGIN } from './lib/remoteConfig';
 
 const httpLink = createHttpLink({
-  uri: import.meta.env.VITE_NOTIFYCOMP_API_ORIGIN || 'https://admin.notifycomp.com/graphql',
+  uri: NOTIFYCOMP_GRAPHQL_ORIGIN,
 });
 
 const wsLink = new GraphQLWsLink(
   createClient({
-    url: import.meta.env.VITE_NOTIFYCOMP_WS_ORIGIN || 'wss://admin.notifycomp.com/graphql',
+    url: NOTIFYCOMP_WS_ORIGIN,
+    on: {
+      connecting: () => {
+        setNotifyCompWebSocketStatus({ status: 'connecting' });
+      },
+      connected: () => {
+        setNotifyCompWebSocketStatus({ status: 'connected' });
+      },
+      closed: () => {
+        setNotifyCompWebSocketStatus({ status: 'disconnected' });
+      },
+      error: () => {
+        setNotifyCompWebSocketStatus({
+          status: 'disconnected',
+          message:
+            'Unable to connect to NotifyComp live updates. Activity changes may not update automatically.',
+        });
+      },
+    },
   }),
 );
 
+const authLink = setContext((_, { headers }) => {
+  const token = getNotifyCompRemoteToken();
+
+  return {
+    headers: {
+      ...headers,
+      ...(token && { authorization: `Bearer ${token}` }),
+    },
+  };
+});
+
 const splitLink = split(
   ({ query }) => {
     const definition = getMainDefinition(query);
     return definition.kind === 'OperationDefinition' && definition.operation === 'subscription';
   },
   wsLink,
-  httpLink,
+  authLink.concat(httpLink),
 );
 
 const client = new ApolloClient({
diff --git a/src/components/CompetitionListItem/CompetitionListItem.tsx b/src/components/CompetitionListItem/CompetitionListItem.tsx
index c2744dc..9edbc19 100644
--- a/src/components/CompetitionListItem/CompetitionListItem.tsx
+++ b/src/components/CompetitionListItem/CompetitionListItem.tsx
@@ -13,6 +13,7 @@ interface CompetitionListItemProps {
   city: string;
   isLive: boolean;
   isBookmarked?: boolean;
+  variant?: 'card' | 'dropdown';
 }
 
 export const CompetitionListItem = ({
@@ -24,6 +25,7 @@ export const CompetitionListItem = ({
   city,
   isLive,
   isBookmarked,
+  variant = 'card',
 }: CompetitionListItemProps) => {
   const endDate = new Date(
     new Date(end_date).getTime() + 1000 * 60 * new Date().getTimezoneOffset(),
@@ -33,7 +35,9 @@ export const CompetitionListItem = ({
     <Link to={`/competitions/${id}`}>
       <li
         className={classNames(
-          'link-card list-none flex flex-row cursor-pointer group transition-colors my-1 type-body',
+          variant === 'card'
+            ? 'link-card list-none flex flex-row cursor-pointer group hover-transition my-1 type-body'
+            : 'list-none flex flex-row cursor-pointer group hover-transition type-body w-full px-2 py-2 bg-panel hover:bg-gray-100 dark:hover:bg-gray-700',
           {
             'opacity-50': endDate < new Date(Date.now() - 1000 * 60 * 60 * 24),
           },
diff --git a/src/components/CompetitionListItem/__snapshots__/CompetitionListItem.test.tsx.snap b/src/components/CompetitionListItem/__snapshots__/CompetitionListItem.test.tsx.snap
index 1229d6f..15e9542 100644
--- a/src/components/CompetitionListItem/__snapshots__/CompetitionListItem.test.tsx.snap
+++ b/src/components/CompetitionListItem/__snapshots__/CompetitionListItem.test.tsx.snap
@@ -7,7 +7,7 @@ exports[`CompetitionListItem matches snapshot (default) 1`] = `
       href="/competitions/123"
     >
       <li
-        class="link-card list-none flex flex-row cursor-pointer group transition-colors my-1 type-body opacity-50"
+        class="link-card list-none flex flex-row cursor-pointer group hover-transition my-1 type-body opacity-50"
       >
         <div
           class="flex flex-shrink mr-2 type-title"
@@ -50,7 +50,7 @@ exports[`CompetitionListItem renders with all props (live and bookmarked) 1`] =
       href="/competitions/123"
     >
       <li
-        class="link-card list-none flex flex-row cursor-pointer group transition-colors my-1 type-body opacity-50"
+        class="link-card list-none flex flex-row cursor-pointer group hover-transition my-1 type-body opacity-50"
       >
         <div
           class="flex flex-shrink mr-2 type-title"
diff --git a/src/components/CompetitionSelect/CompetitionSelect.tsx b/src/components/CompetitionSelect/CompetitionSelect.tsx
index e0fdf48..ff58920 100644
--- a/src/components/CompetitionSelect/CompetitionSelect.tsx
+++ b/src/components/CompetitionSelect/CompetitionSelect.tsx
@@ -16,6 +16,17 @@ export const CompetitionSelect = ({ onSelect, className }: CompetitionSelectProp
   const { t } = useTranslation();
   const { effectiveTheme } = useUserSettings();
   const isDark = effectiveTheme === 'dark';
+  const colors = {
+    controlBackground: isDark ? '#1f2937' : '#ffffff',
+    optionBackground: isDark ? '#1f2937' : '#ffffff',
+    optionFocusedBackground: isDark ? '#374151' : '#e5e7eb',
+    optionSelectedBackground: isDark ? '#1e3a8a' : '#dbeafe',
+    text: isDark ? '#ffffff' : '#111827',
+    mutedText: isDark ? '#9ca3af' : '#4b5563',
+    border: isDark ? '#374151' : '#e5e7eb',
+    menuBorder: isDark ? '#4b5563' : '#cbd5e1',
+    focusBorder: isDark ? '#60a5fa' : '#3b82f6',
+  };
 
   const loadOptions = useDebounced(async (inputValue: string) => {
     try {
@@ -58,7 +69,7 @@ export const CompetitionSelect = ({ onSelect, className }: CompetitionSelectProp
     dropdownIndicator: (state) =>
       ['text-muted', state.isFocused ? 'text-blue-600 dark:text-blue-400' : ''].join(' '),
     clearIndicator: () => 'text-muted hover-text-tertiary',
-    menu: () => 'bg-panel border border-tertiary-weak shadow-md',
+    menu: () => 'bg-panel border border-tertiary-weak shadow-md dropdown-open-transition',
     menuList: () => 'bg-panel',
     option: (state) =>
       [
@@ -72,37 +83,54 @@ export const CompetitionSelect = ({ onSelect, className }: CompetitionSelectProp
   const styles: StylesConfig<ApiCompetition, false> = {
     control: (base, state) => ({
       ...base,
-      backgroundColor: 'transparent',
-      borderColor: state.isFocused ? (isDark ? '#60a5fa' : '#3b82f6') : base.borderColor,
-      boxShadow: state.isFocused ? `0 0 0 1px ${isDark ? '#60a5fa' : '#3b82f6'}` : 'none',
+      backgroundColor: colors.controlBackground,
+      borderColor: state.isFocused ? colors.focusBorder : colors.border,
+      boxShadow: state.isFocused ? `0 0 0 1px ${colors.focusBorder}` : 'none',
       ':hover': {
         ...base[':hover'],
-        borderColor: state.isFocused ? (isDark ? '#60a5fa' : '#3b82f6') : base.borderColor,
+        borderColor: state.isFocused ? colors.focusBorder : colors.border,
       },
     }),
     menu: (base) => ({
       ...base,
-      backgroundColor: 'transparent',
+      backgroundColor: colors.optionBackground,
+      border: `1px solid ${colors.menuBorder}`,
+      boxShadow: '0 16px 36px rgba(15, 23, 42, 0.38)',
+      overflow: 'hidden',
+      zIndex: 1000,
     }),
     menuList: (base) => ({
       ...base,
-      backgroundColor: 'transparent',
+      backgroundColor: colors.optionBackground,
+      paddingBottom: 0,
+      paddingTop: 0,
     }),
-    option: (base) => ({
+    option: (base, state) => ({
       ...base,
-      backgroundColor: 'transparent',
+      backgroundColor: state.isSelected
+        ? colors.optionSelectedBackground
+        : state.isFocused
+          ? colors.optionFocusedBackground
+          : colors.optionBackground,
+      color: colors.text,
+      cursor: 'pointer',
+      padding: 0,
+      ':active': {
+        ...base[':active'],
+        backgroundColor: colors.optionSelectedBackground,
+      },
     }),
     input: (base) => ({
       ...base,
-      color: isDark ? '#ffffff' : '#111827', // gray-900
+      color: colors.text,
     }),
     singleValue: (base) => ({
       ...base,
-      color: isDark ? '#ffffff' : '#111827', // gray-900
+      color: colors.text,
     }),
     placeholder: (base) => ({
       ...base,
-      color: isDark ? '#9ca3af' : '#4b5563', // dark: gray-400, light: gray-600
+      color: colors.mutedText,
     }),
   };
 
@@ -113,7 +141,9 @@ export const CompetitionSelect = ({ onSelect, className }: CompetitionSelectProp
       cacheOptions
       loadOptions={loadOptions}
       placeholder={t('common.competitionSelect.placeholder')}
-      noOptionsMessage={() => t('common.competitionSelect.noOptions')}
+      noOptionsMessage={({ inputValue }) =>
+        inputValue.trim() ? t('common.competitionSelect.noOptions') : null
+      }
       components={{
         Option: CompetitionOption,
       }}
@@ -125,7 +155,7 @@ export const CompetitionSelect = ({ onSelect, className }: CompetitionSelectProp
 };
 
 export const CompetitionOption = ({ data }: OptionProps<ApiCompetition>) => {
-  return <CompetitionListItem {...data} isLive={false} />;
+  return <CompetitionListItem {...data} isLive={false} variant="dropdown" />;
 };
 
 function useDebounced<Input, Output>(
diff --git a/src/components/CutoffTimeLimitPanel/CutoffTimeLimitPanel.stories.tsx b/src/components/CutoffTimeLimitPanel/CutoffTimeLimitPanel.stories.tsx
index e12a099..ff0533c 100644
--- a/src/components/CutoffTimeLimitPanel/CutoffTimeLimitPanel.stories.tsx
+++ b/src/components/CutoffTimeLimitPanel/CutoffTimeLimitPanel.stories.tsx
@@ -2,6 +2,8 @@ import type { Meta, StoryObj } from '@storybook/react';
 import {
   getStorybookRoundFixture,
   makeStorybookCompetitionFixtureWithRound,
+  storybookParticipationConditionLinkedRoundsFixture,
+  storybookParticipationConditionPercentFixture,
 } from '@/storybook/competitionFixtures';
 import { makeCompetitionContainerDecorator } from '@/storybook/competitionStorybook';
 import { CutoffTimeLimitPanel } from './CutoffTimeLimitPanel';
@@ -53,6 +55,33 @@ export const RankingAdvancement: Story = {
   },
 };
 
+export const ParticipationConditionPercent: Story = {
+  parameters: {
+    competitionFixture: storybookParticipationConditionPercentFixture,
+  },
+  args: {
+    round: storybookParticipationConditionPercentFixture.events[0].rounds[0],
+  },
+};
+
+export const ParticipationConditionLinkedRounds: Story = {
+  parameters: {
+    competitionFixture: storybookParticipationConditionLinkedRoundsFixture,
+  },
+  args: {
+    round: storybookParticipationConditionLinkedRoundsFixture.events[0].rounds[1],
+  },
+};
+
+export const ParticipationConditionLinkedRoundsStart: Story = {
+  parameters: {
+    competitionFixture: storybookParticipationConditionLinkedRoundsFixture,
+  },
+  args: {
+    round: storybookParticipationConditionLinkedRoundsFixture.events[0].rounds[0],
+  },
+};
+
 export const CutoffAndTimeLimit: Story = {
   args: {
     round: getStorybookRoundFixture('222-r1'),
diff --git a/src/components/CutoffTimeLimitPanel/CutoffTimeLimitPanel.test.tsx b/src/components/CutoffTimeLimitPanel/CutoffTimeLimitPanel.test.tsx
index 832e75e..de058ce 100644
--- a/src/components/CutoffTimeLimitPanel/CutoffTimeLimitPanel.test.tsx
+++ b/src/components/CutoffTimeLimitPanel/CutoffTimeLimitPanel.test.tsx
@@ -22,24 +22,196 @@ jest.mock('react-tiny-popover', () => ({
 }));
 
 jest.mock('react-i18next', () => ({
-  Trans: ({ i18nKey }: { i18nKey: string }) => i18nKey,
+  Trans: ({ i18nKey, values }: { i18nKey: string; values?: Record<string, unknown> }) => {
+    if (i18nKey === 'common.wca.advancement.ranking') {
+      return `Top ${values?.level} to next round`;
+    }
+
+    if (i18nKey === 'common.wca.advancement.percent') {
+      return `Top ${values?.level}% to next round`;
+    }
+
+    if (i18nKey === 'common.wca.advancement.linkedRanking') {
+      return `Top ${values?.level} combined across ${values?.rounds} advance to next round`;
+    }
+
+    if (i18nKey === 'common.wca.advancement.linkedPercent') {
+      return `Top ${values?.level}% combined across ${values?.rounds} advance to next round`;
+    }
+
+    if (i18nKey === 'common.wca.cumulativeTimelimit') {
+      return `Time Limit: ${values?.time} Cumulative`;
+    }
+
+    if (i18nKey === 'common.wca.cumulativeTimelimitWithrounds') {
+      return `Time Limit: ${values?.time} Total with:`;
+    }
+
+    return i18nKey;
+  },
   useTranslation: () => ({
-    t: (key: string) => key,
+    t: (key: string, options?: Record<string, unknown>) => {
+      if (key === 'common.help') {
+        return 'help';
+      }
+
+      if (key === 'common.wca.cutoff') {
+        return 'Cutoff';
+      }
+
+      if (key === 'common.wca.timeLimit') {
+        return 'Time Limit';
+      }
+
+      if (key === 'common.activityCodeToName.round') {
+        return `Round ${options?.roundNumber}`;
+      }
+
+      if (key === 'common.wca.advancement.ranking') {
+        return `Top ${options?.level} advance to ${options?.what}`;
+      }
+
+      if (key === 'common.wca.advancement.percent') {
+        return `Top ${options?.level}% advance to ${options?.what}`;
+      }
+
+      if (key === 'common.wca.advancement.linkedRanking') {
+        return `Top ${options?.level} in dual rounds ${options?.rounds} advance to ${options?.what}`;
+      }
+
+      if (key === 'common.wca.advancement.linkedPercent') {
+        return `Top ${options?.level}% in dual rounds ${options?.rounds} advance to ${options?.what}`;
+      }
+
+      if (key === 'common.wca.advancement.nextRound') {
+        return 'next round';
+      }
+
+      if (key === 'common.wca.advancement.final') {
+        return 'final';
+      }
+
+      if (key === 'common.wca.advancement.resultThresholdUnknown') {
+        return 'an unknown result';
+      }
+
+      if (options?.defaultValue) {
+        return String(options.defaultValue)
+          .replace('{{level}}', String(options.level ?? ''))
+          .replace('{{rounds}}', String(options.rounds ?? ''))
+          .replace('{{round}}', String(options.round ?? ''))
+          .replace('{{what}}', String(options.what ?? ''))
+          .replace('{{scope}}', String(options.scope ?? ''))
+          .replace('{{result}}', String(options.result ?? ''));
+      }
+
+      return key;
+    },
   }),
 }));
 
+const wcifMock = {
+  id: 'TestComp2026',
+  schedule: { venues: [] },
+  events: [
+    {
+      id: '333',
+      rounds: [
+        {
+          id: '333-r1',
+          format: 'a',
+          cutoff: null,
+          timeLimit: null,
+          advancementCondition: {
+            type: 'ranking',
+            level: 16,
+          },
+          results: [],
+        },
+        {
+          id: '333-r2',
+          format: 'a',
+          cutoff: null,
+          timeLimit: null,
+          participationRuleset: {
+            participationSource: {
+              type: 'round',
+              roundId: '333-r1',
+              resultCondition: {
+                type: 'percent',
+                value: 75,
+              },
+            },
+          },
+          results: [],
+        },
+        {
+          id: '333-r3',
+          format: 'a',
+          cutoff: null,
+          timeLimit: null,
+          participationRuleset: {
+            participationSource: {
+              type: 'linkedRounds',
+              roundIds: ['333-r1', '333-r2'],
+              resultCondition: {
+                type: 'ranking',
+                value: 12,
+              },
+            },
+          },
+          results: [],
+        },
+      ],
+    },
+    {
+      id: '222',
+      rounds: [
+        {
+          id: '222-r1',
+          format: 'a',
+          cutoff: null,
+          timeLimit: null,
+          results: [],
+        },
+        {
+          id: '222-r2',
+          format: 'a',
+          cutoff: null,
+          timeLimit: null,
+          results: [],
+        },
+        {
+          id: '222-r3',
+          format: 'a',
+          cutoff: null,
+          timeLimit: null,
+          participationRuleset: {
+            participationSource: {
+              type: 'linkedRounds',
+              roundIds: ['222-r1', '222-r2'],
+              resultCondition: {
+                type: 'ranking',
+                value: 8,
+              },
+            },
+          },
+          results: [],
+        },
+      ],
+    },
+  ],
+};
+
 jest.mock('@/providers/WCIFProvider', () => ({
   useWCIF: () => ({
     competitionId: 'TestComp2026',
-    wcif: {
-      id: 'TestComp2026',
-      schedule: { venues: [] },
-    },
+    wcif: wcifMock,
     setTitle: () => {},
   }),
 }));
 
-const round = {
+const cutoffOnlyRound = {
   id: '333-r1',
   cutoff: {
     numberOfAttempts: 2,
@@ -49,7 +221,7 @@ const round = {
   advancementCondition: null,
 } as unknown as Round;
 
-function renderPanel() {
+function renderPanel(round: Round) {
   return render(
     <MemoryRouter>
       <CutoffTimeLimitPanel round={round} />
@@ -59,7 +231,7 @@ function renderPanel() {
 
 describe('CutoffTimeLimitPanel', () => {
   it('uses theme-aware popover classes for help content', () => {
-    renderPanel();
+    renderPanel(cutoffOnlyRound);
 
     fireEvent.click(screen.getByRole('button', { name: /help/i }));
 
@@ -71,4 +243,31 @@ describe('CutoffTimeLimitPanel', () => {
     expect(popoverContent).toHaveClass('text-default');
     expect(popoverContent).not.toHaveClass('bg-white');
   });
+
+  it('shows the legacy advancement text for stable wcif rounds', () => {
+    renderPanel(wcifMock.events[0].rounds[0] as unknown as Round);
+
+    expect(screen.getByText('Top 16 advance to next round')).toBeInTheDocument();
+  });
+
+  it('shows advancement text derived from the next round participation ruleset', () => {
+    renderPanel({
+      ...(wcifMock.events[0].rounds[0] as object),
+      advancementCondition: null,
+    } as Round);
+
+    expect(screen.getByText('Top 75% advance to next round')).toBeInTheDocument();
+  });
+
+  it('shows linked-round advancement text when a later round depends on combined results', () => {
+    renderPanel(wcifMock.events[0].rounds[1] as unknown as Round);
+
+    expect(screen.getByText('Top 12 in dual rounds 1 & 2 advance to final')).toBeInTheDocument();
+  });
+
+  it('shows the same dual-round advancement text for the first round in a linked-round set', () => {
+    renderPanel(wcifMock.events[1].rounds[0] as unknown as Round);
+
+    expect(screen.getByText('Top 8 in dual rounds 1 & 2 advance to final')).toBeInTheDocument();
+  });
 });
diff --git a/src/components/CutoffTimeLimitPanel/CutoffTimeLimitPanel.tsx b/src/components/CutoffTimeLimitPanel/CutoffTimeLimitPanel.tsx
index 615882b..265db36 100644
--- a/src/components/CutoffTimeLimitPanel/CutoffTimeLimitPanel.tsx
+++ b/src/components/CutoffTimeLimitPanel/CutoffTimeLimitPanel.tsx
@@ -1,10 +1,12 @@
 import { Cutoff, Round, parseActivityCode } from '@wca/helpers';
 import classNames from 'classnames';
-import { useState } from 'react';
+import { useMemo, useState } from 'react';
 import { Trans, useTranslation } from 'react-i18next';
 import { Link } from 'react-router-dom';
 import { Popover } from 'react-tiny-popover';
 import { renderCentiseconds, renderCutoff } from '@/lib/results';
+import { getEventRoundsForRound, joinLabels } from '@/lib/roundLabels';
+import { CompatibleRound, getAdvancementConditionForRound, ResultCondition } from '@/lib/wcif';
 import { useWCIF } from '@/providers/WCIFProvider';
 
 export function CutoffTimeLimitPanel({
@@ -20,10 +22,17 @@ export function CutoffTimeLimitPanel({
   const cutoff = round.cutoff;
   const timeLimit = round.timeLimit;
   const timelimitTime = timeLimit && renderCentiseconds(timeLimit?.centiseconds);
+  const cumulativeRoundIds = getCumulativeRoundIds(timeLimit, round.id);
+  const eventRounds = useMemo(
+    () => getEventRoundsForRound(wcif?.events, round.id),
+    [round.id, wcif?.events],
+  );
+  const advancement = useMemo(
+    () => getAdvancementConditionForRound(eventRounds, round as CompatibleRound),
+    [eventRounds, round],
+  );
 
-  if (!timeLimit && !cutoff && !round.advancementCondition) return null;
-
-  const level = round.advancementCondition?.level;
+  if (!timeLimit && !cutoff && !advancement) return null;
 
   return (
     <div className={classNames('flex w-full', className)}>
@@ -44,8 +53,7 @@ export function CutoffTimeLimitPanel({
 
           {timeLimit &&
             timeLimit?.cumulativeRoundIds.length > 0 &&
-            timeLimit.cumulativeRoundIds.filter((activityCode) => activityCode !== round.id)
-              .length === 0 && (
+            cumulativeRoundIds.length === 0 && (
               <span className="px-2">
                 <Trans
                   i18nKey={'common.wca.cumulativeTimelimit'}
@@ -57,8 +65,7 @@ export function CutoffTimeLimitPanel({
 
           {timeLimit &&
             timeLimit?.cumulativeRoundIds.length > 0 &&
-            timeLimit.cumulativeRoundIds.filter((activityCode) => activityCode !== round.id)
-              .length > 0 && (
+            cumulativeRoundIds.length > 0 && (
               <div className="px-2">
                 <span>
                   <Trans
@@ -66,55 +73,27 @@ export function CutoffTimeLimitPanel({
                     values={{ time: timelimitTime }}
                     components={{ b: <span className="font-semibold" /> }}
                   />
-                  {timeLimit.cumulativeRoundIds
-                    .filter((activityCode) => activityCode !== round.id)
-                    .map((activityCode, i, arry) => {
-                      const { eventId, roundNumber } = parseActivityCode(activityCode);
-                      return (
-                        <Link
-                          key={activityCode}
-                          to={`/competitions/${wcif?.id}/events/${activityCode}`}>
-                          <span
-                            className={`cubing-icon event-${eventId} mx-1 before:-ml-1 before:mr-2`}>
-                            {t('common.activityCodeToName.round', { roundNumber })}
-                            {i < arry.length - 1 ? ', ' : ''}
-                          </span>
-                        </Link>
-                      );
-                    })}
+                  {cumulativeRoundIds.map((activityCode, i, arry) => {
+                    const { eventId, roundNumber } = parseActivityCode(activityCode);
+                    return (
+                      <Link
+                        key={activityCode}
+                        to={`/competitions/${wcif?.id}/events/${activityCode}`}>
+                        <span
+                          className={`cubing-icon event-${eventId} mx-1 before:-ml-1 before:mr-2`}>
+                          {t('common.activityCodeToName.round', { roundNumber })}
+                          {i < arry.length - 1 ? ', ' : ''}
+                        </span>
+                      </Link>
+                    );
+                  })}
                 </span>
               </div>
             )}
         </div>
-        {round.advancementCondition && (
-          <div>
-            {round.advancementCondition.type === 'ranking' && (
-              <div className="px-2">
-                <Trans
-                  i18nKey={'common.wca.advancement.ranking'}
-                  values={{ level }}
-                  components={{ b: <span className="font-semibold" /> }}
-                />
-              </div>
-            )}
-            {round.advancementCondition.type === 'percent' && (
-              <div className="px-2">
-                <Trans
-                  i18nKey={'common.wca.advancement.percent'}
-                  values={{ level }}
-                  components={{ b: <span className="font-semibold" /> }}
-                />
-              </div>
-            )}
-            {round.advancementCondition.type === 'attemptResult' && (
-              <div className="px-2">
-                <Trans
-                  i18nKey={'common.wca.advancement.attemptResult'}
-                  values={{ level }}
-                  components={{ b: <span className="font-semibold" /> }}
-                />
-              </div>
-            )}
+        {advancement && (
+          <div className="px-2">
+            {renderAdvancementText(t, eventRounds, advancement.sourceType, advancement)}
           </div>
         )}
       </div>
@@ -125,6 +104,110 @@ export function CutoffTimeLimitPanel({
   );
 }
 
+function getCumulativeRoundIds(timeLimit: Round['timeLimit'], roundId: string) {
+  return timeLimit?.cumulativeRoundIds.filter((activityCode) => activityCode !== roundId) || [];
+}
+
+function renderAdvancementText(
+  t: ReturnType<typeof useTranslation>['t'],
+  eventRounds: CompatibleRound[],
+  sourceType: 'registrations' | 'round' | 'linkedRounds',
+  advancement: NonNullable<ReturnType<typeof getAdvancementConditionForRound>>,
+) {
+  if (sourceType === 'linkedRounds') {
+    return renderLinkedRoundsAdvancementText(t, eventRounds, advancement);
+  }
+
+  return renderSingleRoundAdvancementText(t, eventRounds, advancement);
+}
+
+function renderLinkedRoundsAdvancementText(
+  t: ReturnType<typeof useTranslation>['t'],
+  eventRounds: CompatibleRound[],
+  advancement: NonNullable<ReturnType<typeof getAdvancementConditionForRound>>,
+) {
+  const { resultCondition } = advancement;
+  const sourceRoundNames = advancement.sourceRoundIds.map((roundId) => {
+    const roundNumber = parseActivityCode(roundId).roundNumber;
+    return roundNumber ? roundNumber.toString() : '';
+  });
+  const sourceRoundsLabel = joinLabels(sourceRoundNames);
+  const targetLabel = getAdvancementTargetLabel(t, eventRounds, advancement.targetRoundId);
+
+  switch (resultCondition.type) {
+    case 'ranking':
+      return t('common.wca.advancement.linkedRanking', {
+        level: resultCondition.value,
+        rounds: sourceRoundsLabel,
+        what: targetLabel,
+      });
+    case 'percent':
+      return t('common.wca.advancement.linkedPercent', {
+        level: resultCondition.value,
+        rounds: sourceRoundsLabel,
+        what: targetLabel,
+      });
+    case 'resultAchieved':
+      return t('common.wca.advancement.linkedResultAchieved', {
+        scope: t(`common.wca.advancement.scope.${resultCondition.scope}`),
+        result:
+          resultCondition.value === null
+            ? t('common.wca.advancement.resultThresholdUnknown')
+            : renderCentiseconds(resultCondition.value),
+        rounds: sourceRoundsLabel,
+        what: targetLabel,
+      });
+  }
+}
+
+function renderSingleRoundAdvancementText(
+  t: ReturnType<typeof useTranslation>['t'],
+  eventRounds: CompatibleRound[],
+  advancement: NonNullable<ReturnType<typeof getAdvancementConditionForRound>>,
+) {
+  const { resultCondition } = advancement;
+  const targetLabel = getAdvancementTargetLabel(t, eventRounds, advancement.targetRoundId);
+
+  switch (resultCondition.type) {
+    case 'ranking':
+      return t('common.wca.advancement.ranking', {
+        level: resultCondition.value,
+        what: targetLabel,
+      });
+    case 'percent':
+      return t('common.wca.advancement.percent', {
+        level: resultCondition.value,
+        what: targetLabel,
+      });
+    case 'resultAchieved':
+      return t('common.wca.advancement.resultAchieved', {
+        scope: t(`common.wca.advancement.scope.${resultCondition.scope}`),
+        result:
+          resultCondition.value === null
+            ? t('common.wca.advancement.resultThresholdUnknown')
+            : renderCentiseconds(resultCondition.value),
+        what: targetLabel,
+      });
+  }
+}
+
+function getAdvancementTargetLabel(
+  t: ReturnType<typeof useTranslation>['t'],
+  eventRounds: CompatibleRound[],
+  targetRoundId: string | null | undefined,
+) {
+  if (!targetRoundId) {
+    return t('common.wca.advancement.unknown');
+  }
+
+  const targetRoundIndex = eventRounds.findIndex((candidate) => candidate.id === targetRoundId);
+  if (targetRoundIndex === eventRounds.length - 1) {
+    return t('common.wca.advancement.final');
+  }
+
+  return t('common.wca.advancement.nextRound');
+}
+
 function CutoffTimeLimitPopover({ cutoff }: { cutoff: Cutoff | null }) {
   const { t } = useTranslation();
   const [open, setOpen] = useState(false);
diff --git a/src/components/NotifyCompConnectionStatus/NotifyCompConnectionStatus.tsx b/src/components/NotifyCompConnectionStatus/NotifyCompConnectionStatus.tsx
new file mode 100644
index 0000000..59b160e
--- /dev/null
+++ b/src/components/NotifyCompConnectionStatus/NotifyCompConnectionStatus.tsx
@@ -0,0 +1,47 @@
+import classNames from 'classnames';
+import { NoteBox } from '@/components/Notebox';
+import { useNotifyCompWebSocketStatus } from '@/hooks/useNotifyCompWebSocketStatus';
+
+interface NotifyCompConnectionStatusProps {
+  className?: string;
+  compact?: boolean;
+}
+
+const statusText = {
+  connecting: 'Connecting to NotifyComp live updates...',
+  disconnected:
+    'Not connected to NotifyComp live updates. Activity changes may not update automatically.',
+  idle: '',
+  connected: '',
+};
+
+export function NotifyCompConnectionStatus({
+  className,
+  compact = false,
+}: NotifyCompConnectionStatusProps) {
+  const { message, status } = useNotifyCompWebSocketStatus();
+
+  if (status === 'idle' || status === 'connected') {
+    return null;
+  }
+
+  const text = message || statusText[status];
+  const toneClassName =
+    status === 'connecting' ? 'bg-yellow-400 dark:bg-yellow-300' : 'bg-red-500 dark:bg-red-400';
+
+  if (compact) {
+    return (
+      <div
+        className={classNames(
+          'flex items-center justify-center gap-1 text-xs font-medium text-muted',
+          className,
+        )}
+        title={text}>
+        <span className={classNames('h-2 w-2 rounded-full', toneClassName)} aria-hidden="true" />
+        <span>{status === 'connecting' ? 'Connecting live updates' : 'Live updates offline'}</span>
+      </div>
+    );
+  }
+
+  return <NoteBox className={className} prefix="Live updates" text={text} />;
+}
diff --git a/src/components/NotifyCompConnectionStatus/index.ts b/src/components/NotifyCompConnectionStatus/index.ts
new file mode 100644
index 0000000..a239111
--- /dev/null
+++ b/src/components/NotifyCompConnectionStatus/index.ts
@@ -0,0 +1 @@
+export * from './NotifyCompConnectionStatus';
diff --git a/src/components/NotifyCompRemoteBar/NotifyCompRemoteBar.tsx b/src/components/NotifyCompRemoteBar/NotifyCompRemoteBar.tsx
new file mode 100644
index 0000000..5611ba6
--- /dev/null
+++ b/src/components/NotifyCompRemoteBar/NotifyCompRemoteBar.tsx
@@ -0,0 +1,208 @@
+import classNames from 'classnames';
+import { Container } from '@/components/Container';
+import { NotifyCompConnectionStatus } from '@/components/NotifyCompConnectionStatus';
+import { RemoteActivitySummaryList } from '@/components/RemoteActivitySummaryList';
+import { useCompetitionRemoteControl } from '@/hooks/useCompetitionRemoteControl';
+import { useNotifyCompWebSocketStatus } from '@/hooks/useNotifyCompWebSocketStatus';
+import { useNow } from '@/hooks/useNow';
+import { RemoteActivityGroup } from '@/lib/notifyCompRemoteActivities';
+import { canUseNotifyCompRemoteControls } from '@/lib/notifyCompWebSocketStatus';
+import { useConfirm } from '@/providers/ConfirmProvider';
+import {
+  formatElapsedDuration,
+  formatNextActivityOffset,
+  getRemoteBarProgress,
+} from './remoteBarProgress';
+
+interface NotifyCompRemoteBarProps {
+  competitionId: string;
+}
+
+const iconButtonClassName =
+  'flex h-10 w-10 items-center justify-center rounded-full border border-tertiary-weak bg-panel text-lg leading-none text-default shadow-sm hover-transition hover:bg-gray-100 disabled:cursor-not-allowed disabled:opacity-40 dark:hover:bg-gray-700';
+const primaryButtonClassName =
+  'flex h-10 w-10 items-center justify-center rounded-full border border-blue-300 bg-blue-200 text-lg leading-none text-gray-900 shadow-sm hover-transition hover:bg-blue-300 disabled:cursor-not-allowed disabled:opacity-40 dark:border-blue-600 dark:bg-blue-700 dark:text-white dark:hover:bg-blue-600';
+
+export function NotifyCompRemoteBar({ competitionId }: NotifyCompRemoteBarProps) {
+  const confirm = useConfirm();
+  const remote = useCompetitionRemoteControl({ competitionId });
+  const notifyCompWebSocketStatus = useNotifyCompWebSocketStatus();
+  const now = useNow();
+
+  if (!remote.isAuthenticated || !remote.competition || remote.scheduledActivities.length === 0) {
+    return null;
+  }
+
+  const activeNames = remote.activeGroups.map((group) => group.name);
+  const hasActiveGroups = activeNames.length > 0;
+  const currentTitle = activeNames.length > 0 ? activeNames.join(', ') : 'No active activity';
+  const nextTitle = remote.nextGroup?.name || 'No next activity';
+  const elapsed = formatElapsedDuration(remote.activeGroups, now);
+  const nextOffset = formatNextActivityOffset(remote.nextGroup, now);
+  const progress = getRemoteBarProgress({
+    activeGroups: remote.activeGroups,
+    now,
+  });
+  const progressBarClassName = classNames('block h-full rounded-full', {
+    'bg-blue-500 dark:bg-blue-400': progress.tone === 'normal',
+    'bg-yellow-400 dark:bg-yellow-300': progress.tone === 'warning',
+    'bg-red-500 dark:bg-red-400': progress.tone === 'overdue',
+  });
+  const activeActivities = remote.activeGroups.flatMap((group) => group.scheduledActivities);
+  const controlsDisabled =
+    remote.isSaving || !canUseNotifyCompRemoteControls(notifyCompWebSocketStatus.status);
+
+  const confirmNextGroup = (group: RemoteActivityGroup) =>
+    confirm({
+      confirmLabel: 'Advance',
+      message: (
+        <div className="space-y-4">
+          <p>
+            Advance to <strong>{group.name}</strong>? This will update Live Activities for this
+            competition.
+          </p>
+          {activeActivities.length > 0 && (
+            <div className="space-y-2">
+              <p className="type-label">Activities that will stop</p>
+              <RemoteActivitySummaryList activities={activeActivities} roundingMinutes={1} />
+            </div>
+          )}
+          <div className="space-y-2">
+            <p className="type-label">Activities that will start</p>
+            <RemoteActivitySummaryList activities={group.scheduledActivities} roundingMinutes={1} />
+          </div>
+        </div>
+      ),
+    });
+
+  const confirmFinishCompetition = () =>
+    confirm({
+      confirmLabel: 'Finish competition',
+      message: (
+        <div className="space-y-4">
+          <p>
+            Finish this competition? This will set an end time for the final active Live Activities.
+          </p>
+          <div className="space-y-2">
+            <p className="type-label">Activities that will stop</p>
+            <RemoteActivitySummaryList activities={activeActivities} roundingMinutes={1} />
+          </div>
+        </div>
+      ),
+    });
+
+  const runSwitch = async (direction: 'previous' | 'next') => {
+    const group = direction === 'previous' ? remote.previousGroup : remote.nextGroup;
+
+    if (direction === 'previous') {
+      await remote.switchToPreviousGroup();
+      return;
+    }
+
+    if (direction === 'next' && !group && hasActiveGroups) {
+      if (await confirmFinishCompetition()) {
+        await remote.finishAllActivities();
+      }
+      return;
+    }
+
+    if (direction === 'next' && group && !(await confirmNextGroup(group))) {
+      return;
+    }
+
+    await remote.switchToGroup(group);
+  };
+
+  const togglePlayback = async () => {
+    if (remote.activeGroups.length > 0) {
+      await Promise.all(remote.activeGroups.map((group) => remote.stopGroup(group)));
+      return;
+    }
+
+    if (remote.nextGroup && !(await confirmNextGroup(remote.nextGroup))) {
+      return;
+    }
+
+    await remote.switchToGroup(remote.nextGroup);
+  };
+
+  return (
+    <nav
+      aria-label="Remote control"
+      className="z-20 w-full border-t border-tertiary-weak bg-panel shadow-md shadow-tertiary-dark print:hidden">
+      <Container
+        fullWidth
+        className="relative flex-row min-h-16 items-center justify-center px-2 py-2">
+        <div
+          className={classNames(
+            'grid w-full max-w-4xl grid-cols-[minmax(0,1fr)_auto_minmax(0,1fr)] items-center gap-2 md:gap-4',
+            {
+              'opacity-60': remote.isLoading,
+            },
+          )}>
+          <div className="min-w-0 space-y-0.5 text-left">
+            <div className="text-xs font-medium uppercase leading-none text-muted">Current</div>
+            <div className="truncate text-sm font-medium text-default">{currentTitle}</div>
+            {hasActiveGroups && <div className="text-sm tabular-nums text-muted">{elapsed}</div>}
+          </div>
+
+          <div className="flex w-40 flex-col justify-center space-y-1 sm:w-48 md:w-64">
+            <div className="flex items-center justify-center gap-2">
+              <button
+                type="button"
+                className={iconButtonClassName}
+                disabled={controlsDisabled || !remote.previousGroup}
+                aria-label="Go back to previous remote activity"
+                onClick={() => {
+                  void runSwitch('previous');
+                }}>
+                <span className="fa fa-arrow-left" aria-hidden="true" />
+              </button>
+
+              <button
+                type="button"
+                className={primaryButtonClassName}
+                disabled={
+                  controlsDisabled || (remote.activeGroups.length === 0 && !remote.nextGroup)
+                }
+                aria-label={
+                  remote.activeGroups.length > 0
+                    ? 'Stop current remote activities'
+                    : 'Start next remote activity'
+                }
+                onClick={() => {
+                  void togglePlayback();
+                }}>
+                {remote.activeGroups.length > 0 ? <>&#9632;</> : <>&#9654;</>}
+              </button>
+
+              <button
+                type="button"
+                className={iconButtonClassName}
+                disabled={controlsDisabled || (!remote.nextGroup && !hasActiveGroups)}
+                aria-label={remote.nextGroup ? 'Go to next remote activity' : 'Finish competition'}
+                onClick={() => {
+                  void runSwitch('next');
+                }}>
+                <span className="fa fa-arrow-right" aria-hidden="true" />
+              </button>
+            </div>
+
+            <div className="flex h-4 items-center">
+              <div className="h-1 w-full overflow-hidden rounded-full bg-tertiary">
+                <span className={progressBarClassName} style={{ width: `${progress.percent}%` }} />
+              </div>
+            </div>
+          </div>
+
+          <div className="min-w-0 space-y-0.5 text-right">
+            <div className="text-xs font-medium uppercase leading-none text-muted">Next</div>
+            <div className="truncate text-sm font-medium text-default">{nextTitle}</div>
+            <div className="truncate text-sm text-muted">{nextOffset}</div>
+          </div>
+          <NotifyCompConnectionStatus compact className="col-span-3 -mt-1" />
+        </div>
+      </Container>
+    </nav>
+  );
+}
diff --git a/src/components/NotifyCompRemoteBar/index.ts b/src/components/NotifyCompRemoteBar/index.ts
new file mode 100644
index 0000000..dd69b8a
--- /dev/null
+++ b/src/components/NotifyCompRemoteBar/index.ts
@@ -0,0 +1 @@
+export * from './NotifyCompRemoteBar';
diff --git a/src/components/NotifyCompRemoteBar/remoteBarProgress.test.ts b/src/components/NotifyCompRemoteBar/remoteBarProgress.test.ts
new file mode 100644
index 0000000..dca0a94
--- /dev/null
+++ b/src/components/NotifyCompRemoteBar/remoteBarProgress.test.ts
@@ -0,0 +1,176 @@
+import { RemoteActivityGroup } from '@/lib/notifyCompRemoteActivities';
+import {
+  formatElapsedDuration,
+  formatElapsedMMSS,
+  formatNextActivityOffset,
+  getRemoteBarProgress,
+} from './remoteBarProgress';
+
+const group = (overrides: Partial<RemoteActivityGroup>): RemoteActivityGroup => ({
+  id: '333-r1-g1',
+  liveActivities: [],
+  name: '3x3x3 Cube, Round 1, Group 1',
+  scheduledActivities: [
+    {
+      activityCode: '333-r1-g1',
+      childActivities: [],
+      endTime: '2026-06-01T10:10:00Z',
+      extensions: [],
+      id: 101,
+      name: '3x3x3 Cube, Round 1, Group 1',
+      room: {
+        id: 1,
+        name: 'Stage 1',
+      } as RemoteActivityGroup['scheduledActivities'][number]['room'],
+      startTime: '2026-06-01T10:00:00Z',
+    },
+  ],
+  status: 'next',
+  ...overrides,
+});
+
+describe('remoteBarProgress', () => {
+  it('formats elapsed live activity time as MM:SS', () => {
+    expect(formatElapsedMMSS('2026-06-01T10:01:05Z', new Date('2026-06-01T10:06:09Z'))).toBe(
+      '05:04',
+    );
+  });
+
+  it('formats elapsed time against scheduled activity duration', () => {
+    expect(
+      formatElapsedDuration(
+        [
+          group({
+            liveActivities: [
+              {
+                activityId: 101,
+                endTime: null,
+                startTime: '2026-06-01T10:01:05Z',
+              },
+            ],
+            status: 'current',
+          }),
+        ],
+        new Date('2026-06-01T10:06:09Z'),
+      ),
+    ).toBe('05:04 / 10 minutes');
+  });
+
+  it('describes how many minutes remain until the next activity', () => {
+    expect(
+      formatNextActivityOffset(
+        group({
+          name: 'Clock, Round 1, Group 1',
+          scheduledActivities: [
+            {
+              ...group({}).scheduledActivities[0],
+              startTime: '2026-06-01T10:14:15Z',
+            },
+          ],
+        }),
+        new Date('2026-06-01T10:10:00Z'),
+      ),
+    ).toBe('In 5 minutes');
+  });
+
+  it('describes how many minutes late the next activity is', () => {
+    expect(
+      formatNextActivityOffset(
+        group({
+          scheduledActivities: [
+            {
+              ...group({}).scheduledActivities[0],
+              startTime: '2026-06-01T10:05:00Z',
+            },
+          ],
+        }),
+        new Date('2026-06-01T10:10:00Z'),
+      ),
+    ).toBe('5 minutes ago');
+  });
+
+  it('describes far future activity starts in hours', () => {
+    expect(
+      formatNextActivityOffset(
+        group({
+          scheduledActivities: [
+            {
+              ...group({}).scheduledActivities[0],
+              startTime: '2026-06-01T13:45:00Z',
+            },
+          ],
+        }),
+        new Date('2026-06-01T10:10:00Z'),
+      ),
+    ).toBe('In 4 hours');
+  });
+
+  it('fills progress based on live start time and scheduled activity duration', () => {
+    expect(
+      getRemoteBarProgress({
+        activeGroups: [
+          group({
+            liveActivities: [
+              {
+                activityId: 101,
+                endTime: null,
+                startTime: '2026-06-01T10:00:00Z',
+              },
+            ],
+            status: 'current',
+          }),
+        ],
+        now: new Date('2026-06-01T10:05:00Z'),
+      }),
+    ).toEqual({
+      percent: 50,
+      tone: 'normal',
+    });
+  });
+
+  it('uses a warning tone once the activity is within 5 percent of done', () => {
+    expect(
+      getRemoteBarProgress({
+        activeGroups: [
+          group({
+            liveActivities: [
+              {
+                activityId: 101,
+                endTime: null,
+                startTime: '2026-06-01T10:00:00Z',
+              },
+            ],
+            status: 'current',
+          }),
+        ],
+        now: new Date('2026-06-01T10:09:30Z'),
+      }),
+    ).toEqual({
+      percent: 95,
+      tone: 'warning',
+    });
+  });
+
+  it('uses an overdue tone once the scheduled duration has elapsed', () => {
+    expect(
+      getRemoteBarProgress({
+        activeGroups: [
+          group({
+            liveActivities: [
+              {
+                activityId: 101,
+                endTime: null,
+                startTime: '2026-06-01T10:00:00Z',
+              },
+            ],
+            status: 'current',
+          }),
+        ],
+        now: new Date('2026-06-01T10:11:00Z'),
+      }),
+    ).toEqual({
+      percent: 100,
+      tone: 'overdue',
+    });
+  });
+});
diff --git a/src/components/NotifyCompRemoteBar/remoteBarProgress.ts b/src/components/NotifyCompRemoteBar/remoteBarProgress.ts
new file mode 100644
index 0000000..6761489
--- /dev/null
+++ b/src/components/NotifyCompRemoteBar/remoteBarProgress.ts
@@ -0,0 +1,154 @@
+import { RemoteActivityGroup } from '@/lib/notifyCompRemoteActivities';
+
+const SECOND = 1000;
+const MINUTE = 60 * SECOND;
+
+const clampPercent = (value: number) => Math.min(100, Math.max(0, value));
+
+const getTime = (isoString?: string | null) => {
+  if (!isoString) {
+    return undefined;
+  }
+
+  const time = new Date(isoString).getTime();
+  return Number.isNaN(time) ? undefined : time;
+};
+
+const getEarliestTime = (times: Array<number | undefined>) => {
+  const validTimes = times.filter((time): time is number => time !== undefined);
+  return validTimes.length ? Math.min(...validTimes) : undefined;
+};
+
+const getLatestTime = (times: Array<number | undefined>) => {
+  const validTimes = times.filter((time): time is number => time !== undefined);
+  return validTimes.length ? Math.max(...validTimes) : undefined;
+};
+
+export const formatElapsedMMSS = (startTime: number | string | undefined, now: Date) => {
+  const start = typeof startTime === 'number' ? startTime : getTime(startTime);
+
+  if (start === undefined) {
+    return '00:00';
+  }
+
+  const elapsedSeconds = Math.max(0, Math.floor((now.getTime() - start) / SECOND));
+  const minutes = Math.floor(elapsedSeconds / 60);
+  const seconds = elapsedSeconds % 60;
+
+  return `${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
+};
+
+export const getGroupScheduledStartTime = (group?: RemoteActivityGroup) =>
+  getEarliestTime(group?.scheduledActivities.map((activity) => getTime(activity.startTime)) || []);
+
+const getActiveGroupsScheduledStartTime = (groups: RemoteActivityGroup[]) =>
+  getEarliestTime(
+    groups.flatMap((group) =>
+      group.scheduledActivities.map((activity) => getTime(activity.startTime)),
+    ),
+  );
+
+const getActiveGroupsScheduledEndTime = (groups: RemoteActivityGroup[]) =>
+  getLatestTime(
+    groups.flatMap((group) =>
+      group.scheduledActivities.map((activity) => getTime(activity.endTime)),
+    ),
+  );
+
+export const getActiveGroupStartTime = (groups: RemoteActivityGroup[]) =>
+  getEarliestTime(
+    groups.flatMap((group) => {
+      const liveStartTimes = group.liveActivities
+        .filter((activity) => activity.startTime && !activity.endTime)
+        .map((activity) => getTime(activity.startTime));
+
+      if (liveStartTimes.length > 0) {
+        return liveStartTimes;
+      }
+
+      return group.scheduledActivities.map((activity) => getTime(activity.startTime));
+    }),
+  );
+
+export const getActiveGroupsScheduledDuration = (groups: RemoteActivityGroup[]) => {
+  const start = getActiveGroupsScheduledStartTime(groups);
+  const end = getActiveGroupsScheduledEndTime(groups);
+
+  if (start === undefined || end === undefined || end <= start) {
+    return undefined;
+  }
+
+  return end - start;
+};
+
+const formatDurationMinutes = (duration: number | undefined) => {
+  if (duration === undefined) {
+    return '0 minutes';
+  }
+
+  const minutes = Math.max(1, Math.round(duration / MINUTE));
+  const unit = minutes === 1 ? 'minute' : 'minutes';
+
+  return `${minutes} ${unit}`;
+};
+
+export const formatElapsedDuration = (groups: RemoteActivityGroup[], now: Date) =>
+  `${formatElapsedMMSS(getActiveGroupStartTime(groups), now)} / ${formatDurationMinutes(
+    getActiveGroupsScheduledDuration(groups),
+  )}`;
+
+export const formatNextActivityOffset = (nextGroup: RemoteActivityGroup | undefined, now: Date) => {
+  const nextStart = getGroupScheduledStartTime(nextGroup);
+
+  if (!nextGroup || nextStart === undefined) {
+    return 'No next activity';
+  }
+
+  const offsetMs = nextStart - now.getTime();
+  const absoluteOffsetMinutes = Math.max(1, Math.ceil(Math.abs(offsetMs) / MINUTE));
+  const minuteUnit = absoluteOffsetMinutes === 1 ? 'minute' : 'minutes';
+
+  if (offsetMs < 0) {
+    return `${absoluteOffsetMinutes} ${minuteUnit} ago`;
+  }
+
+  if (absoluteOffsetMinutes < 60) {
+    return `In ${absoluteOffsetMinutes} ${minuteUnit}`;
+  }
+
+  const remainingHours = Math.ceil(absoluteOffsetMinutes / 60);
+  const unit = remainingHours === 1 ? 'hour' : 'hours';
+
+  return `In ${remainingHours} ${unit}`;
+};
+
+export const getRemoteBarProgress = ({
+  activeGroups,
+  now,
+}: {
+  activeGroups: RemoteActivityGroup[];
+  now: Date;
+}) => {
+  const activeStart = getActiveGroupStartTime(activeGroups);
+  const duration = getActiveGroupsScheduledDuration(activeGroups);
+
+  if (activeStart === undefined || duration === undefined) {
+    return {
+      percent: 0,
+      tone: 'normal' as const,
+    };
+  }
+
+  const elapsed = Math.max(0, now.getTime() - activeStart);
+  const percent = (elapsed / duration) * 100;
+
+  return {
+    percent: clampPercent(percent),
+    tone:
+      percent > 100
+        ? ('overdue' as const)
+        : percent >= 95
+          ? ('warning' as const)
+          : ('normal' as const),
+  };
+};
diff --git a/src/components/RemoteActivitySummaryList/RemoteActivitySummaryList.stories.tsx b/src/components/RemoteActivitySummaryList/RemoteActivitySummaryList.stories.tsx
new file mode 100644
index 0000000..fc428f4
--- /dev/null
+++ b/src/components/RemoteActivitySummaryList/RemoteActivitySummaryList.stories.tsx
@@ -0,0 +1,60 @@
+import type { Meta, StoryObj } from '@storybook/react';
+import { RemoteScheduledActivity } from '@/lib/notifyCompRemoteActivities';
+import { storybookCompetitionFixture } from '@/storybook/competitionFixtures';
+import { RemoteActivitySummaryList } from './RemoteActivitySummaryList';
+
+const venue = storybookCompetitionFixture.schedule.venues[0];
+const mainRoom = venue.rooms[0];
+const sideRoom = venue.rooms[1];
+
+const scheduledActivity = (
+  room: typeof mainRoom,
+  parentIndex: number,
+  childIndex: number,
+): RemoteScheduledActivity => {
+  const parent = room.activities[parentIndex];
+  const child = parent.childActivities[childIndex] || parent;
+
+  return {
+    ...child,
+    parent,
+    room: {
+      ...room,
+      venue: {
+        timezone: venue.timezone,
+      },
+    },
+  } as RemoteScheduledActivity;
+};
+
+const meta = {
+  title: 'Components/Competition/Remote Activity Summary List',
+  component: RemoteActivitySummaryList,
+  decorators: [
+    (Story) => (
+      <div className="w-full max-w-lg bg-panel p-4">
+        <Story />
+      </div>
+    ),
+  ],
+  parameters: {
+    layout: 'padded',
+  },
+  tags: ['autodocs'],
+} satisfies Meta<typeof RemoteActivitySummaryList>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const SingleStage: Story = {
+  args: {
+    activities: [scheduledActivity(mainRoom, 0, 0)],
+  },
+};
+
+export const MultipleStages: Story = {
+  args: {
+    activities: [scheduledActivity(mainRoom, 0, 0), scheduledActivity(sideRoom, 0, 0)],
+  },
+};
diff --git a/src/components/RemoteActivitySummaryList/RemoteActivitySummaryList.tsx b/src/components/RemoteActivitySummaryList/RemoteActivitySummaryList.tsx
new file mode 100644
index 0000000..58e1e63
--- /dev/null
+++ b/src/components/RemoteActivitySummaryList/RemoteActivitySummaryList.tsx
@@ -0,0 +1,49 @@
+import { RoomPill } from '@/components/Pill';
+import { getRoomData } from '@/lib/activities';
+import { RemoteScheduledActivity } from '@/lib/notifyCompRemoteActivities';
+import { formatTimeRange } from '@/lib/time';
+
+interface RemoteActivitySummaryListProps {
+  activities: RemoteScheduledActivity[];
+  roundingMinutes?: number;
+}
+
+const activityTimeZone = (activity: RemoteScheduledActivity) =>
+  (activity.room as RemoteScheduledActivity['room'] & { venue?: { timezone?: string } }).venue
+    ?.timezone;
+
+export function RemoteActivitySummaryList({
+  activities,
+  roundingMinutes = 5,
+}: RemoteActivitySummaryListProps) {
+  return (
+    <ul className="divide-y divide-tertiary-weak">
+      {activities.map((activity) => {
+        const stage = getRoomData(activity.room, activity);
+
+        return (
+          <li key={activity.id} className="flex flex-col py-2 type-body">
+            <span className="type-body-sm font-medium">{activity.name}</span>
+            <span className="flex items-start justify-between gap-4 type-meta">
+              <RoomPill
+                className="px-1"
+                style={{
+                  backgroundColor: `${stage.color}70`,
+                }}>
+                {stage.name}
+              </RoomPill>
+              <span className="ml-auto shrink-0 whitespace-nowrap text-right">
+                {formatTimeRange(
+                  activity.startTime,
+                  activity.endTime,
+                  roundingMinutes,
+                  activityTimeZone(activity),
+                )}
+              </span>
+            </span>
+          </li>
+        );
+      })}
+    </ul>
+  );
+}
diff --git a/src/components/RemoteActivitySummaryList/index.ts b/src/components/RemoteActivitySummaryList/index.ts
new file mode 100644
index 0000000..309ef17
--- /dev/null
+++ b/src/components/RemoteActivitySummaryList/index.ts
@@ -0,0 +1 @@
+export * from './RemoteActivitySummaryList';
diff --git a/src/components/RoundActionPicker/RoundActionPicker.stories.tsx b/src/components/RoundActionPicker/RoundActionPicker.stories.tsx
new file mode 100644
index 0000000..fed8ab2
--- /dev/null
+++ b/src/components/RoundActionPicker/RoundActionPicker.stories.tsx
@@ -0,0 +1,68 @@
+import type { Meta, StoryObj } from '@storybook/react';
+import { RoundActionPicker } from './RoundActionPicker';
+import { RoundActionPickerEvent } from './types';
+
+const events: RoundActionPickerEvent[] = [
+  {
+    id: '333',
+    name: '3x3x3 Cube',
+    rounds: [
+      { id: '333-r1', roundNumber: 1, groupCount: 5, resultStatus: 'now' },
+      { id: '333-r2', roundNumber: 2, groupCount: 3 },
+      { id: '333-r3', roundNumber: 3, groupCount: 1 },
+    ],
+  },
+  {
+    id: '444',
+    name: '4x4x4 Cube',
+    rounds: [
+      { id: '444-r1', roundNumber: 1, groupCount: 4, resultStatus: 'done' },
+      { id: '444-r2', roundNumber: 2, groupCount: 1 },
+    ],
+  },
+  {
+    id: '555',
+    name: '5x5x5 Cube',
+    rounds: [{ id: '555-r1', roundNumber: 1, groupCount: 3, resultStatus: 'done' }],
+  },
+  {
+    id: '333bf',
+    name: '3x3x3 Blindfolded',
+    rounds: [
+      { id: '333bf-r1', roundNumber: 1, groupCount: 2, resultStatus: 'done' },
+      { id: '333bf-r2', roundNumber: 2, groupCount: 1 },
+    ],
+  },
+];
+
+const meta = {
+  title: 'Components/Competition/RoundActionPicker',
+  component: RoundActionPicker,
+  decorators: [
+    (Story) => (
+      <div className="w-full max-w-5xl p-4">
+        <Story />
+      </div>
+    ),
+  ],
+  args: {
+    events,
+  },
+  tags: ['autodocs'],
+} satisfies Meta<typeof RoundActionPicker>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Groups: Story = {
+  args: {
+    mode: 'groups',
+  },
+};
+
+export const Results: Story = {
+  args: {
+    mode: 'results',
+  },
+};
diff --git a/src/components/RoundActionPicker/RoundActionPicker.tsx b/src/components/RoundActionPicker/RoundActionPicker.tsx
new file mode 100644
index 0000000..f96870a
--- /dev/null
+++ b/src/components/RoundActionPicker/RoundActionPicker.tsx
@@ -0,0 +1,127 @@
+import classNames from 'classnames';
+import { AnchorLink } from '@/lib/linkRenderer';
+import { RoundActionPickerEvent, RoundActionPickerMode, RoundActionPickerProps } from './types';
+
+export type RoundResultStatus = RoundActionPickerEvent['rounds'][number]['resultStatus'];
+
+const modeConfig: Record<
+  RoundActionPickerMode,
+  {
+    actionLabel: string;
+  }
+> = {
+  groups: {
+    actionLabel: 'Choose group',
+  },
+  results: {
+    actionLabel: 'View results',
+  },
+};
+
+const resultStatusLabel: Record<
+  NonNullable<RoundActionPickerEvent['rounds'][number]['resultStatus']>,
+  string
+> = {
+  now: 'Now',
+  done: 'Done',
+};
+
+const resultStatusClassName: Record<
+  NonNullable<RoundActionPickerEvent['rounds'][number]['resultStatus']>,
+  string
+> = {
+  now: 'bg-amber-100 text-amber-900 ring-amber-300 dark:bg-amber-900 dark:text-amber-100 dark:ring-amber-700',
+  done: 'bg-blue-100 text-blue-900 ring-blue-300 dark:bg-blue-900 dark:text-blue-100 dark:ring-blue-700',
+};
+
+function EventIcon({ eventId }: { eventId: string }) {
+  return <span className={`cubing-icon event-${eventId}`} aria-hidden="true" />;
+}
+
+export function RoundResultStatusBadge({
+  status,
+  size = 'default',
+}: {
+  status: RoundResultStatus;
+  size?: 'default' | 'sm';
+}) {
+  if (!status) {
+    return <span aria-hidden="true" />;
+  }
+
+  return (
+    <span
+      className={classNames(
+        'inline-flex items-center rounded-md ring-1 ring-inset',
+        size === 'sm' ? 'px-1.5 py-0.5 text-[0.65rem]' : 'px-2 py-1 type-body-xs',
+        resultStatusClassName[status],
+      )}>
+      {resultStatusLabel[status]}
+    </span>
+  );
+}
+
+function RoundMetric({
+  mode,
+  groupCount,
+  resultStatus,
+}: {
+  mode: RoundActionPickerMode;
+  groupCount?: number;
+  resultStatus?: RoundActionPickerEvent['rounds'][number]['resultStatus'];
+}) {
+  if (mode === 'groups') {
+    return (
+      <span className="inline-flex min-w-10 items-center justify-end tabular-nums">
+        {groupCount ?? 0}
+      </span>
+    );
+  }
+
+  return <RoundResultStatusBadge status={resultStatus} size="sm" />;
+}
+
+export function RoundActionPicker({
+  mode,
+  events,
+  LinkComponent = AnchorLink,
+}: RoundActionPickerProps) {
+  const config = modeConfig[mode];
+
+  return (
+    <section className="w-full type-body">
+      <div className="overflow-hidden rounded-md border border-tertiary-weak bg-panel shadow-sm">
+        {events.map((event) => (
+          <div key={event.id} className="border-t border-tertiary-weak first:border-t-0">
+            {event.rounds.map((round, roundIndex) => (
+              <LinkComponent
+                key={round.id}
+                to={round.href ?? '#'}
+                className="grid min-h-12 grid-cols-[minmax(10rem,24rem)_7rem_minmax(0,1fr)_8rem] items-center gap-2 px-3 py-2 text-default hover-transition hover:bg-gray-100 dark:hover:bg-gray-800">
+                <span className="flex min-w-0 items-center gap-2">
+                  {roundIndex === 0 && (
+                    <>
+                      <EventIcon eventId={event.id} />
+                      <span className="truncate">{event.name}</span>
+                    </>
+                  )}
+                </span>
+                <span>{`Round ${round.roundNumber}`}</span>
+                <span aria-hidden="true" />
+                <span className="flex items-center justify-end gap-2">
+                  <RoundMetric
+                    mode={mode}
+                    groupCount={round.groupCount}
+                    resultStatus={round.resultStatus}
+                  />
+                  <span className="sr-only">{config.actionLabel}</span>
+                  <span className="fa fa-chevron-right text-muted" aria-hidden="true" />
+                </span>
+              </LinkComponent>
+            ))}
+          </div>
+        ))}
+      </div>
+    </section>
+  );
+}
diff --git a/src/components/RoundActionPicker/index.ts b/src/components/RoundActionPicker/index.ts
new file mode 100644
index 0000000..d497054
--- /dev/null
+++ b/src/components/RoundActionPicker/index.ts
@@ -0,0 +1,2 @@
+export * from './RoundActionPicker';
+export * from './types';
diff --git a/src/components/RoundActionPicker/types.ts b/src/components/RoundActionPicker/types.ts
new file mode 100644
index 0000000..3a4f8b1
--- /dev/null
+++ b/src/components/RoundActionPicker/types.ts
@@ -0,0 +1,23 @@
+import { LinkRenderer } from '@/lib/linkRenderer';
+
+export type RoundActionPickerMode = 'groups' | 'results';
+
+export interface RoundActionPickerRound {
+  id: string;
+  roundNumber: number;
+  groupCount?: number;
+  resultStatus?: 'now' | 'done';
+  href?: string;
+}
+
+export interface RoundActionPickerEvent {
+  id: string;
+  name: string;
+  rounds: RoundActionPickerRound[];
+}
+
+export interface RoundActionPickerProps {
+  mode: RoundActionPickerMode;
+  events: RoundActionPickerEvent[];
+  LinkComponent?: LinkRenderer;
+}
diff --git a/src/components/StyledNavLink/StyledNavLink.tsx b/src/components/StyledNavLink/StyledNavLink.tsx
index a110d85..cce056f 100644
--- a/src/components/StyledNavLink/StyledNavLink.tsx
+++ b/src/components/StyledNavLink/StyledNavLink.tsx
@@ -11,11 +11,12 @@ export const StyledNavLink: React.FC<StyledNavLinkProps> = ({
   to,
   text,
   className,
+  end = true,
   ...props
 }: StyledNavLinkProps) => (
   <NavLink
     {...props}
-    end
+    end={end}
     to={to}
     className={({ isActive }) =>
       classNames('link-nav', className, {
diff --git a/src/components/index.ts b/src/components/index.ts
index 209c315..38a0b25 100644
--- a/src/components/index.ts
+++ b/src/components/index.ts
@@ -16,4 +16,7 @@ export * from './LastFetchedAt';
 export * from './LinkButton';
 export * from './LoggedOutPromptCard';
 export * from './Notebox';
+export * from './NotifyCompConnectionStatus';
+export * from './NotifyCompRemoteBar';
 export * from './PinCompetitionButton';
+export * from './RemoteActivitySummaryList';
diff --git a/src/containers/CompetitionEvents/CompetitionEvents.tsx b/src/containers/CompetitionEvents/CompetitionEvents.tsx
index 455a7f4..245e312 100644
--- a/src/containers/CompetitionEvents/CompetitionEvents.tsx
+++ b/src/containers/CompetitionEvents/CompetitionEvents.tsx
@@ -1,14 +1,14 @@
-import { parseActivityCode } from '@wca/helpers';
 import { useCallback, useEffect, useMemo } from 'react';
-import { useTranslation } from 'react-i18next';
 import { Container } from '@/components/Container';
+import { RoundActionPicker } from '@/components/RoundActionPicker';
 import { groupActivitiesByRound } from '@/lib/activities';
 import { getAllEvents, getEventName } from '@/lib/events';
+import { AnchorLink, LinkRenderer } from '@/lib/linkRenderer';
 import { useWCIF } from '@/providers/WCIFProvider';
 
 export interface CompetitionEventsContainerProps {
   competitionId: string;
-  onNavigate?: (to: string) => void;
+  LinkComponent?: LinkRenderer;
 }
 
 function onlyUnique(value, index, self) {
@@ -17,9 +17,8 @@ function onlyUnique(value, index, self) {
 
 export function CompetitionEventsContainer({
   competitionId,
-  onNavigate = (to) => window.location.assign(to),
+  LinkComponent = AnchorLink,
 }: CompetitionEventsContainerProps) {
-  const { t } = useTranslation();
   const { wcif, setTitle } = useWCIF();
 
   const uniqueGroupCountForRound = useCallback(
@@ -33,6 +32,20 @@ export function CompetitionEventsContainer({
   );
 
   const events = useMemo(() => (wcif ? getAllEvents(wcif) : []), [wcif]);
+  const pickerEvents = useMemo(
+    () =>
+      events.map((event) => ({
+        id: event.id,
+        name: getEventName(event.id, event),
+        rounds: event.rounds.map((round, index) => ({
+          id: round.id,
+          roundNumber: index + 1,
+          groupCount: uniqueGroupCountForRound(round.id),
+          href: `/competitions/${competitionId}/events/${round.id}`,
+        })),
+      })),
+    [competitionId, events, uniqueGroupCountForRound],
+  );
 
   useEffect(() => {
     setTitle('Events');
@@ -40,42 +53,8 @@ export function CompetitionEventsContainer({
 
   return (
     <Container className="pt-4">
-      <div className="flex w-full flex-col">
-        <div className="table-container">
-          <table className="table-base table-striped text-left type-body">
-            <thead className="table-header">
-              <tr>
-                <th className="table-header-cell">{t('common.wca.event')}</th>
-                <th className="table-header-cell-center">{t('common.wca.round')}</th>
-                <th className="table-header-cell-center">{t('common.wca.group_other')}</th>
-                <th className="table-header-cell">
-                  <span className="sr-only">{t('common.view')}</span>
-                </th>
-              </tr>
-            </thead>
-            <tbody>
-              {events.map((event) =>
-                event.rounds?.map((round, index) => {
-                  const url = `/competitions/${competitionId}/events/${round.id}`;
-
-                  return (
-                    <tr
-                      key={round.id}
-                      className="table-row-border-b table-row-hover-bg cursor-pointer"
-                      onClick={() => onNavigate(url)}>
-                      <td className="table-cell">{index === 0 ? getEventName(event.id) : ''}</td>
-                      <td className="table-cell-center">
-                        {parseActivityCode(round.id).roundNumber}
-                      </td>
-                      <td className="table-cell-center">{uniqueGroupCountForRound(round.id)}</td>
-                      <td className="table-cell text-right">{t('common.view')}</td>
-                    </tr>
-                  );
-                }),
-              )}
-            </tbody>
-          </table>
-        </div>
+      <div className="p-2">
+        <RoundActionPicker mode="groups" events={pickerEvents} LinkComponent={LinkComponent} />
       </div>
     </Container>
   );
diff --git a/src/containers/CompetitionGroup/CompetitionGroup.tsx b/src/containers/CompetitionGroup/CompetitionGroup.tsx
index 3c002ef..9d34634 100644
--- a/src/containers/CompetitionGroup/CompetitionGroup.tsx
+++ b/src/containers/CompetitionGroup/CompetitionGroup.tsx
@@ -158,7 +158,7 @@ export function CompetitionGroupContainer({
             <LinkComponent
               to={prevUrl || ''}
               className={classNames(
-                'my-1 flex w-full justify-end rounded-md border border-tertiary-weak p-2 px-2 transition-colors',
+                'my-1 flex w-full justify-end rounded-md border border-tertiary-weak p-2 px-2 hover-transition',
                 {
                   'pointer-events-none opacity-25': !prev,
                   'group cursor-pointer hover:bg-gray-100 dark:hover:bg-gray-700': prev,
@@ -170,7 +170,7 @@ export function CompetitionGroupContainer({
             <LinkComponent
               to={nextUrl || ''}
               className={classNames(
-                'group my-1 flex w-full rounded-md border border-tertiary-weak p-2 px-2 transition-colors hover:bg-gray-100 dark:hover:bg-gray-700',
+                'group my-1 flex w-full rounded-md border border-tertiary-weak p-2 px-2 hover-transition hover:bg-gray-100 dark:hover:bg-gray-700',
                 {
                   'pointer-events-none opacity-25': !next,
                 },
@@ -283,7 +283,7 @@ export function CompetitionGroupContainer({
             <LinkComponent
               to={prevUrl || ''}
               className={classNames(
-                'my-1 flex w-full justify-end rounded-md border border-tertiary-weak p-2 px-2 transition-colors',
+                'my-1 flex w-full justify-end rounded-md border border-tertiary-weak p-2 px-2 hover-transition',
                 {
                   'pointer-events-none opacity-25': !prev,
                   'group cursor-pointer hover:bg-gray-100 dark:hover:bg-gray-700': prev,
@@ -295,7 +295,7 @@ export function CompetitionGroupContainer({
             <LinkComponent
               to={nextUrl || ''}
               className={classNames(
-                'group my-1 flex w-full rounded-md border border-tertiary-weak p-2 px-2 transition-colors hover:bg-gray-100 dark:hover:bg-gray-700',
+                'group my-1 flex w-full rounded-md border border-tertiary-weak p-2 px-2 hover-transition hover:bg-gray-100 dark:hover:bg-gray-700',
                 {
                   'pointer-events-none opacity-25': !next,
                 },
@@ -371,7 +371,7 @@ export function CompetitionGroupContainer({
                         <LinkComponent
                           key={person.registrantId}
                           to={`/competitions/${competitionId}/persons/${person.registrantId}`}
-                          className="col-span-1 p-1 transition-colors duration-150 hover:bg-gray-100 hover:opacity-80 dark:text-white dark:hover:bg-gray-700">
+                          className="col-span-1 p-1 hover-transition hover:bg-gray-100 hover:opacity-80 dark:text-white dark:hover:bg-gray-700">
                           {person.name}
                         </LinkComponent>
                       ))}
diff --git a/src/containers/CompetitionLive/CompetitionLive.tsx b/src/containers/CompetitionLive/CompetitionLive.tsx
index 1fb8ce2..0a68b48 100644
--- a/src/containers/CompetitionLive/CompetitionLive.tsx
+++ b/src/containers/CompetitionLive/CompetitionLive.tsx
@@ -1,4 +1,4 @@
-import { Container } from '@/components/Container';
+import { Container, NotifyCompConnectionStatus } from '@/components';
 import { LiveActivities } from '@/containers/LiveActivities';
 
 export interface CompetitionLiveContainerProps {
@@ -12,6 +12,7 @@ export function CompetitionLiveContainer({ competitionId }: CompetitionLiveConta
         <i className="fa fa-tower-broadcast mr-1 text-green-500 type-heading" />
         <span className="type-heading">Live Activities </span>
       </div>
+      <NotifyCompConnectionStatus className="mx-2" />
       <LiveActivities competitionId={competitionId} />
     </Container>
   );
diff --git a/src/containers/CompetitionPerson/CompetitionPerson.tsx b/src/containers/CompetitionPerson/CompetitionPerson.tsx
index e56f64a..61442f5 100644
--- a/src/containers/CompetitionPerson/CompetitionPerson.tsx
+++ b/src/containers/CompetitionPerson/CompetitionPerson.tsx
@@ -1,8 +1,11 @@
 import { Person } from '@wca/helpers';
 import { Extension } from '@wca/helpers/lib/models/extension';
 import { useEffect } from 'react';
-import { Container } from '@/components/Container';
-import { PersonalScheduleContainer } from '@/containers/PersonalSchedule';
+import { Link, useLocation } from 'react-router-dom';
+import { CompetitionPersonalResultsContent } from '@/containers/CompetitionPersonalResults';
+import { PersonalBestsContainer } from '@/containers/PersonalBests';
+import { PersonalScheduleContent } from '@/containers/PersonalSchedule';
+import { PersonalPage, PersonalPageLayout } from '@/containers/PersonalSchedule/PersonalPageLayout';
 import { useWCIF } from '@/providers/WCIFProvider';
 
 export interface CompetitionPersonContainerProps {
@@ -10,7 +13,8 @@ export interface CompetitionPersonContainerProps {
 }
 
 export function CompetitionPersonContainer({ registrantId }: CompetitionPersonContainerProps) {
-  const { wcif, setTitle } = useWCIF();
+  const { competitionId, wcif, setTitle } = useWCIF();
+  const { pathname } = useLocation();
 
   const person = wcif?.persons?.find((p) => p.registrantId.toString() === registrantId) as
     | (Person & {
@@ -28,9 +32,27 @@ export function CompetitionPersonContainer({ registrantId }: CompetitionPersonCo
     return null;
   }
 
+  const activePage: PersonalPage = pathname.endsWith('/results')
+    ? 'results'
+    : pathname.endsWith('/records')
+      ? 'records'
+      : 'schedule';
+
+  const content = (() => {
+    if (activePage === 'results') {
+      return <CompetitionPersonalResultsContent person={person} LinkComponent={Link} />;
+    }
+
+    if (activePage === 'records') {
+      return person.wcaId ? <PersonalBestsContainer wcif={wcif} person={person} /> : null;
+    }
+
+    return <PersonalScheduleContent person={person} />;
+  })();
+
   return (
-    <Container>
-      <PersonalScheduleContainer person={person} />
-    </Container>
+    <PersonalPageLayout activePage={activePage} competitionId={competitionId} person={person}>
+      {content}
+    </PersonalPageLayout>
   );
 }
diff --git a/src/containers/CompetitionPersonalBests/CompetitionPersonalBests.tsx b/src/containers/CompetitionPersonalBests/CompetitionPersonalBests.tsx
index d5ea777..ca03111 100644
--- a/src/containers/CompetitionPersonalBests/CompetitionPersonalBests.tsx
+++ b/src/containers/CompetitionPersonalBests/CompetitionPersonalBests.tsx
@@ -1,6 +1,6 @@
 import { useEffect } from 'react';
-import { Container } from '@/components/Container';
 import { PersonalBestsContainer } from '@/containers/PersonalBests';
+import { PersonalPageLayout } from '@/containers/PersonalSchedule/PersonalPageLayout';
 import { useWCIF } from '@/providers/WCIFProvider';
 
 export interface CompetitionPersonalBestsContainerProps {
@@ -26,8 +26,8 @@ export function CompetitionPersonalBestsContainer({
   }
 
   return (
-    <Container>
+    <PersonalPageLayout activePage="records" competitionId={wcif.id} person={person}>
       <PersonalBestsContainer wcif={wcif} person={person} />
-    </Container>
+    </PersonalPageLayout>
   );
 }
diff --git a/src/containers/CompetitionPersonalResults/CompetitionPersonalResults.stories.tsx b/src/containers/CompetitionPersonalResults/CompetitionPersonalResults.stories.tsx
new file mode 100644
index 0000000..8c448b7
--- /dev/null
+++ b/src/containers/CompetitionPersonalResults/CompetitionPersonalResults.stories.tsx
@@ -0,0 +1,20 @@
+import type { Meta, StoryObj } from '@storybook/react';
+import { makeCompetitionContainerDecorator } from '@/storybook/competitionStorybook';
+import { CompetitionPersonalResultsContainer } from './CompetitionPersonalResults';
+
+const meta = {
+  title: 'Containers/Competition/Personal Results',
+  component: CompetitionPersonalResultsContainer,
+  decorators: [makeCompetitionContainerDecorator()],
+  parameters: { layout: 'fullscreen' },
+  tags: ['autodocs'],
+} satisfies Meta<typeof CompetitionPersonalResultsContainer>;
+
+export default meta;
+type Story = StoryObj<typeof meta>;
+
+export const Competitor: Story = {
+  args: {
+    registrantId: '1',
+  },
+};
diff --git a/src/containers/CompetitionPersonalResults/CompetitionPersonalResults.test.tsx b/src/containers/CompetitionPersonalResults/CompetitionPersonalResults.test.tsx
new file mode 100644
index 0000000..90d5602
--- /dev/null
+++ b/src/containers/CompetitionPersonalResults/CompetitionPersonalResults.test.tsx
@@ -0,0 +1,304 @@
+import '@testing-library/jest-dom';
+import { fireEvent, render, screen, within } from '@testing-library/react';
+import { Competition } from '@wca/helpers';
+import { MemoryRouter } from 'react-router-dom';
+import { AnchorLink } from '@/lib/linkRenderer';
+import { CompetitionPersonalResultsContainer } from './CompetitionPersonalResults';
+
+let mockWcaLiveResults: unknown[] = [];
+let mockWcaCompetitionResults: unknown[] | undefined = [];
+let mockWcaCompetitionResultsStatus = 'success';
+
+jest.mock('@/components/Container', () => ({
+  Container: ({ children }: { children: React.ReactNode }) => <div>{children}</div>,
+}));
+
+jest.mock('@/lib/events', () => ({
+  getEventName: (eventId: string) => (eventId === '333' ? '3x3x3 Cube' : '4x4x4 Cube'),
+}));
+
+jest.mock('@/hooks/UsePinnedPersons', () => ({
+  usePinnedPersons: () => ({
+    pinnedPersons: [],
+    pinPerson: jest.fn(),
+    unpinPerson: jest.fn(),
+  }),
+}));
+
+jest.mock('@/hooks/queries/useWcaLive', () => ({
+  useWcaLiveCompetitorLink: () => ({
+    data: 'https://live.worldcubeassociation.org/competitions/TestComp2026/competitors/1',
+    status: 'success',
+  }),
+  useWcaLiveCompetitorResults: () => ({
+    data: mockWcaLiveResults,
+    status: 'success',
+  }),
+}));
+
+jest.mock('@/hooks/queries/useWcaResults', () => ({
+  useWcaCompetitionResults: () => ({
+    data: mockWcaCompetitionResults,
+    status: mockWcaCompetitionResultsStatus,
+  }),
+}));
+
+jest.mock('country-flag-icons', () => ({
+  hasFlag: () => true,
+}));
+
+jest.mock('country-flag-icons/unicode', () => ({
+  __esModule: true,
+  default: () => '🇺🇸',
+}));
+
+jest.mock('react-i18next', () => ({
+  useTranslation: () => ({
+    t: (key: string, options?: Record<string, unknown>) => {
+      if (key === 'competition.results.title') return 'Results';
+      if (key === 'competition.results.noResults') return 'No results yet.';
+      if (key === 'competition.results.rank') return '#';
+      if (key === 'competition.results.average') return 'Avg';
+      if (key === 'competition.results.best') return 'Best';
+      if (key === 'competition.results.attempts') return 'Attempts';
+      if (key === 'competition.results.allResults') return 'All results';
+      if (key === 'competition.results.viewLiveResults') return 'view live results';
+      if (key === 'competition.personalResults.eventResults') return 'Event results';
+      if (key === 'competition.personalSchedule.schedule') return 'Schedule';
+      if (key === 'competition.personalSchedule.results') return 'Results';
+      if (key === 'competition.personalSchedule.records') return 'Records';
+      if (key === 'common.close') return 'Close';
+      if (key === 'common.name') return 'Name';
+      if (key === 'common.wca.event') return 'Event';
+      if (key === 'common.wca.round') return 'Round';
+      if (key === 'common.loading') return 'Loading...';
+      if (key === 'common.activityCodeToName.round') return `Round ${options?.roundNumber}`;
+
+      return key;
+    },
+  }),
+}));
+
+const wcifMock = {
+  id: 'TestComp2026',
+  schedule: {
+    startDate: '2026-05-03',
+    numberOfDays: 2,
+    venues: [],
+  },
+  persons: [
+    {
+      registrantId: 1,
+      name: 'Vikram Haldar',
+      wcaUserId: 1001,
+      wcaId: '2010HALD01',
+      countryIso2: 'US',
+      registration: null,
+      extensions: [],
+    },
+  ],
+  events: [
+    {
+      id: '333',
+      extensions: [],
+      rounds: [
+        {
+          id: '333-r1',
+          format: 'a',
+          cutoff: null,
+          timeLimit: null,
+          advancementCondition: null,
+          results: [
+            {
+              personId: 1,
+              ranking: 2,
+              attempts: [
+                { result: 690, reconstruction: null },
+                { result: 732, reconstruction: null },
+                { result: 786, reconstruction: null },
+                { result: 1034, reconstruction: null },
+                { result: 705, reconstruction: null },
+              ],
+              best: 690,
+              average: 741,
+            },
+          ],
+          extensions: [],
+        },
+      ],
+    },
+    {
+      id: '444',
+      extensions: [],
+      rounds: [
+        {
+          id: '444-r1',
+          format: 'a',
+          cutoff: null,
+          timeLimit: null,
+          advancementCondition: null,
+          results: [],
+          extensions: [],
+        },
+      ],
+    },
+  ],
+} as unknown as Competition;
+
+jest.mock('@/providers/WCIFProvider', () => ({
+  useWCIF: () => ({
+    competitionId: 'TestComp2026',
+    wcif: wcifMock,
+    setTitle: () => {},
+  }),
+}));
+
+function renderPersonalResults(registrantId = '1') {
+  return render(
+    <MemoryRouter>
+      <CompetitionPersonalResultsContainer registrantId={registrantId} LinkComponent={AnchorLink} />
+    </MemoryRouter>,
+  );
+}
+
+describe('CompetitionPersonalResultsContainer', () => {
+  beforeAll(() => {
+    jest.useFakeTimers().setSystemTime(new Date('2026-05-03T12:00:00'));
+  });
+
+  afterAll(() => {
+    jest.useRealTimers();
+  });
+
+  beforeEach(() => {
+    mockWcaLiveResults = [];
+    mockWcaCompetitionResults = [];
+    mockWcaCompetitionResultsStatus = 'success';
+  });
+
+  it('shows event tables for the selected competitor results', () => {
+    renderPersonalResults();
+
+    expect(screen.getByText('Vikram Haldar')).toBeInTheDocument();
+    expect(screen.getByRole('link', { name: /view live results/i })).toHaveAttribute(
+      'href',
+      'https://live.worldcubeassociation.org/competitions/TestComp2026/competitors/1',
+    );
+    expect(screen.getByText('🇺🇸')).toBeInTheDocument();
+    expect(screen.getByText('3x3x3 Cube')).toBeInTheDocument();
+    expect(screen.queryByText('4x4x4 Cube')).not.toBeInTheDocument();
+    expect(screen.getByRole('table', { name: 'Event results' })).toBeInTheDocument();
+    expect(screen.getByRole('columnheader', { name: '1' })).toHaveClass('hidden', 'md:table-cell');
+    expect(screen.getByRole('link', { name: 'Round 1' })).toHaveAttribute(
+      'href',
+      '/competitions/TestComp2026/results/333-r1',
+    );
+    expect(screen.getByText('7.41')).toBeInTheDocument();
+    expect(screen.getAllByText('6.90')).toHaveLength(2);
+  });
+
+  it('renders nothing when the person cannot be found', () => {
+    const { container } = renderPersonalResults('2');
+
+    expect(container).toBeEmptyDOMElement();
+  });
+
+  it('uses WCA Live partial results when they are available', () => {
+    mockWcaLiveResults = [
+      {
+        id: 'live-result-1',
+        ranking: 4,
+        advancing: true,
+        advancingQuestionable: true,
+        attempts: [{ result: 800 }, { result: 900 }],
+        best: 800,
+        average: 0,
+        round: {
+          id: 'live-round-1',
+          name: 'First Round',
+          number: 1,
+          competitionEvent: {
+            id: '333',
+            event: {
+              id: '333',
+              name: '3x3x3 Cube',
+              rank: 10,
+            },
+          },
+          format: {
+            id: 'a',
+            numberOfAttempts: 5,
+            sortBy: 'average',
+          },
+        },
+      },
+    ];
+
+    renderPersonalResults();
+
+    expect(screen.getByRole('link', { name: 'First Round' })).toHaveAttribute(
+      'href',
+      '/competitions/TestComp2026/results/333-r1',
+    );
+    expect(screen.getAllByText('8.00')).toHaveLength(2);
+    expect(screen.getByText('4')).toHaveClass('bg-yellow-200');
+    expect(screen.queryByText('7.41')).not.toBeInTheDocument();
+  });
+
+  it('uses WCA competition API results when WCIF and WCA Live results are missing', () => {
+    const originalResults = wcifMock.events[0].rounds[0].results;
+    wcifMock.events[0].rounds[0].results = [];
+    mockWcaCompetitionResults = [
+      {
+        id: 8085002,
+        pos: 3,
+        best: 700,
+        average: 800,
+        name: 'Vikram Haldar',
+        country_iso2: 'US',
+        competition_id: 'TestComp2026',
+        event_id: '333',
+        round_type_id: '1',
+        format_id: 'a',
+        wca_id: '2010HALD01',
+        attempts: [700, 800, 900],
+      },
+    ];
+
+    try {
+      renderPersonalResults();
+
+      expect(screen.getByRole('link', { name: 'Round 1' })).toHaveAttribute(
+        'href',
+        '/competitions/TestComp2026/results/333-r1',
+      );
+      expect(screen.getAllByText('8.00')).toHaveLength(2);
+      expect(screen.getAllByText('7.00')).toHaveLength(2);
+    } finally {
+      wcifMock.events[0].rounds[0].results = originalResults;
+    }
+  });
+
+  it('opens full result details from a narrow personal results row', () => {
+    renderPersonalResults();
+
+    fireEvent.click(screen.getByRole('row', { name: /2 Round 1/ }));
+
+    expect(screen.getByRole('dialog')).toBeInTheDocument();
+    expect(screen.getByRole('heading', { name: '#2' })).toBeInTheDocument();
+    expect(within(screen.getByRole('dialog')).getByText('Event')).toBeInTheDocument();
+    expect(within(screen.getByRole('dialog')).getByText('3x3x3 Cube')).toBeInTheDocument();
+    expect(within(screen.getByRole('dialog')).getByText('Round')).toBeInTheDocument();
+    expect(within(screen.getByRole('dialog')).getByText('Round 1')).toBeInTheDocument();
+    expect(screen.getByText('6.90, 7.32, 7.86, 10.34, 7.05')).toBeInTheDocument();
+    expect(within(screen.getByRole('dialog')).getByText('7.41')).toBeInTheDocument();
+    expect(screen.getByRole('link', { name: 'All results' })).toHaveAttribute(
+      'href',
+      '/competitions/TestComp2026/results/333-r1',
+    );
+
+    fireEvent.click(screen.getByRole('dialog'));
+
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+  });
+});
diff --git a/src/containers/CompetitionPersonalResults/CompetitionPersonalResults.tsx b/src/containers/CompetitionPersonalResults/CompetitionPersonalResults.tsx
new file mode 100644
index 0000000..4c34f16
--- /dev/null
+++ b/src/containers/CompetitionPersonalResults/CompetitionPersonalResults.tsx
@@ -0,0 +1,126 @@
+import { Person } from '@wca/helpers';
+import { useEffect, useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+import { ExternalLink } from '@/components/ExternalLink';
+import { getPersonalResultsFromSources } from '@/containers/CompetitionResults/resultsProvider';
+import { PersonalPageLayout } from '@/containers/PersonalSchedule/PersonalPageLayout';
+import { useWcaLiveCompetitorLink, useWcaLiveCompetitorResults } from '@/hooks/queries/useWcaLive';
+import { useWcaCompetitionResults } from '@/hooks/queries/useWcaResults';
+import { isCompetitionDay } from '@/lib/competitionDates';
+import { AnchorLink, LinkRenderer } from '@/lib/linkRenderer';
+import { useWCIF } from '@/providers/WCIFProvider';
+import { CompetitionPersonalResultsTable } from './CompetitionPersonalResultsTable';
+
+export interface CompetitionPersonalResultsContainerProps {
+  registrantId: string;
+  LinkComponent?: LinkRenderer;
+}
+
+interface CompetitionPersonalResultsContentProps {
+  person: Person;
+  LinkComponent?: LinkRenderer;
+}
+
+export function CompetitionPersonalResultsContent({
+  person,
+  LinkComponent = AnchorLink,
+}: CompetitionPersonalResultsContentProps) {
+  const { t } = useTranslation();
+  const { wcif, competitionId } = useWCIF();
+  const isTodayCompetitionDay = wcif ? isCompetitionDay(wcif) : false;
+  const { data: wcaLiveLink, status: wcaLiveFetchStatus } = useWcaLiveCompetitorLink(
+    competitionId,
+    person.registrantId.toString(),
+    { enabled: isTodayCompetitionDay },
+  );
+  const { data: wcaLiveResults } = useWcaLiveCompetitorResults(wcaLiveLink, {
+    enabled: isTodayCompetitionDay && wcaLiveFetchStatus === 'success',
+  });
+  const { data: wcaApiResults, status: wcaApiResultsStatus } = useWcaCompetitionResults(
+    competitionId,
+    {
+      enabled: Boolean(wcif),
+    },
+  );
+  const isWcaApiResultsLoading = wcaApiResultsStatus === 'pending' && !wcaApiResults;
+
+  const eventResults = useMemo(() => {
+    if (!wcif) {
+      return [];
+    }
+
+    return getPersonalResultsFromSources({
+      wcif,
+      person,
+      wcaLiveResults,
+      wcaApiResults,
+    });
+  }, [person, wcaApiResults, wcaLiveResults, wcif]);
+
+  if (!wcif) {
+    return null;
+  }
+
+  return (
+    <div className="flex flex-col space-y-4">
+      {isTodayCompetitionDay && wcaLiveFetchStatus === 'success' && (
+        <ExternalLink
+          href={wcaLiveLink}
+          className="rounded-md border border-tertiary-weak bg-panel px-3 py-2">
+          {t('competition.results.viewLiveResults')}
+        </ExternalLink>
+      )}
+      {eventResults.length > 0 ? (
+        <div className="space-y-6">
+          {eventResults.map((eventResult) => (
+            <section key={eventResult.eventId} className="space-y-2">
+              <h3 className="type-heading-sm">{eventResult.eventName}</h3>
+              <CompetitionPersonalResultsTable
+                competitionId={competitionId}
+                eventId={eventResult.eventId}
+                eventName={eventResult.eventName}
+                person={person}
+                roundResults={eventResult.rounds}
+                LinkComponent={LinkComponent}
+              />
+            </section>
+          ))}
+        </div>
+      ) : isWcaApiResultsLoading ? (
+        <div className="rounded-md border border-tertiary-weak bg-panel p-4 text-muted">
+          {t('common.loading')}
+        </div>
+      ) : (
+        <div className="rounded-md border border-tertiary-weak bg-panel p-4 text-muted">
+          {t('competition.results.noResults')}
+        </div>
+      )}
+    </div>
+  );
+}
+
+export function CompetitionPersonalResultsContainer({
+  registrantId,
+  LinkComponent = AnchorLink,
+}: CompetitionPersonalResultsContainerProps) {
+  const { t } = useTranslation();
+  const { wcif, competitionId, setTitle } = useWCIF();
+
+  const person = wcif?.persons.find((p) => p.registrantId.toString() === registrantId);
+
+  useEffect(() => {
+    if (person) {
+      setTitle(`${person.name} ${t('competition.results.title')}`);
+    }
+  }, [person, setTitle, t]);
+
+  if (!wcif || !person) {
+    return null;
+  }
+
+  return (
+    <PersonalPageLayout activePage="results" competitionId={competitionId} person={person}>
+      <CompetitionPersonalResultsContent person={person} LinkComponent={LinkComponent} />
+    </PersonalPageLayout>
+  );
+}
diff --git a/src/containers/CompetitionPersonalResults/CompetitionPersonalResultsTable.tsx b/src/containers/CompetitionPersonalResults/CompetitionPersonalResultsTable.tsx
new file mode 100644
index 0000000..2469073
--- /dev/null
+++ b/src/containers/CompetitionPersonalResults/CompetitionPersonalResultsTable.tsx
@@ -0,0 +1,212 @@
+import { AttemptResult, EventId, Person } from '@wca/helpers';
+import classNames from 'classnames';
+import { KeyboardEvent, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { CompetitionRoundResult } from '@/containers/CompetitionResults/CompetitionResultsTable';
+import { ResultDetailsDialog } from '@/containers/CompetitionResults/ResultDetailsDialog';
+import { shouldOpenResultDetailsDialog } from '@/containers/CompetitionResults/resultDetailsViewport';
+import { LinkRenderer } from '@/lib/linkRenderer';
+import { renderResultByEventId } from '@/lib/results';
+
+interface PersonalRoundResult {
+  roundId: string;
+  roundName?: string;
+  roundNumber: number;
+  ranking: number | null;
+  advancing: boolean;
+  advancingQuestionable: boolean;
+  attempts: {
+    result: AttemptResult;
+  }[];
+  best: AttemptResult;
+  average: AttemptResult;
+}
+
+interface CompetitionPersonalResultsTableProps {
+  competitionId: string;
+  eventId: string;
+  eventName: string;
+  person: Person;
+  roundResults: PersonalRoundResult[];
+  LinkComponent: LinkRenderer;
+}
+
+const renderSingleResult = (eventId: string, value: AttemptResult) => {
+  if (value === 0) {
+    return '-';
+  }
+
+  return renderResultByEventId(eventId as EventId, 'single', value);
+};
+
+const renderAverageResult = (eventId: string, value: AttemptResult) => {
+  if (value === 0) {
+    return '-';
+  }
+
+  return renderResultByEventId(eventId as EventId, 'average', value);
+};
+
+const toCompetitionRoundResult = (result: PersonalRoundResult): CompetitionRoundResult => ({
+  id: result.roundId,
+  personId: null,
+  ranking: result.ranking,
+  advancing: result.advancing,
+  advancingQuestionable: result.advancingQuestionable,
+  attempts: result.attempts,
+  best: result.best,
+  average: result.average,
+});
+
+export function CompetitionPersonalResultsTable({
+  competitionId,
+  eventId,
+  eventName,
+  person,
+  roundResults,
+  LinkComponent,
+}: CompetitionPersonalResultsTableProps) {
+  const { t } = useTranslation();
+  const [selectedResult, setSelectedResult] = useState<PersonalRoundResult | null>(null);
+  const attemptColumnCount = Math.max(0, ...roundResults.map((result) => result.attempts.length));
+  const getRoundName = (result: PersonalRoundResult) =>
+    result.roundName ?? t('common.activityCodeToName.round', { roundNumber: result.roundNumber });
+  const openDetailsDialog = (result: PersonalRoundResult) => {
+    if (!shouldOpenResultDetailsDialog()) {
+      return;
+    }
+
+    setSelectedResult(result);
+  };
+
+  const openDetailsDialogFromKeyboard =
+    (result: PersonalRoundResult) => (event: KeyboardEvent<HTMLTableRowElement>) => {
+      if (event.key !== 'Enter' && event.key !== ' ') {
+        return;
+      }
+
+      if (!shouldOpenResultDetailsDialog()) {
+        return;
+      }
+
+      event.preventDefault();
+      setSelectedResult(result);
+    };
+
+  return (
+    <div className="w-full overflow-x-auto border border-tertiary-weak bg-panel shadow-md">
+      <table
+        aria-label={t('competition.personalResults.eventResults')}
+        className="w-full min-w-0 table-fixed md:min-w-[48rem]">
+        <colgroup>
+          <col className="w-10" />
+          <col />
+          {Array.from({ length: attemptColumnCount }, (_, attemptIndex) => (
+            <col key={attemptIndex} className="hidden w-20 md:table-column" />
+          ))}
+          <col className="w-20" />
+          <col className="w-20" />
+        </colgroup>
+        <thead>
+          <tr className="border-b border-tertiary-weak type-body-xs font-semibold">
+            <th scope="col" className="px-2 py-2 text-right">
+              {t('competition.results.rank')}
+            </th>
+            <th scope="col" className="px-2 py-2 text-left">
+              {t('common.wca.round')}
+            </th>
+            {Array.from({ length: attemptColumnCount }, (_, attemptIndex) => (
+              <th
+                key={attemptIndex}
+                scope="col"
+                className="hidden px-4 py-2 text-right md:table-cell">
+                {attemptIndex + 1}
+              </th>
+            ))}
+            <th scope="col" className="px-4 py-2 text-right">
+              {t('competition.results.average')}
+            </th>
+            <th scope="col" className="px-4 py-2 text-right">
+              {t('competition.results.best')}
+            </th>
+          </tr>
+        </thead>
+        <tbody>
+          {roundResults.map((result) => (
+            <tr
+              key={result.roundId}
+              className="cursor-pointer border-b border-tertiary-weak hover-transition hover:bg-gray-50 last:border-b-0 dark:hover:bg-gray-800 md:cursor-default"
+              tabIndex={0}
+              onClick={() => openDetailsDialog(result)}
+              onKeyDown={openDetailsDialogFromKeyboard(result)}>
+              <td
+                className={classNames(
+                  'px-2 py-2 text-right type-body-sm tabular-nums',
+                  result.advancing &&
+                    !result.advancingQuestionable &&
+                    'bg-green-300 text-gray-950 dark:bg-green-700 dark:text-white',
+                  result.advancingQuestionable &&
+                    'bg-yellow-200 text-gray-950 dark:bg-yellow-500 dark:text-gray-950',
+                )}>
+                {result.ranking ?? '-'}
+              </td>
+              <td className="min-w-0 px-2 py-2">
+                <span className="block truncate md:hidden">{getRoundName(result)}</span>
+                <LinkComponent
+                  to={`/competitions/${competitionId}/results/${result.roundId}`}
+                  className="hidden truncate text-primary hover-transition hover:text-primary-strong md:block">
+                  {getRoundName(result)}
+                </LinkComponent>
+              </td>
+              {Array.from({ length: attemptColumnCount }, (_, attemptIndex) => (
+                <td
+                  key={attemptIndex}
+                  className="hidden px-4 py-2 text-right tabular-nums md:table-cell">
+                  {result.attempts[attemptIndex]
+                    ? renderSingleResult(eventId, result.attempts[attemptIndex].result)
+                    : '-'}
+                </td>
+              ))}
+              <td className="px-4 py-2 text-right font-semibold tabular-nums">
+                {renderAverageResult(eventId, result.average)}
+              </td>
+              <td className="px-4 py-2 text-right tabular-nums">
+                {renderSingleResult(eventId, result.best)}
+              </td>
+            </tr>
+          ))}
+        </tbody>
+      </table>
+      {selectedResult && (
+        <ResultDetailsDialog
+          competitionId={competitionId}
+          eventId={eventId}
+          name={person.name}
+          title={
+            selectedResult.ranking ? `#${selectedResult.ranking}` : getRoundName(selectedResult)
+          }
+          details={[
+            {
+              label: t('common.wca.event'),
+              value: eventName,
+            },
+            {
+              label: t('common.wca.round'),
+              value: getRoundName(selectedResult),
+              link: {
+                label: t('competition.results.allResults'),
+                to: `/competitions/${competitionId}/results/${selectedResult.roundId}`,
+              },
+            },
+          ]}
+          primaryRankingType="average"
+          result={toCompetitionRoundResult(selectedResult)}
+          LinkComponent={LinkComponent}
+          onClose={() => setSelectedResult(null)}
+        />
+      )}
+    </div>
+  );
+}
+
+export type { PersonalRoundResult };
diff --git a/src/containers/CompetitionPersonalResults/index.ts b/src/containers/CompetitionPersonalResults/index.ts
new file mode 100644
index 0000000..4b21e94
--- /dev/null
+++ b/src/containers/CompetitionPersonalResults/index.ts
@@ -0,0 +1 @@
+export * from './CompetitionPersonalResults';
diff --git a/src/containers/CompetitionPsychSheetEvent/CompetitionPsychSheetEvent.tsx b/src/containers/CompetitionPsychSheetEvent/CompetitionPsychSheetEvent.tsx
index f1af5fd..808a5d9 100644
--- a/src/containers/CompetitionPsychSheetEvent/CompetitionPsychSheetEvent.tsx
+++ b/src/containers/CompetitionPsychSheetEvent/CompetitionPsychSheetEvent.tsx
@@ -128,7 +128,7 @@ export function CompetitionPsychSheetEventContainer({
                 <LinkComponent
                   key={person.registrantId}
                   className={classNames(
-                    'contents [&>span]:transition-colors',
+                    'contents [&>span]:hover-transition',
                     isOdd ? '[&>span]:table-bg-row-alt-secondary' : '[&>span]:table-bg-row',
                     '[&:hover>span]:table-bg-row-hover-secondary',
                   )}
diff --git a/src/containers/CompetitionResults/CompetitionResults.test.tsx b/src/containers/CompetitionResults/CompetitionResults.test.tsx
new file mode 100644
index 0000000..2c7d1d0
--- /dev/null
+++ b/src/containers/CompetitionResults/CompetitionResults.test.tsx
@@ -0,0 +1,544 @@
+import '@testing-library/jest-dom';
+import { fireEvent, render, screen, within } from '@testing-library/react';
+import { Competition } from '@wca/helpers';
+import { AnchorLink } from '@/lib/linkRenderer';
+import { CompetitionResultsContainer } from './CompetitionResults';
+
+let mockWcaLiveRoundResults: unknown[] = [];
+let mockWcaCompetitionResults: unknown[] | undefined = [];
+let mockWcaCompetitionResultsStatus = 'success';
+const mockUseWcaLiveRoundLink = jest.fn();
+const mockUseWcaLiveRoundResults = jest.fn();
+
+jest.mock('@/components/Container', () => ({
+  Container: ({ children }: { children: React.ReactNode }) => <div>{children}</div>,
+}));
+
+jest.mock('@/lib/events', () => ({
+  getEventName: (eventId: string) => (eventId === '333' ? '3x3x3 Cube' : eventId),
+  getAllEvents: (wcif: Competition) => wcif.events,
+}));
+
+jest.mock('@/hooks/queries/useWcaLive', () => ({
+  useWcaLiveRoundLink: (...args: unknown[]) => mockUseWcaLiveRoundLink(...args),
+  useWcaLiveRoundResults: (...args: unknown[]) => mockUseWcaLiveRoundResults(...args),
+}));
+
+jest.mock('@/hooks/queries/useWcaResults', () => ({
+  useWcaCompetitionResults: () => ({
+    data: mockWcaCompetitionResults,
+    status: mockWcaCompetitionResultsStatus,
+  }),
+}));
+
+jest.mock('react-i18next', () => ({
+  useTranslation: () => ({
+    t: (key: string, options?: Record<string, unknown>) => {
+      if (key === 'competition.results.title') return 'Results';
+      if (key === 'competition.results.roundNotFound') return 'Round not found.';
+      if (key === 'competition.results.back') return 'Back';
+      if (key === 'competition.results.noResults') return 'No results yet.';
+      if (key === 'competition.results.rank') return '#';
+      if (key === 'competition.results.competitor') return 'Competitor';
+      if (key === 'competition.results.average') return 'Avg';
+      if (key === 'competition.results.best') return 'Best';
+      if (key === 'competition.results.attempts') return 'Attempts';
+      if (key === 'competition.results.liveResultsDelayNote') {
+        return 'Data is pulled from WCA Live and may be delayed.';
+      }
+      if (key === 'competition.results.allResults') return 'All results';
+      if (key === 'competition.results.unknownCompetitor') {
+        return `Competitor #${options?.personId}`;
+      }
+      if (key === 'common.close') return 'Close';
+      if (key === 'common.wca.event') return 'Event';
+      if (key === 'common.wca.round') return 'Round';
+      if (key === 'common.view') return 'View';
+      if (key === 'common.loading') return 'Loading...';
+      if (key === 'common.activityCodeToName.round') return `Round ${options?.roundNumber}`;
+
+      return key;
+    },
+  }),
+}));
+
+const wcifMock = {
+  formatVersion: '1.0',
+  id: 'TestComp2026',
+  name: 'Test Competition 2026',
+  shortName: 'Test Comp 2026',
+  persons: [
+    {
+      registrantId: 1,
+      name: 'Blake Thompson',
+      wcaUserId: 1001,
+      wcaId: '2010THOM03',
+      countryIso2: 'US',
+      registration: null,
+      assignments: [{ activityId: 101, assignmentCode: 'competitor', stationNumber: 1 }],
+      extensions: [],
+    },
+    {
+      registrantId: 2,
+      name: 'Nick Silvestri',
+      wcaUserId: 1002,
+      wcaId: '2016SILV08',
+      countryIso2: 'US',
+      registration: null,
+      assignments: [{ activityId: 101, assignmentCode: 'competitor', stationNumber: 2 }],
+      extensions: [],
+    },
+    {
+      registrantId: 3,
+      name: 'Casey Nguyen',
+      wcaUserId: 1003,
+      wcaId: '2024NGUY02',
+      countryIso2: 'US',
+      registration: null,
+      assignments: [{ activityId: 101, assignmentCode: 'competitor', stationNumber: 3 }],
+      extensions: [],
+    },
+  ],
+  competitorLimit: null,
+  extensions: [],
+  events: [
+    {
+      id: '333',
+      extensions: [],
+      rounds: [
+        {
+          id: '333-r1',
+          format: 'a',
+          cutoff: null,
+          timeLimit: null,
+          advancementCondition: {
+            type: 'ranking',
+            level: 1,
+          },
+          results: [
+            {
+              personId: 2,
+              ranking: 2,
+              attempts: [
+                { result: 1400, reconstruction: null },
+                { result: 1500, reconstruction: null },
+                { result: 1600, reconstruction: null },
+              ],
+              best: 1400,
+              average: 1500,
+            },
+            {
+              personId: 1,
+              ranking: 1,
+              attempts: [
+                { result: 1200, reconstruction: null },
+                { result: 1300, reconstruction: null },
+                { result: 1400, reconstruction: null },
+              ],
+              best: 1200,
+              average: 1300,
+            },
+          ],
+          extensions: [],
+        },
+        {
+          id: '333-r2',
+          format: 'a',
+          cutoff: null,
+          timeLimit: null,
+          advancementCondition: null,
+          results: [],
+          extensions: [],
+        },
+      ],
+    },
+    {
+      id: '222',
+      extensions: [],
+      rounds: [
+        {
+          id: '222-r1',
+          format: 'a',
+          cutoff: null,
+          timeLimit: null,
+          advancementCondition: null,
+          results: [],
+          extensions: [],
+        },
+        {
+          id: '222-r2',
+          format: 'a',
+          cutoff: null,
+          timeLimit: null,
+          advancementCondition: null,
+          results: [],
+          extensions: [],
+        },
+      ],
+    },
+  ],
+  schedule: {
+    numberOfDays: 1,
+    startDate: '2026-05-03',
+    venues: [
+      {
+        id: 1,
+        name: 'Main Venue',
+        latitudeMicrodegrees: 0,
+        longitudeMicrodegrees: 0,
+        countryIso2: 'US',
+        timezone: 'America/Los_Angeles',
+        rooms: [
+          {
+            id: 1,
+            name: 'Main Room',
+            color: '#ffffff',
+            activities: [
+              {
+                id: 100,
+                name: '3x3x3 Cube Round 1',
+                activityCode: '333-r1',
+                startTime: '2026-05-03T19:00:00Z',
+                endTime: '2026-05-03T20:00:00Z',
+                childActivities: [
+                  {
+                    id: 101,
+                    name: '3x3x3 Cube Round 1 Group 1',
+                    activityCode: '333-r1-g1',
+                    startTime: '2026-05-03T19:00:00Z',
+                    endTime: '2026-05-03T20:00:00Z',
+                    childActivities: [],
+                    extensions: [],
+                  },
+                ],
+                extensions: [],
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  },
+} as unknown as Competition;
+
+jest.mock('@/providers/WCIFProvider', () => ({
+  useWCIF: () => ({
+    competitionId: 'TestComp2026',
+    wcif: wcifMock,
+    setTitle: () => {},
+  }),
+}));
+
+function renderResults(selectedRoundId?: string) {
+  return render(
+    <CompetitionResultsContainer
+      competitionId="TestComp2026"
+      selectedRoundId={selectedRoundId}
+      LinkComponent={AnchorLink}
+    />,
+  );
+}
+
+describe('CompetitionResultsContainer', () => {
+  beforeEach(() => {
+    mockWcaLiveRoundResults = [];
+    mockWcaCompetitionResults = [];
+    mockWcaCompetitionResultsStatus = 'success';
+    mockUseWcaLiveRoundLink.mockReturnValue({
+      data: 'https://live.worldcubeassociation.org/competitions/TestComp2026/rounds/1',
+      status: 'success',
+    });
+    mockUseWcaLiveRoundResults.mockImplementation(() => ({
+      data: { results: mockWcaLiveRoundResults },
+      status: 'success',
+    }));
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it('shows the round chooser without selected round content by default', () => {
+    renderResults();
+
+    expect(screen.queryByText('Results')).not.toBeInTheDocument();
+    expect(screen.queryByText('Select a round')).not.toBeInTheDocument();
+    expect(screen.getAllByRole('link')).toHaveLength(2);
+    expect(screen.getAllByRole('link').map((link) => link.getAttribute('href'))).toEqual([
+      '/competitions/TestComp2026/results/333-r1',
+      '/competitions/TestComp2026/results/222-r1',
+    ]);
+    expect(screen.getAllByText('3x3x3 Cube')).toHaveLength(1);
+    expect(screen.getAllByText('222')).toHaveLength(1);
+    expect(screen.queryByRole('link', { name: 'Round 2' })).not.toBeInTheDocument();
+    expect(screen.queryByRole('table', { name: 'Results' })).not.toBeInTheDocument();
+    expect(
+      screen.getByText('Data is pulled from WCA Live and may be delayed.'),
+    ).toBeInTheDocument();
+  });
+
+  it('shows the selected round results table', () => {
+    renderResults('333-r1');
+
+    expect(screen.getByRole('link', { name: 'Back' })).toHaveAttribute(
+      'href',
+      '/competitions/TestComp2026/results',
+    );
+    expect(screen.getByText('3x3x3 Cube Round 1')).toBeInTheDocument();
+    expect(screen.getByRole('table', { name: 'Results' })).toBeInTheDocument();
+    expect(screen.getByRole('columnheader', { name: '#' })).toBeInTheDocument();
+    expect(screen.getByRole('columnheader', { name: 'Competitor' })).toBeInTheDocument();
+    expect(screen.getByRole('columnheader', { name: '1' })).toHaveClass('hidden', 'md:table-cell');
+    expect(screen.getByRole('columnheader', { name: 'Avg' })).toBeInTheDocument();
+    expect(screen.getByRole('columnheader', { name: 'Best' })).toBeInTheDocument();
+    expect(screen.getByRole('link', { name: 'Blake Thompson' })).toHaveAttribute(
+      'href',
+      '/competitions/TestComp2026/persons/1/results',
+    );
+    expect(screen.getByRole('link', { name: 'Nick Silvestri' })).toHaveAttribute(
+      'href',
+      '/competitions/TestComp2026/persons/2/results',
+    );
+    expect(screen.getByRole('navigation', { name: 'Round' })).toBeInTheDocument();
+    expect(
+      within(screen.getByRole('navigation', { name: 'Round' }))
+        .getAllByRole('link', { name: /Round 1/ })
+        .map((link) => link.getAttribute('href')),
+    ).toEqual([
+      '/competitions/TestComp2026/results/333-r1',
+      '/competitions/TestComp2026/results/222-r1',
+    ]);
+    expect(
+      within(screen.getByRole('navigation', { name: 'Round' })).getByText('Done'),
+    ).toBeInTheDocument();
+    expect(screen.queryByText('2010THOM03')).not.toBeInTheDocument();
+    expect(screen.getAllByText('13.00')).toHaveLength(2);
+    expect(screen.getAllByText('12.00')).toHaveLength(2);
+    expect(screen.queryByLabelText('Attempts')).not.toBeInTheDocument();
+    expect(
+      screen.getByText('Data is pulled from WCA Live and may be delayed.'),
+    ).toBeInTheDocument();
+    expect(
+      screen
+        .getAllByRole('row')
+        .slice(1)
+        .map((row) => within(row).getAllByRole('cell')[0].textContent),
+    ).toEqual(['1', '2']);
+    expect(
+      within(screen.getByRole('row', { name: /1 Blake Thompson/ })).getByText('1'),
+    ).toHaveClass('bg-green-300');
+    expect(
+      within(screen.getByRole('row', { name: /2 Nick Silvestri/ })).getByText('2'),
+    ).not.toHaveClass('bg-green-300');
+  });
+
+  it('shows a not-found state for an invalid round id', () => {
+    renderResults('333-r9');
+
+    expect(screen.getByRole('link', { name: 'Back' })).toHaveAttribute(
+      'href',
+      '/competitions/TestComp2026/results',
+    );
+    expect(screen.getByText('Round not found.')).toBeInTheDocument();
+    expect(screen.getAllByRole('link')).toHaveLength(3);
+  });
+
+  it('does not show the selected round scaffold for a round with no result rows', () => {
+    renderResults('333-r2');
+
+    expect(screen.getByText('Round not found.')).toBeInTheDocument();
+    expect(screen.queryByRole('link', { name: 'Round 2' })).not.toBeInTheDocument();
+  });
+
+  it('does not show the round not-found state while fallback results are loading', () => {
+    mockWcaCompetitionResults = undefined;
+    mockWcaCompetitionResultsStatus = 'pending';
+
+    renderResults('333-r2');
+
+    expect(screen.getByText('Loading...')).toBeInTheDocument();
+    expect(screen.queryByText('Round not found.')).not.toBeInTheDocument();
+  });
+
+  it('does not show the no-results state while fallback results are loading', () => {
+    mockWcaCompetitionResults = undefined;
+    mockWcaCompetitionResultsStatus = 'pending';
+
+    renderResults('222-r1');
+
+    expect(screen.getByText('Loading...')).toBeInTheDocument();
+    expect(screen.queryByText('No results yet.')).not.toBeInTheDocument();
+  });
+
+  it('uses WCA competition API results when WCIF and WCA Live results are missing', () => {
+    mockWcaCompetitionResults = [
+      {
+        id: 8085001,
+        pos: 1,
+        best: 900,
+        average: 950,
+        name: 'Blake Thompson',
+        country_iso2: 'US',
+        competition_id: 'TestComp2026',
+        event_id: '333',
+        round_type_id: '2',
+        format_id: 'a',
+        wca_id: '2010THOM03',
+        attempts: [900, 950, 1000, 1050, 1200],
+        best_index: 0,
+        worst_index: 4,
+        regional_single_record: 'NR',
+        regional_average_record: 'WR',
+      },
+    ];
+
+    renderResults('333-r2');
+
+    expect(screen.getByText('3x3x3 Cube Round 2')).toBeInTheDocument();
+    expect(screen.getByRole('link', { name: 'Blake Thompson' })).toHaveAttribute(
+      'href',
+      '/competitions/TestComp2026/persons/1/results',
+    );
+    expect(
+      within(screen.getByRole('row', { name: /1 Blake Thompson/ })).getByText('(9.00)'),
+    ).toBeInTheDocument();
+    expect(
+      within(screen.getByRole('row', { name: /1 Blake Thompson/ })).getByText('(12.00)'),
+    ).toBeInTheDocument();
+    expect(
+      within(screen.getByRole('row', { name: /1 Blake Thompson/ })).getAllByText('9.50'),
+    ).toHaveLength(2);
+    expect(screen.getAllByText('9.00')).toHaveLength(1);
+    expect(screen.getByLabelText('WR record')).toHaveTextContent('WR');
+    expect(screen.getByLabelText('NR record')).toHaveTextContent('NR');
+    expect(
+      within(screen.getByRole('navigation', { name: 'Event rounds' }))
+        .getAllByRole('link')
+        .map((link) => link.getAttribute('href')),
+    ).toEqual([
+      '/competitions/TestComp2026/results/333-r1',
+      '/competitions/TestComp2026/results/333-r2',
+    ]);
+    expect(
+      within(screen.getByRole('navigation', { name: 'Event rounds' })).getByRole('link', {
+        name: /Round 2/,
+      }),
+    ).toHaveClass('bg-blue-700', 'text-white');
+    expect(
+      within(screen.getByRole('navigation', { name: 'Round' })).getAllByText('Done'),
+    ).toHaveLength(2);
+  });
+
+  it('shows round one for an event even before it has results', () => {
+    renderResults('222-r1');
+
+    expect(screen.getByRole('link', { name: 'Back' })).toHaveAttribute(
+      'href',
+      '/competitions/TestComp2026/results',
+    );
+    expect(screen.getByText('222 Round 1')).toBeInTheDocument();
+    expect(screen.getByText('No results yet.')).toBeInTheDocument();
+    expect(screen.getAllByRole('link', { name: /Round 1/ })).toHaveLength(2);
+  });
+
+  it('uses WCA Live partial results for the selected round when they are available', () => {
+    mockWcaLiveRoundResults = [
+      {
+        id: 'live-result-1',
+        ranking: 3,
+        advancing: true,
+        advancingQuestionable: true,
+        attempts: [
+          { result: 1100 },
+          { result: 1200 },
+          { result: 1300 },
+          { result: 1400 },
+          { result: 1500 },
+        ],
+        best: 1100,
+        average: 1300,
+        singleRecordTag: 'PR',
+        averageRecordTag: 'PR',
+        person: {
+          id: 'live-person-1',
+          registrantId: 1,
+          name: 'Blake Thompson',
+        },
+      },
+    ];
+
+    renderResults('333-r1');
+
+    expect(mockUseWcaLiveRoundLink).toHaveBeenCalledWith('TestComp2026', '333', 1, {
+      enabled: true,
+    });
+    expect(mockUseWcaLiveRoundResults).toHaveBeenCalledWith(
+      'https://live.worldcubeassociation.org/competitions/TestComp2026/rounds/1',
+      {
+        enabled: true,
+      },
+    );
+    expect(screen.getByRole('link', { name: 'Blake Thompson' })).toHaveAttribute(
+      'href',
+      '/competitions/TestComp2026/persons/1/results',
+    );
+    expect(screen.getByRole('link', { name: 'Nick Silvestri' })).toHaveAttribute(
+      'href',
+      '/competitions/TestComp2026/persons/2/results',
+    );
+    expect(screen.getByRole('link', { name: 'Casey Nguyen' })).toHaveAttribute(
+      'href',
+      '/competitions/TestComp2026/persons/3/results',
+    );
+    expect(
+      within(screen.getByRole('row', { name: /3 Blake Thompson/ })).getByText('3'),
+    ).toHaveClass('bg-yellow-200');
+    expect(
+      within(screen.getByRole('row', { name: /Casey Nguyen/ })).getAllByRole('cell')[0],
+    ).toBeEmptyDOMElement();
+    expect(
+      within(screen.getByRole('row', { name: /3 Blake Thompson/ })).getByText('(11.00)'),
+    ).toBeInTheDocument();
+    expect(
+      within(screen.getByRole('row', { name: /3 Blake Thompson/ })).getByText('(15.00)'),
+    ).toBeInTheDocument();
+    expect(screen.getAllByText('11.00')).toHaveLength(1);
+    expect(screen.getAllByLabelText('PR record').map((badge) => badge.textContent)).toEqual([
+      'PR',
+      'PR',
+    ]);
+    expect(
+      within(screen.getByRole('row', { name: /2 Nick Silvestri/ })).getAllByText('15.00'),
+    ).toHaveLength(2);
+    expect(
+      screen.getByText('Data is pulled from WCA Live and may be delayed.'),
+    ).toBeInTheDocument();
+  });
+
+  it('opens full result details from a narrow results row', () => {
+    renderResults('333-r1');
+
+    fireEvent.click(screen.getByRole('row', { name: /1 Blake Thompson/ }));
+
+    expect(screen.getByRole('dialog')).toBeInTheDocument();
+    expect(screen.getByRole('heading', { name: 'Blake Thompson #1' })).toBeInTheDocument();
+    expect(screen.getByText('12.00, 13.00, 14.00')).toBeInTheDocument();
+    expect(screen.getByRole('link', { name: 'All results' })).toHaveAttribute(
+      'href',
+      '/competitions/TestComp2026/persons/1/results',
+    );
+
+    fireEvent.keyDown(document, { key: 'Escape' });
+
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+  });
+
+  it('closes result details when clicking outside the dialog content', () => {
+    renderResults('333-r1');
+
+    fireEvent.click(screen.getByRole('row', { name: /1 Blake Thompson/ }));
+    fireEvent.click(screen.getByRole('dialog'));
+
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+  });
+});
diff --git a/src/containers/CompetitionResults/CompetitionResults.tsx b/src/containers/CompetitionResults/CompetitionResults.tsx
new file mode 100644
index 0000000..bd91ec8
--- /dev/null
+++ b/src/containers/CompetitionResults/CompetitionResults.tsx
@@ -0,0 +1,321 @@
+import classNames from 'classnames';
+import { useEffect, useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+import { Container } from '@/components/Container';
+import { LinkButton } from '@/components/LinkButton';
+import { NoteBox } from '@/components/Notebox';
+import {
+  RoundActionPicker,
+  RoundActionPickerEvent,
+  RoundResultStatus,
+  RoundResultStatusBadge,
+} from '@/components/RoundActionPicker';
+import { useWcaLiveRoundLink, useWcaLiveRoundResults } from '@/hooks/queries/useWcaLive';
+import { useWcaCompetitionResults } from '@/hooks/queries/useWcaResults';
+import { useNow } from '@/hooks/useNow';
+import { getRoundActivitiesForRoundId } from '@/lib/activities';
+import { isCompetitionDay } from '@/lib/competitionDates';
+import { getEventName } from '@/lib/events';
+import { AnchorLink, LinkRenderer } from '@/lib/linkRenderer';
+import { findRoundWithEvent, getAllRoundsWithEvents } from '@/lib/rounds';
+import { useWCIF } from '@/providers/WCIFProvider';
+import { CompetitionResultsTable } from './CompetitionResultsTable';
+import { ResultsEventRoundSelector } from './ResultsEventRoundSelector';
+import { getWcaApiResultsByRoundId } from './resultSources';
+import { getRoundResultsFromSources } from './resultsProvider';
+
+export interface CompetitionResultsContainerProps {
+  competitionId: string;
+  selectedRoundId?: string;
+  LinkComponent?: LinkRenderer;
+}
+
+interface RoundOptionGroup {
+  event: ReturnType<typeof getAllRoundsWithEvents>[number]['event'];
+  rounds: ReturnType<typeof getAllRoundsWithEvents>;
+}
+
+const getRoundResultStatus = (
+  round: RoundOptionGroup['rounds'][number]['round'],
+  wcif: ReturnType<typeof useWCIF>['wcif'],
+  now: Date,
+  hasApiResults = false,
+): RoundResultStatus => {
+  const isRoundOngoing =
+    wcif &&
+    getRoundActivitiesForRoundId(wcif, round.id).some((activity) => {
+      const start = new Date(activity.startTime);
+      const end = new Date(activity.endTime);
+
+      return start <= now && now < end;
+    });
+
+  if (isRoundOngoing) {
+    return 'now';
+  }
+
+  if (round.results.length === 0 && !hasApiResults) {
+    return undefined;
+  }
+
+  return 'done';
+};
+
+function ResultsRoundNav({
+  competitionId,
+  groups,
+  selectedRoundId,
+  LinkComponent,
+  wcif,
+  now,
+  apiResultsByRoundId,
+}: {
+  competitionId: string;
+  groups: RoundOptionGroup[];
+  selectedRoundId?: string;
+  LinkComponent: LinkRenderer;
+  wcif: ReturnType<typeof useWCIF>['wcif'];
+  now: Date;
+  apiResultsByRoundId: Map<string, unknown[]>;
+}) {
+  const { t } = useTranslation();
+
+  return (
+    <nav
+      aria-label={t('common.wca.round')}
+      className="hidden overflow-y-auto rounded-md border border-tertiary-weak bg-panel shadow-sm lg:sticky lg:top-4 lg:block lg:max-h-[calc(100vh-2rem)]">
+      <div>
+        {groups.map(({ event, rounds }) => (
+          <div key={event.id} className="border-b border-tertiary-weak last:border-b-0">
+            <div className="flex items-center gap-2 px-3 py-2 text-muted type-body-xs">
+              <span className={`cubing-icon event-${event.id}`} aria-hidden="true" />
+              <span className="truncate">{getEventName(event.id, event)}</span>
+            </div>
+            <div>
+              {rounds.map(({ round, roundNumber }) => {
+                const isSelected = round.id === selectedRoundId;
+                const status = getRoundResultStatus(
+                  round,
+                  wcif,
+                  now,
+                  (apiResultsByRoundId.get(round.id)?.length ?? 0) > 0,
+                );
+
+                return (
+                  <LinkComponent
+                    key={round.id}
+                    to={`/competitions/${competitionId}/results/${round.id}`}
+                    className={classNames(
+                      'flex min-h-10 items-center gap-2 px-3 py-2 type-body-sm hover-transition hover:bg-gray-100 dark:hover:bg-gray-700',
+                      {
+                        'bg-blue-700 text-white dark:bg-blue-300 dark:text-gray-950': isSelected,
+                        'text-default': !isSelected,
+                      },
+                    )}>
+                    <span className="flex-1 truncate">
+                      {t('common.activityCodeToName.round', { roundNumber })}
+                    </span>
+                    {status && <RoundResultStatusBadge status={status} size="sm" />}
+                  </LinkComponent>
+                );
+              })}
+            </div>
+          </div>
+        ))}
+      </div>
+    </nav>
+  );
+}
+
+export function CompetitionResultsContainer({
+  competitionId,
+  selectedRoundId,
+  LinkComponent = AnchorLink,
+}: CompetitionResultsContainerProps) {
+  const { t } = useTranslation();
+  const { wcif, setTitle } = useWCIF();
+  const now = useNow(30 * 1000);
+  const isTodayCompetitionDay = wcif ? isCompetitionDay(wcif) : false;
+  const { data: wcaApiResults, status: wcaApiResultsStatus } = useWcaCompetitionResults(
+    competitionId,
+    {
+      enabled: Boolean(wcif),
+    },
+  );
+  const isWcaApiResultsLoading = wcaApiResultsStatus === 'pending' && !wcaApiResults;
+  const apiResultsByRoundId = useMemo(
+    () => (wcif && wcaApiResults ? getWcaApiResultsByRoundId(wcif, wcaApiResults) : new Map()),
+    [wcaApiResults, wcif],
+  );
+
+  useEffect(() => {
+    setTitle(t('competition.results.title'));
+  }, [setTitle, t]);
+
+  const roundOptions = useMemo(
+    () =>
+      wcif
+        ? getAllRoundsWithEvents(wcif).filter(
+            ({ round, roundNumber }) =>
+              roundNumber === 1 ||
+              round.results.length > 0 ||
+              (apiResultsByRoundId.get(round.id)?.length ?? 0) > 0,
+          )
+        : [],
+    [apiResultsByRoundId, wcif],
+  );
+  const eventsWithResults = useMemo(
+    () =>
+      roundOptions.reduce<RoundOptionGroup[]>((groups, roundOption) => {
+        const existingGroup = groups.find((group) => group.event.id === roundOption.event.id);
+
+        if (existingGroup) {
+          existingGroup.rounds.push(roundOption);
+          return groups;
+        }
+
+        groups.push({
+          event: roundOption.event,
+          rounds: [roundOption],
+        });
+        return groups;
+      }, []),
+    [roundOptions],
+  );
+  const pickerEvents = useMemo<RoundActionPickerEvent[]>(
+    () =>
+      eventsWithResults.map(({ event, rounds }) => ({
+        id: event.id,
+        name: getEventName(event.id, event),
+        rounds: rounds.map(({ round, roundNumber }) => ({
+          id: round.id,
+          roundNumber,
+          resultStatus: getRoundResultStatus(
+            round,
+            wcif,
+            now,
+            (apiResultsByRoundId.get(round.id)?.length ?? 0) > 0,
+          ),
+          href: `/competitions/${competitionId}/results/${round.id}`,
+        })),
+      })),
+    [apiResultsByRoundId, competitionId, eventsWithResults, now, wcif],
+  );
+  const selectedRound = useMemo(() => {
+    if (!wcif || !selectedRoundId) {
+      return undefined;
+    }
+
+    const round = findRoundWithEvent(wcif, selectedRoundId);
+    return round &&
+      (round.roundNumber === 1 ||
+        round.round.results.length > 0 ||
+        (apiResultsByRoundId.get(round.round.id)?.length ?? 0) > 0 ||
+        isTodayCompetitionDay)
+      ? round
+      : undefined;
+  }, [apiResultsByRoundId, isTodayCompetitionDay, selectedRoundId, wcif]);
+  const { data: wcaLiveRoundLink, status: wcaLiveRoundLinkStatus } = useWcaLiveRoundLink(
+    competitionId,
+    selectedRound?.event.id ?? '',
+    selectedRound?.roundNumber ?? 1,
+    { enabled: Boolean(selectedRound) },
+  );
+  const { data: wcaLiveRound } = useWcaLiveRoundResults(wcaLiveRoundLink, {
+    enabled: wcaLiveRoundLinkStatus === 'success',
+  });
+  const roundResults = useMemo(
+    () => getRoundResultsFromSources({ wcif, selectedRound, wcaLiveRound, wcaApiResults }),
+    [selectedRound, wcaApiResults, wcaLiveRound, wcif],
+  );
+  const selectedEventRoundLinks = useMemo(
+    () =>
+      selectedRound
+        ? (pickerEvents.find((event) => event.id === selectedRound.event.id)?.rounds ?? []).map(
+            ({ href, id, resultStatus, roundNumber }) => ({
+              href: href ?? `/competitions/${competitionId}/results/${id}`,
+              id,
+              resultStatus,
+              roundNumber,
+            }),
+          )
+        : [],
+    [competitionId, pickerEvents, selectedRound],
+  );
+
+  if (selectedRoundId) {
+    return (
+      <Container className="pt-4" fullWidth>
+        <div className="mx-auto grid w-full max-w-screen-xl gap-4 p-2 type-body lg:grid-cols-[16rem_minmax(0,1fr)] lg:items-start">
+          <ResultsRoundNav
+            competitionId={competitionId}
+            groups={eventsWithResults}
+            selectedRoundId={selectedRoundId}
+            LinkComponent={LinkComponent}
+            wcif={wcif}
+            now={now}
+            apiResultsByRoundId={apiResultsByRoundId}
+          />
+          <div className="flex flex-col min-w-0 space-y-4">
+            <div className="lg:hidden">
+              <LinkButton
+                to={`/competitions/${competitionId}/results`}
+                title={t('competition.results.back')}
+                variant="light"
+                LinkComponent={LinkComponent}
+              />
+            </div>
+
+            {selectedRound ? (
+              <section className="space-y-2">
+                <h2 className="type-heading">
+                  {getEventName(selectedRound.event.id, selectedRound.event)}{' '}
+                  {t('common.activityCodeToName.round', {
+                    roundNumber: selectedRound.roundNumber,
+                  })}
+                </h2>
+                <NoteBox text={t('competition.results.liveResultsDelayNote')} />
+                <ResultsEventRoundSelector
+                  selectedRoundId={selectedRound.round.id}
+                  rounds={selectedEventRoundLinks}
+                  LinkComponent={LinkComponent}
+                />
+                {isWcaApiResultsLoading && roundResults.length === 0 ? (
+                  <section className="p-4 border rounded-md border-tertiary-weak bg-panel text-muted">
+                    <p>{t('common.loading')}</p>
+                  </section>
+                ) : (
+                  <CompetitionResultsTable
+                    competitionId={competitionId}
+                    eventId={selectedRound.event.id}
+                    round={selectedRound.round}
+                    persons={wcif?.persons ?? []}
+                    results={roundResults}
+                    LinkComponent={LinkComponent}
+                  />
+                )}
+              </section>
+            ) : isWcaApiResultsLoading ? (
+              <section className="p-4 border rounded-md border-tertiary-weak bg-panel text-muted">
+                <p>{t('common.loading')}</p>
+              </section>
+            ) : (
+              <section className="p-4 border rounded-md border-tertiary-weak bg-panel">
+                <p>{t('competition.results.roundNotFound')}</p>
+              </section>
+            )}
+          </div>
+        </div>
+      </Container>
+    );
+  }
+
+  return (
+    <Container className="pt-4">
+      <div className="flex flex-col p-2 space-y-4 type-body">
+        <NoteBox text={t('competition.results.liveResultsDelayNote')} />
+        <RoundActionPicker mode="results" events={pickerEvents} LinkComponent={LinkComponent} />
+      </div>
+    </Container>
+  );
+}
diff --git a/src/containers/CompetitionResults/CompetitionResultsTable.tsx b/src/containers/CompetitionResults/CompetitionResultsTable.tsx
new file mode 100644
index 0000000..0348495
--- /dev/null
+++ b/src/containers/CompetitionResults/CompetitionResultsTable.tsx
@@ -0,0 +1,394 @@
+import { AttemptResult, EventId, Person, RankingType, Round, RoundFormat } from '@wca/helpers';
+import classNames from 'classnames';
+import { KeyboardEvent, ReactNode, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { AnchorLink, LinkRenderer } from '@/lib/linkRenderer';
+import { renderResultByEventId } from '@/lib/results';
+import { ResultDetailsDialog } from './ResultDetailsDialog';
+import { normalizeResultRecordTag, ResultRecordBadge, ResultRecordTag } from './ResultRecordBadge';
+import { shouldOpenResultDetailsDialog } from './resultDetailsViewport';
+
+export interface CompetitionRoundResult {
+  id: string | number;
+  personId: number | null;
+  personName?: string;
+  ranking: number | null;
+  advancing: boolean;
+  advancingQuestionable: boolean;
+  attempts: {
+    result: AttemptResult;
+  }[];
+  best: AttemptResult;
+  average: AttemptResult;
+  bestAttemptIndex?: number | null;
+  worstAttemptIndex?: number | null;
+  singleRecordTag?: ResultRecordTag;
+  averageRecordTag?: ResultRecordTag;
+}
+
+interface CompetitionResultsTableProps {
+  competitionId: string;
+  eventId: string;
+  round: Round;
+  persons: Person[];
+  results?: CompetitionRoundResult[];
+  LinkComponent?: LinkRenderer;
+}
+
+type RoundResultWithRecords = Round['results'][number] & {
+  regionalSingleRecord?: string | null;
+  regionalAverageRecord?: string | null;
+  singleRecordTag?: string | null;
+  averageRecordTag?: string | null;
+};
+
+const getPrimaryRankingType = (format: RoundFormat): RankingType =>
+  format === 'a' || format === 'm' ? 'average' : 'single';
+
+const getResultValue = (result: CompetitionRoundResult, rankingType: RankingType) =>
+  rankingType === 'average' ? result.average : result.best;
+
+const renderResultValue = (
+  eventId: string,
+  rankingType: RankingType,
+  result: CompetitionRoundResult,
+) => {
+  const value = getResultValue(result, rankingType);
+
+  if (value === 0) {
+    return '-';
+  }
+
+  return renderResultByEventId(eventId as EventId, rankingType, value);
+};
+
+const renderAttemptValue = (eventId: string, value: AttemptResult) => {
+  if (value === 0) {
+    return '-';
+  }
+
+  return renderResultByEventId(eventId as EventId, 'single', value);
+};
+
+const isAverageOfFiveRound = (format: RoundFormat) => format === 'a';
+
+const isValidAttemptResult = (value: AttemptResult) => Number(value) > 0;
+
+const getCalculatedDroppedAttemptIndexes = (
+  attempts: CompetitionRoundResult['attempts'],
+): Set<number> => {
+  const validAttempts = attempts
+    .map((attempt, index) => ({ index, value: Number(attempt.result) }))
+    .filter((attempt) => attempt.value > 0);
+  const completedAttempts = attempts
+    .map((attempt, index) => ({ index, value: Number(attempt.result) }))
+    .filter((attempt) => attempt.value !== 0);
+
+  if (validAttempts.length === 0 || completedAttempts.length !== 5) {
+    return new Set();
+  }
+
+  const bestAttempt = validAttempts.reduce((best, attempt) =>
+    attempt.value < best.value ? attempt : best,
+  );
+  const worstAttempt = completedAttempts.reduce((worst, attempt) => {
+    const attemptIsInvalid = !isValidAttemptResult(attempt.value);
+    const worstIsInvalid = !isValidAttemptResult(worst.value);
+
+    if (attemptIsInvalid && !worstIsInvalid) {
+      return attempt;
+    }
+
+    if (attemptIsInvalid || worstIsInvalid) {
+      return worst;
+    }
+
+    return attempt.value > worst.value ? attempt : worst;
+  });
+
+  return new Set([bestAttempt.index, worstAttempt.index]);
+};
+
+const getDroppedAttemptIndexes = (
+  roundFormat: RoundFormat,
+  result: CompetitionRoundResult,
+): Set<number> => {
+  if (!isAverageOfFiveRound(roundFormat) || result.attempts.length !== 5) {
+    return new Set();
+  }
+
+  const providedIndexes = [result.bestAttemptIndex, result.worstAttemptIndex].filter(
+    (index): index is number =>
+      typeof index === 'number' && Number.isInteger(index) && index >= 0 && index < 5,
+  );
+
+  return providedIndexes.length > 0
+    ? new Set(providedIndexes)
+    : getCalculatedDroppedAttemptIndexes(result.attempts);
+};
+
+const renderAttemptDisplayValue = (
+  eventId: string,
+  value: AttemptResult,
+  isDroppedAttempt: boolean,
+) => {
+  const renderedValue = renderAttemptValue(eventId, value);
+
+  return isDroppedAttempt && renderedValue !== '-' ? `(${renderedValue})` : renderedValue;
+};
+
+const getRecordTag = (result: CompetitionRoundResult, rankingType: RankingType) =>
+  rankingType === 'average' ? result.averageRecordTag : result.singleRecordTag;
+
+const ResultValue = ({
+  children,
+  recordTag,
+}: {
+  children: ReactNode;
+  recordTag?: ResultRecordTag;
+}) => (
+  <span className="inline-grid grid-cols-[auto_1rem] items-baseline justify-end gap-1">
+    <span className="text-right">{children}</span>
+    <span className="flex w-4 justify-start">
+      <ResultRecordBadge tag={recordTag} />
+    </span>
+  </span>
+);
+
+const isRosterOnlyResult = (result: CompetitionRoundResult) =>
+  result.ranking == null &&
+  result.attempts.length === 0 &&
+  result.best === 0 &&
+  result.average === 0;
+
+const sortResultsByRanking = (results: CompetitionRoundResult[]) =>
+  [...results].sort((a, b) => {
+    if (a.ranking == null && b.ranking == null) {
+      return 0;
+    }
+
+    if (a.ranking == null) {
+      return 1;
+    }
+
+    if (b.ranking == null) {
+      return -1;
+    }
+
+    return a.ranking - b.ranking;
+  });
+
+const toCompetitionRoundResult = (result: Round['results'][number]): CompetitionRoundResult => {
+  const resultWithRecords = result as RoundResultWithRecords;
+
+  return {
+    id: result.personId,
+    personId: result.personId,
+    ranking: result.ranking,
+    advancing: false,
+    advancingQuestionable: false,
+    attempts: result.attempts.map((attempt) => ({ result: attempt.result })),
+    best: result.best,
+    average: result.average,
+    singleRecordTag: normalizeResultRecordTag(
+      resultWithRecords.singleRecordTag ?? resultWithRecords.regionalSingleRecord,
+    ),
+    averageRecordTag: normalizeResultRecordTag(
+      resultWithRecords.averageRecordTag ?? resultWithRecords.regionalAverageRecord,
+    ),
+  };
+};
+
+export function CompetitionResultsTable({
+  competitionId,
+  eventId,
+  round,
+  persons,
+  results = round.results.map(toCompetitionRoundResult),
+  LinkComponent = AnchorLink,
+}: CompetitionResultsTableProps) {
+  const { t } = useTranslation();
+  const [selectedResult, setSelectedResult] = useState<CompetitionRoundResult | null>(null);
+  const primaryRankingType = getPrimaryRankingType(round.format);
+  const attemptColumnCount = Math.max(0, ...results.map((result) => result.attempts.length));
+  const sortedResults = sortResultsByRanking(results);
+
+  const openDetailsDialog = (result: CompetitionRoundResult) => {
+    if (!shouldOpenResultDetailsDialog()) {
+      return;
+    }
+
+    setSelectedResult(result);
+  };
+
+  const openDetailsDialogFromKeyboard =
+    (result: CompetitionRoundResult) => (event: KeyboardEvent<HTMLTableRowElement>) => {
+      if (event.key !== 'Enter' && event.key !== ' ') {
+        return;
+      }
+
+      if (!shouldOpenResultDetailsDialog()) {
+        return;
+      }
+
+      event.preventDefault();
+      setSelectedResult(result);
+    };
+
+  if (results.length === 0) {
+    return (
+      <div className="rounded-md border border-tertiary-weak bg-panel p-4 text-muted">
+        {t('competition.results.noResults')}
+      </div>
+    );
+  }
+
+  return (
+    <div className="w-full overflow-x-auto border border-tertiary-weak bg-panel text-default">
+      <table
+        aria-label={t('competition.results.title')}
+        className="w-full min-w-[22rem] table-fixed type-body-sm sm:min-w-[30rem] md:min-w-[56rem]">
+        <colgroup>
+          <col className="w-10 sm:w-12" />
+          <col />
+          {Array.from({ length: attemptColumnCount }, (_, attemptIndex) => (
+            <col key={attemptIndex} className="hidden w-24 md:table-column" />
+          ))}
+          <col className="w-20 sm:w-24" />
+          <col className="w-20 sm:w-24" />
+        </colgroup>
+        <thead>
+          <tr className="border-b border-tertiary-weak bg-gray-100 type-body-xs font-semibold text-gray-800 dark:bg-gray-900 dark:text-gray-100">
+            <th scope="col" className="px-1 py-2 text-right sm:px-2">
+              {t('competition.results.rank')}
+            </th>
+            <th scope="col" className="px-2 py-2 text-left">
+              {t('competition.results.competitor')}
+            </th>
+            {Array.from({ length: attemptColumnCount }, (_, attemptIndex) => (
+              <th
+                key={attemptIndex}
+                scope="col"
+                className="hidden whitespace-nowrap px-3 py-2 text-right text-gray-600 dark:text-gray-300 md:table-cell">
+                {attemptIndex + 1}
+              </th>
+            ))}
+            <th
+              scope="col"
+              className="border-l-2 border-tertiary px-2 py-2 text-right sm:px-3 md:px-2">
+              {primaryRankingType === 'average'
+                ? t('competition.results.average')
+                : t('competition.results.best')}
+            </th>
+            <th scope="col" className="px-2 py-2 text-right sm:px-3 md:px-2">
+              {t('competition.results.best')}
+            </th>
+          </tr>
+        </thead>
+        <tbody>
+          {sortedResults.map((result) => {
+            const person = persons.find((p) => p.registrantId === result.personId);
+            const name =
+              person?.name ??
+              result.personName ??
+              t('competition.results.unknownCompetitor', { personId: result.personId });
+            const isRosterOnly = isRosterOnlyResult(result);
+            const droppedAttemptIndexes = getDroppedAttemptIndexes(round.format, result);
+
+            return (
+              <tr
+                key={result.id}
+                className="cursor-pointer border-b border-tertiary-weak hover-transition hover:bg-gray-50 last:border-b-0 dark:hover:bg-gray-700 md:cursor-default"
+                tabIndex={0}
+                onClick={() => openDetailsDialog(result)}
+                onKeyDown={openDetailsDialogFromKeyboard(result)}>
+                <td
+                  className={classNames(
+                    'px-1 py-2 text-right tabular-nums sm:px-2',
+                    result.advancing &&
+                      !result.advancingQuestionable &&
+                      'bg-green-300 text-gray-950 dark:bg-green-700 dark:text-white',
+                    result.advancingQuestionable &&
+                      'bg-yellow-200 text-gray-950 dark:bg-yellow-500 dark:text-gray-950',
+                  )}>
+                  {result.ranking ?? (isRosterOnly ? '' : '-')}
+                </td>
+                <td className="min-w-0 px-2 py-2">
+                  {person && result.personId ? (
+                    <>
+                      <span className="block truncate md:hidden">{name}</span>
+                      <LinkComponent
+                        to={`/competitions/${competitionId}/persons/${person.registrantId}/results`}
+                        className="hidden truncate text-default hover-transition hover:text-primary md:block">
+                        {name}
+                      </LinkComponent>
+                    </>
+                  ) : (
+                    <span className="block truncate">{name}</span>
+                  )}
+                </td>
+                {Array.from({ length: attemptColumnCount }, (_, attemptIndex) => (
+                  <td
+                    key={attemptIndex}
+                    className="hidden whitespace-nowrap px-3 py-2 text-right text-gray-700 tabular-nums dark:text-gray-300 md:table-cell">
+                    {result.attempts[attemptIndex]
+                      ? renderAttemptDisplayValue(
+                          eventId,
+                          result.attempts[attemptIndex].result,
+                          droppedAttemptIndexes.has(attemptIndex),
+                        )
+                      : isRosterOnly
+                        ? ''
+                        : '-'}
+                  </td>
+                ))}
+                <td className="border-l-2 border-tertiary bg-gray-50 px-2 py-2 text-right font-semibold tabular-nums dark:bg-gray-900/50 sm:px-3 md:px-2">
+                  {isRosterOnly ? (
+                    ''
+                  ) : (
+                    <ResultValue recordTag={getRecordTag(result, primaryRankingType)}>
+                      {renderResultValue(eventId, primaryRankingType, result)}
+                    </ResultValue>
+                  )}
+                </td>
+                <td className="bg-gray-50 px-2 py-2 text-right tabular-nums dark:bg-gray-900/50 sm:px-3 md:px-2">
+                  {isRosterOnly ? (
+                    ''
+                  ) : (
+                    <ResultValue
+                      recordTag={
+                        primaryRankingType === 'average' ? result.singleRecordTag : undefined
+                      }>
+                      {renderResultValue(eventId, 'single', result)}
+                    </ResultValue>
+                  )}
+                </td>
+              </tr>
+            );
+          })}
+        </tbody>
+      </table>
+      {selectedResult &&
+        (() => {
+          const person = persons.find((p) => p.registrantId === selectedResult.personId);
+          const name =
+            person?.name ??
+            selectedResult.personName ??
+            t('competition.results.unknownCompetitor', { personId: selectedResult.personId });
+
+          return (
+            <ResultDetailsDialog
+              competitionId={competitionId}
+              eventId={eventId}
+              name={name}
+              person={person}
+              primaryRankingType={primaryRankingType}
+              result={selectedResult}
+              LinkComponent={LinkComponent}
+              onClose={() => setSelectedResult(null)}
+            />
+          );
+        })()}
+    </div>
+  );
+}
diff --git a/src/containers/CompetitionResults/ResultDetailsDialog.tsx b/src/containers/CompetitionResults/ResultDetailsDialog.tsx
new file mode 100644
index 0000000..6562e5f
--- /dev/null
+++ b/src/containers/CompetitionResults/ResultDetailsDialog.tsx
@@ -0,0 +1,150 @@
+import { EventId, Person, RankingType } from '@wca/helpers';
+import { MouseEvent, useEffect } from 'react';
+import { useTranslation } from 'react-i18next';
+import { AnchorLink, LinkRenderer } from '@/lib/linkRenderer';
+import { renderResultByEventId } from '@/lib/results';
+import type { CompetitionRoundResult } from './CompetitionResultsTable';
+
+interface ResultDetailsDialogItem {
+  label: string;
+  value?: string;
+  link?: {
+    label: string;
+    to: string;
+  };
+}
+
+interface ResultDetailsDialogProps {
+  competitionId: string;
+  eventId: string;
+  name: string;
+  title?: string;
+  details?: ResultDetailsDialogItem[];
+  person?: Person;
+  primaryRankingType: RankingType;
+  result: CompetitionRoundResult;
+  onClose: () => void;
+  LinkComponent?: LinkRenderer;
+}
+
+const renderValue = (eventId: string, rankingType: RankingType, value: number) => {
+  if (value === 0) {
+    return '';
+  }
+
+  return renderResultByEventId(eventId as EventId, rankingType, value);
+};
+
+export function ResultDetailsDialog({
+  competitionId,
+  eventId,
+  name,
+  title,
+  details,
+  person,
+  primaryRankingType,
+  result,
+  onClose,
+  LinkComponent = AnchorLink,
+}: ResultDetailsDialogProps) {
+  const { t } = useTranslation();
+  const attempts = result.attempts
+    .map((attempt) => renderValue(eventId, 'single', attempt.result))
+    .filter(Boolean);
+  const best = renderValue(eventId, 'single', result.best);
+  const average = renderValue(eventId, primaryRankingType, result.average);
+  const defaultDetails: ResultDetailsDialogItem[] = [
+    {
+      label: t('common.name'),
+      value: name,
+      link: person
+        ? {
+            label: t('competition.results.allResults'),
+            to: `/competitions/${competitionId}/persons/${person.registrantId}/results`,
+          }
+        : undefined,
+    },
+  ];
+  const displayedDetails = details ?? defaultDetails;
+  const stopPropagation = (event: MouseEvent<HTMLDivElement>) => {
+    event.stopPropagation();
+  };
+
+  useEffect(() => {
+    const closeOnEscape = (event: KeyboardEvent) => {
+      if (event.key === 'Escape') {
+        onClose();
+      }
+    };
+
+    document.addEventListener('keydown', closeOnEscape);
+
+    return () => {
+      document.removeEventListener('keydown', closeOnEscape);
+    };
+  }, [onClose]);
+
+  return (
+    <div
+      aria-modal="true"
+      className="fixed inset-0 z-50 flex items-center justify-center bg-gray-950/40 p-4"
+      role="dialog"
+      onClick={onClose}>
+      <div className="w-full max-w-xl rounded-md bg-panel p-6 shadow-xl" onClick={stopPropagation}>
+        <div className="space-y-6">
+          <h3 className="type-heading">
+            {title ?? `${name}${result.ranking ? ` #${result.ranking}` : ''}`}
+          </h3>
+
+          <dl className="space-y-4">
+            {displayedDetails.map((detail) => (
+              <div key={detail.label}>
+                <dt className="font-semibold">{detail.label}</dt>
+                {detail.value && <dd>{detail.value}</dd>}
+                {detail.link && (
+                  <dd>
+                    <LinkComponent
+                      to={detail.link.to}
+                      className="text-primary hover-transition hover:underline">
+                      {detail.link.label}
+                    </LinkComponent>
+                  </dd>
+                )}
+              </div>
+            ))}
+
+            {attempts.length > 0 && (
+              <div>
+                <dt className="font-semibold">{t('competition.results.attempts')}</dt>
+                <dd>{attempts.join(', ')}</dd>
+              </div>
+            )}
+
+            {best && (
+              <div>
+                <dt className="font-semibold">{t('competition.results.best')}</dt>
+                <dd>{best}</dd>
+              </div>
+            )}
+
+            {average && (
+              <div>
+                <dt className="font-semibold">{t('competition.results.average')}</dt>
+                <dd>{average}</dd>
+              </div>
+            )}
+          </dl>
+
+          <div className="flex justify-end">
+            <button
+              className="px-2 py-1 font-semibold text-primary hover-transition hover:underline"
+              type="button"
+              onClick={onClose}>
+              {t('common.close')}
+            </button>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/src/containers/CompetitionResults/ResultRecordBadge.tsx b/src/containers/CompetitionResults/ResultRecordBadge.tsx
new file mode 100644
index 0000000..634a0e9
--- /dev/null
+++ b/src/containers/CompetitionResults/ResultRecordBadge.tsx
@@ -0,0 +1,23 @@
+export type ResultRecordTag = string | null | undefined;
+
+interface ResultRecordBadgeProps {
+  tag: ResultRecordTag;
+}
+
+export const normalizeResultRecordTag = (tag: ResultRecordTag) => tag?.toUpperCase();
+
+export function ResultRecordBadge({ tag }: ResultRecordBadgeProps) {
+  const normalizedTag = normalizeResultRecordTag(tag);
+
+  if (!normalizedTag) {
+    return null;
+  }
+
+  return (
+    <span
+      aria-label={`${normalizedTag} record`}
+      className="relative -top-1 inline-flex shrink-0 rounded-sm bg-gray-100 px-0.5 text-[0.55rem] font-bold leading-none text-gray-950 ring-1 ring-gray-300 dark:bg-gray-700 dark:text-gray-100 dark:ring-gray-500">
+      {normalizedTag}
+    </span>
+  );
+}
diff --git a/src/containers/CompetitionResults/ResultsEventRoundSelector.tsx b/src/containers/CompetitionResults/ResultsEventRoundSelector.tsx
new file mode 100644
index 0000000..eaa5b2e
--- /dev/null
+++ b/src/containers/CompetitionResults/ResultsEventRoundSelector.tsx
@@ -0,0 +1,54 @@
+import classNames from 'classnames';
+import { RoundResultStatus, RoundResultStatusBadge } from '@/components/RoundActionPicker';
+import { LinkRenderer } from '@/lib/linkRenderer';
+
+export interface ResultsEventRoundSelectorRound {
+  id: string;
+  roundNumber: number;
+  href: string;
+  resultStatus?: RoundResultStatus;
+}
+
+interface ResultsEventRoundSelectorProps {
+  selectedRoundId: string;
+  rounds: ResultsEventRoundSelectorRound[];
+  LinkComponent: LinkRenderer;
+}
+
+export function ResultsEventRoundSelector({
+  selectedRoundId,
+  rounds,
+  LinkComponent,
+}: ResultsEventRoundSelectorProps) {
+  if (rounds.length <= 1) {
+    return null;
+  }
+
+  return (
+    <nav aria-label="Event rounds" className="lg:hidden">
+      <div className="flex w-full gap-2 overflow-x-auto pb-1">
+        {rounds.map((round) => {
+          const isSelected = round.id === selectedRoundId;
+
+          return (
+            <LinkComponent
+              key={round.id}
+              to={round.href}
+              className={classNames(
+                'flex min-h-11 min-w-20 flex-1 items-center justify-center gap-1 rounded-md border px-2 py-2 text-xs leading-relaxed shadow-sm hover-transition active:translate-y-px focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-blue-500 dark:focus-visible:outline-blue-300 sm:min-h-12 sm:min-w-32 sm:justify-between sm:gap-2 sm:px-4 sm:py-3 sm:text-base',
+                {
+                  'border-blue-700 bg-blue-700 text-white shadow-md dark:border-blue-300 dark:bg-blue-300 dark:text-gray-950':
+                    isSelected,
+                  'border-gray-300 bg-panel text-default hover:border-blue-300 hover:bg-gray-100 dark:border-gray-600 dark:hover:border-blue-500 dark:hover:bg-gray-800':
+                    !isSelected,
+                },
+              )}>
+              <span className="whitespace-nowrap">{`Round ${round.roundNumber}`}</span>
+              <RoundResultStatusBadge status={round.resultStatus} size="sm" />
+            </LinkComponent>
+          );
+        })}
+      </div>
+    </nav>
+  );
+}
diff --git a/src/containers/CompetitionResults/advancement.ts b/src/containers/CompetitionResults/advancement.ts
new file mode 100644
index 0000000..7ff2625
--- /dev/null
+++ b/src/containers/CompetitionResults/advancement.ts
@@ -0,0 +1,90 @@
+import { RankingType, Round } from '@wca/helpers';
+import { RoundAdvancementCondition } from '@/lib/wcif';
+import { CompetitionRoundResult } from './CompetitionResultsTable';
+import { normalizeResultRecordTag } from './ResultRecordBadge';
+
+const averagedFormats = new Set(['a', 'm', '5', 'h']);
+
+const getPrimaryRankingType = (round: Pick<Round, 'format'>): RankingType =>
+  averagedFormats.has(round.format) ? 'average' : 'single';
+
+const getRankLimit = (
+  resultCondition: RoundAdvancementCondition['resultCondition'],
+  resultCount: number,
+) => {
+  if (resultCondition.type === 'ranking') {
+    return resultCondition.value;
+  }
+
+  if (resultCondition.type === 'percent') {
+    return Math.ceil((resultCount * resultCondition.value) / 100);
+  }
+
+  return null;
+};
+
+const getResultValue = (result: Round['results'][number], scope: RankingType) =>
+  scope === 'average' ? result.average : result.best;
+
+const isAdvancingFromStoredResult = (
+  round: Round,
+  result: Round['results'][number],
+  advancementCondition: RoundAdvancementCondition | null,
+) => {
+  if (!advancementCondition) {
+    return false;
+  }
+
+  const { resultCondition } = advancementCondition;
+  const rankedResultCount = round.results.filter(
+    (roundResult) => roundResult.ranking != null,
+  ).length;
+  const rankLimit = getRankLimit(resultCondition, rankedResultCount);
+
+  if (rankLimit != null) {
+    return result.ranking != null && result.ranking <= rankLimit;
+  }
+
+  if (resultCondition.type !== 'resultAchieved') {
+    return false;
+  }
+
+  if (resultCondition.value == null) {
+    return false;
+  }
+
+  const scope = resultCondition.scope ?? getPrimaryRankingType(round);
+  const resultValue = getResultValue(result, scope);
+
+  return resultValue > 0 && resultValue < resultCondition.value;
+};
+
+export const getStoredRoundResults = (
+  round: Round,
+  advancementCondition: RoundAdvancementCondition | null,
+): CompetitionRoundResult[] =>
+  round.results.map((result) => {
+    const resultWithRecords = result as typeof result & {
+      regionalSingleRecord?: string | null;
+      regionalAverageRecord?: string | null;
+      singleRecordTag?: string | null;
+      averageRecordTag?: string | null;
+    };
+
+    return {
+      id: result.personId,
+      personId: result.personId,
+      ranking: result.ranking,
+      advancing: isAdvancingFromStoredResult(round, result, advancementCondition),
+      advancingQuestionable: false,
+      attempts: result.attempts.map((attempt) => ({ result: attempt.result })),
+      best: result.best,
+      average: result.average,
+      singleRecordTag: normalizeResultRecordTag(
+        resultWithRecords.singleRecordTag ?? resultWithRecords.regionalSingleRecord,
+      ),
+      averageRecordTag: normalizeResultRecordTag(
+        resultWithRecords.averageRecordTag ?? resultWithRecords.regionalAverageRecord,
+      ),
+    };
+  });
diff --git a/src/containers/CompetitionResults/index.ts b/src/containers/CompetitionResults/index.ts
new file mode 100644
index 0000000..c4b6944
--- /dev/null
+++ b/src/containers/CompetitionResults/index.ts
@@ -0,0 +1 @@
+export * from './CompetitionResults';
diff --git a/src/containers/CompetitionResults/resultDetailsViewport.ts b/src/containers/CompetitionResults/resultDetailsViewport.ts
new file mode 100644
index 0000000..d444127
--- /dev/null
+++ b/src/containers/CompetitionResults/resultDetailsViewport.ts
@@ -0,0 +1,4 @@
+export const shouldOpenResultDetailsDialog = () =>
+  typeof window === 'undefined' ||
+  !window.matchMedia ||
+  window.matchMedia('(max-width: 767px)').matches;
diff --git a/src/containers/CompetitionResults/resultSources.ts b/src/containers/CompetitionResults/resultSources.ts
new file mode 100644
index 0000000..6e008dd
--- /dev/null
+++ b/src/containers/CompetitionResults/resultSources.ts
@@ -0,0 +1,123 @@
+import { Competition, Person } from '@wca/helpers';
+import { WcaCompetitionResult } from '@/lib/api';
+import { CompetitionRoundResult } from './CompetitionResultsTable';
+import { normalizeResultRecordTag } from './ResultRecordBadge';
+
+const roundTypeOrder = ['0', '1', 'c', '2', 'e', '3', 'b', 'd', 'f'];
+
+const compareRoundTypeIds = (a: string, b: string) => {
+  const aIndex = roundTypeOrder.indexOf(a);
+  const bIndex = roundTypeOrder.indexOf(b);
+
+  if (aIndex !== -1 && bIndex !== -1) {
+    return aIndex - bIndex;
+  }
+
+  if (aIndex !== -1) {
+    return -1;
+  }
+
+  if (bIndex !== -1) {
+    return 1;
+  }
+
+  return a.localeCompare(b);
+};
+
+export const findPersonForApiResult = (persons: Person[], result: WcaCompetitionResult) =>
+  persons.find(
+    (person) =>
+      (result.wca_id && person.wcaId === result.wca_id) ||
+      person.name.toLocaleLowerCase() === result.name.toLocaleLowerCase(),
+  );
+
+export const getWcaApiRoundTypeMap = (results: WcaCompetitionResult[]) => {
+  const roundTypeIdsByEventId = new Map<string, string[]>();
+
+  results.forEach((result) => {
+    const existingRoundTypeIds = roundTypeIdsByEventId.get(result.event_id) ?? [];
+
+    if (!existingRoundTypeIds.includes(result.round_type_id)) {
+      roundTypeIdsByEventId.set(result.event_id, [...existingRoundTypeIds, result.round_type_id]);
+    }
+  });
+
+  roundTypeIdsByEventId.forEach((roundTypeIds, eventId) => {
+    roundTypeIdsByEventId.set(eventId, [...roundTypeIds].sort(compareRoundTypeIds));
+  });
+
+  return roundTypeIdsByEventId;
+};
+
+const getRoundIdForApiResult = (
+  wcif: Competition,
+  roundTypeIdsByEventId: Map<string, string[]>,
+  result: WcaCompetitionResult,
+) => {
+  const event = wcif.events.find((candidate) => candidate.id === result.event_id);
+  const roundTypeIds = roundTypeIdsByEventId.get(result.event_id) ?? [];
+  const numericRoundNumber = Number(result.round_type_id);
+
+  if (event && Number.isInteger(numericRoundNumber) && numericRoundNumber > 0) {
+    return event.rounds[numericRoundNumber - 1]?.id ?? `${result.event_id}-r${numericRoundNumber}`;
+  }
+
+  if (event && result.round_type_id === 'f') {
+    return event.rounds.at(-1)?.id ?? `${result.event_id}-r${event.rounds.length}`;
+  }
+
+  const roundTypeIndex = roundTypeIds.indexOf(result.round_type_id);
+
+  return event?.rounds[roundTypeIndex]?.id ?? `${result.event_id}-r${roundTypeIndex + 1}`;
+};
+
+export const getWcaApiResultsByRoundId = (wcif: Competition, results: WcaCompetitionResult[]) => {
+  const roundTypeIdsByEventId = getWcaApiRoundTypeMap(results);
+
+  return results.reduce<Map<string, WcaCompetitionResult[]>>((resultsByRoundId, result) => {
+    const roundId = getRoundIdForApiResult(wcif, roundTypeIdsByEventId, result);
+    const existingResults = resultsByRoundId.get(roundId) ?? [];
+
+    resultsByRoundId.set(roundId, [...existingResults, result]);
+    return resultsByRoundId;
+  }, new Map());
+};
+
+export const toCompetitionRoundResult = (
+  persons: Person[],
+  result: WcaCompetitionResult,
+): CompetitionRoundResult => {
+  const person = findPersonForApiResult(persons, result);
+
+  return {
+    id: result.id,
+    personId: person?.registrantId ?? null,
+    personName: result.name,
+    ranking: result.pos,
+    advancing: false,
+    advancingQuestionable: false,
+    attempts: result.attempts.map((attempt) => ({ result: attempt })),
+    best: result.best,
+    average: result.average,
+    bestAttemptIndex: result.best_index,
+    worstAttemptIndex: result.worst_index,
+    singleRecordTag: normalizeResultRecordTag(result.regional_single_record),
+    averageRecordTag: normalizeResultRecordTag(result.regional_average_record),
+  };
+};
+
+export const getApiRoundResults = (
+  wcif: Competition | undefined,
+  roundId: string | undefined,
+  results: WcaCompetitionResult[] | undefined,
+) => {
+  if (!wcif || !roundId || !results?.length) {
+    return [];
+  }
+
+  const resultsByRoundId = getWcaApiResultsByRoundId(wcif, results);
+
+  return (resultsByRoundId.get(roundId) ?? []).map((result) =>
+    toCompetitionRoundResult(wcif.persons, result),
+  );
+};
diff --git a/src/containers/CompetitionResults/resultsProvider.test.ts b/src/containers/CompetitionResults/resultsProvider.test.ts
new file mode 100644
index 0000000..6cfc85f
--- /dev/null
+++ b/src/containers/CompetitionResults/resultsProvider.test.ts
@@ -0,0 +1,540 @@
+import { Competition, Person } from '@wca/helpers';
+import { WcaLiveCompetitorResult, WcaLiveRound } from '@/hooks/queries/useWcaLive';
+import { WcaCompetitionResult } from '@/lib/api';
+import { getPersonalResultsFromSources, getRoundResultsFromSources } from './resultsProvider';
+
+jest.mock('@/lib/events', () => ({
+  getEventName: (eventId: string) => (eventId === '333' ? '3x3x3 Cube' : eventId),
+}));
+
+const persons: Person[] = [
+  {
+    registrantId: 1,
+    name: 'Alice Solver',
+    wcaUserId: 1001,
+    wcaId: '2010ALIC01',
+    countryIso2: 'US',
+    registration: null,
+    assignments: [{ activityId: 101, assignmentCode: 'competitor', stationNumber: 1 }],
+    extensions: [],
+  },
+  {
+    registrantId: 2,
+    name: 'Bob Solver',
+    wcaUserId: 1002,
+    wcaId: '2010BOBS01',
+    countryIso2: 'US',
+    registration: null,
+    assignments: [{ activityId: 101, assignmentCode: 'competitor', stationNumber: 2 }],
+    extensions: [],
+  },
+  {
+    registrantId: 3,
+    name: 'Casey Solver',
+    wcaUserId: 1003,
+    wcaId: null,
+    countryIso2: 'US',
+    registration: null,
+    assignments: [{ activityId: 101, assignmentCode: 'competitor', stationNumber: 3 }],
+    extensions: [],
+  },
+];
+
+const wcif = {
+  formatVersion: '1.0',
+  id: 'ProviderTest2026',
+  name: 'Provider Test 2026',
+  shortName: 'Provider Test',
+  persons,
+  competitorLimit: null,
+  extensions: [],
+  events: [
+    {
+      id: '333',
+      extensions: [],
+      rounds: [
+        {
+          id: '333-r1',
+          format: 'a',
+          cutoff: null,
+          timeLimit: null,
+          advancementCondition: null,
+          extensions: [],
+          results: [
+            {
+              personId: 1,
+              ranking: 1,
+              attempts: [
+                { result: 1200, reconstruction: null },
+                { result: 1300, reconstruction: null },
+                { result: 1400, reconstruction: null },
+              ],
+              best: 1200,
+              average: 1300,
+            },
+          ],
+        },
+        {
+          id: '333-r2',
+          format: 'a',
+          cutoff: null,
+          timeLimit: null,
+          advancementCondition: null,
+          extensions: [],
+          results: [],
+        },
+        {
+          id: '333-r3',
+          format: 'a',
+          cutoff: null,
+          timeLimit: null,
+          advancementCondition: null,
+          extensions: [],
+          results: [],
+        },
+      ],
+    },
+  ],
+  schedule: {
+    numberOfDays: 1,
+    startDate: '2026-05-03',
+    venues: [
+      {
+        id: 1,
+        name: 'Main Venue',
+        latitudeMicrodegrees: 0,
+        longitudeMicrodegrees: 0,
+        countryIso2: 'US',
+        timezone: 'America/Los_Angeles',
+        rooms: [
+          {
+            id: 1,
+            name: 'Main Room',
+            color: '#ffffff',
+            activities: [
+              {
+                id: 100,
+                name: '3x3x3 Cube Round 1',
+                activityCode: '333-r1',
+                startTime: '2026-05-03T19:00:00Z',
+                endTime: '2026-05-03T20:00:00Z',
+                childActivities: [
+                  {
+                    id: 101,
+                    name: '3x3x3 Cube Round 1 Group 1',
+                    activityCode: '333-r1-g1',
+                    startTime: '2026-05-03T19:00:00Z',
+                    endTime: '2026-05-03T20:00:00Z',
+                    childActivities: [],
+                    extensions: [],
+                  },
+                ],
+                extensions: [],
+              },
+            ],
+            extensions: [],
+          },
+        ],
+        extensions: [],
+      },
+    ],
+  },
+} as Competition;
+
+const selectedRound = (roundIndex: number) => ({
+  event: wcif.events[0],
+  round: wcif.events[0].rounds[roundIndex],
+  roundNumber: roundIndex + 1,
+});
+
+const apiResult = (overrides: Partial<WcaCompetitionResult> = {}): WcaCompetitionResult => ({
+  id: 9000,
+  pos: 2,
+  best: 1100,
+  average: 1200,
+  name: 'Bob Solver',
+  country_iso2: 'US',
+  competition_id: wcif.id,
+  event_id: '333',
+  round_type_id: '2',
+  format_id: 'a',
+  wca_id: '2010BOBS01',
+  attempts: [1100, 1200, 1300],
+  ...overrides,
+});
+
+const liveRound = (results: WcaLiveRound['results']): WcaLiveRound => ({
+  id: 'live-333-r1',
+  format: {
+    id: 'a',
+    numberOfAttempts: 5,
+    sortBy: 'average',
+  },
+  results,
+});
+
+const liveRoundResult = (
+  overrides: Partial<WcaLiveRound['results'][number]> = {},
+): WcaLiveRound['results'][number] => ({
+  id: 'live-bob',
+  ranking: 2,
+  advancing: false,
+  advancingQuestionable: false,
+  attempts: [{ result: 1000 }, { result: 1100 }, { result: 1200 }],
+  best: 1000,
+  average: 1100,
+  person: {
+    id: '2',
+    registrantId: 2,
+    name: 'Bob Solver',
+  },
+  ...overrides,
+});
+
+const livePersonalResult = (
+  overrides: Partial<WcaLiveCompetitorResult> = {},
+): WcaLiveCompetitorResult => ({
+  id: 'live-personal-333-r1',
+  ranking: 1,
+  advancing: false,
+  advancingQuestionable: false,
+  attempts: [{ result: 900 }, { result: 1000 }, { result: 1100 }],
+  best: 900,
+  average: 1000,
+  round: {
+    id: 'live-round-333-r1',
+    name: 'First Round',
+    number: 1,
+    competitionEvent: {
+      id: 'live-event-333',
+      event: {
+        id: '333',
+        name: '3x3x3 Cube',
+        rank: 10,
+      },
+    },
+    format: {
+      id: 'a',
+      numberOfAttempts: 5,
+      sortBy: 'average',
+    },
+  },
+  ...overrides,
+});
+
+describe('resultsProvider', () => {
+  describe('getRoundResultsFromSources', () => {
+    it('returns no round results without WCIF or a selected round', () => {
+      expect(
+        getRoundResultsFromSources({
+          wcif: undefined,
+          selectedRound: selectedRound(0),
+          wcaApiResults: [],
+          wcaLiveRound: undefined,
+        }),
+      ).toEqual([]);
+      expect(
+        getRoundResultsFromSources({
+          wcif,
+          selectedRound: undefined,
+          wcaApiResults: [],
+          wcaLiveRound: undefined,
+        }),
+      ).toEqual([]);
+    });
+
+    it('uses WCA API results when WCIF has no results for a round', () => {
+      const results = getRoundResultsFromSources({
+        wcif,
+        selectedRound: selectedRound(1),
+        wcaApiResults: [apiResult()],
+        wcaLiveRound: undefined,
+      });
+
+      expect(results).toMatchObject([
+        {
+          personId: 2,
+          ranking: 2,
+          best: 1100,
+          average: 1200,
+          attempts: [{ result: 1100 }, { result: 1200 }, { result: 1300 }],
+        },
+      ]);
+    });
+
+    it('prefers WCIF results over WCA API results for the same competitor', () => {
+      const results = getRoundResultsFromSources({
+        wcif,
+        selectedRound: selectedRound(0),
+        wcaApiResults: [
+          apiResult({
+            id: 9001,
+            pos: 4,
+            best: 2100,
+            average: 2200,
+            name: 'Alice Solver',
+            round_type_id: '1',
+            wca_id: '2010ALIC01',
+            attempts: [2100, 2200, 2300],
+          }),
+        ],
+        wcaLiveRound: undefined,
+      });
+
+      expect(results).toHaveLength(1);
+      expect(results[0]).toMatchObject({
+        personId: 1,
+        ranking: 1,
+        best: 1200,
+        average: 1300,
+      });
+    });
+
+    it('prefers WCA Live results and includes roster rows while a round is partial', () => {
+      const results = getRoundResultsFromSources({
+        wcif,
+        selectedRound: selectedRound(0),
+        wcaApiResults: [
+          apiResult({
+            pos: 5,
+            best: 2100,
+            average: 2200,
+            round_type_id: '1',
+            attempts: [2100, 2200, 2300],
+            regional_single_record: 'NR',
+            regional_average_record: 'WR',
+          }),
+        ],
+        wcaLiveRound: liveRound([
+          liveRoundResult(),
+          liveRoundResult({
+            id: 'live-unknown',
+            person: {
+              id: 'unknown',
+              registrantId: null,
+              name: 'Unknown Competitor',
+            },
+          }),
+        ]),
+      });
+
+      expect(results).toHaveLength(4);
+      expect(results.find((result) => result.personId === 2)).toMatchObject({
+        ranking: 2,
+        best: 1000,
+        average: 1100,
+        singleRecordTag: 'NR',
+        averageRecordTag: 'WR',
+      });
+      expect(results.find((result) => result.personId === 1)).toMatchObject({
+        ranking: 1,
+        best: 1200,
+        average: 1300,
+      });
+      expect(results.find((result) => result.personId === 3)).toMatchObject({
+        ranking: null,
+        best: 0,
+        average: 0,
+      });
+      expect(results.find((result) => result.personId == null)).toMatchObject({
+        personName: 'Unknown Competitor',
+      });
+    });
+
+    it('matches WCA API results by WCA ID before using the displayed name', () => {
+      const results = getRoundResultsFromSources({
+        wcif,
+        selectedRound: selectedRound(1),
+        wcaApiResults: [
+          apiResult({
+            name: 'Different Published Name',
+            wca_id: '2010ALIC01',
+          }),
+        ],
+        wcaLiveRound: undefined,
+      });
+
+      expect(results[0]).toMatchObject({
+        personId: 1,
+        personName: 'Different Published Name',
+      });
+    });
+
+    it('maps final round API result types to the final WCIF round', () => {
+      const results = getRoundResultsFromSources({
+        wcif,
+        selectedRound: selectedRound(2),
+        wcaApiResults: [
+          apiResult({
+            id: 9002,
+            round_type_id: 'f',
+          }),
+        ],
+        wcaLiveRound: undefined,
+      });
+
+      expect(results).toHaveLength(1);
+      expect(results[0]).toMatchObject({
+        id: 9002,
+        personId: 2,
+      });
+    });
+  });
+
+  describe('getPersonalResultsFromSources', () => {
+    it('returns no personal results without WCIF', () => {
+      expect(
+        getPersonalResultsFromSources({
+          wcif: undefined,
+          person: persons[0],
+          wcaApiResults: [],
+          wcaLiveResults: [],
+        }),
+      ).toEqual([]);
+    });
+
+    it('merges personal results per round across WCA API, WCIF, and WCA Live', () => {
+      const results = getPersonalResultsFromSources({
+        wcif,
+        person: persons[0],
+        wcaApiResults: [
+          apiResult({
+            id: 9100,
+            pos: 3,
+            best: 700,
+            average: 800,
+            name: 'Alice Solver',
+            round_type_id: '2',
+            wca_id: '2010ALIC01',
+            attempts: [700, 800, 900],
+          }),
+          apiResult({
+            id: 9101,
+            pos: 2,
+            best: 600,
+            average: 700,
+            name: 'Alice Solver',
+            round_type_id: 'f',
+            wca_id: '2010ALIC01',
+            attempts: [600, 700, 800],
+          }),
+        ],
+        wcaLiveResults: [
+          livePersonalResult({
+            ranking: 4,
+            best: 500,
+            average: 600,
+            attempts: [{ result: 500 }, { result: 600 }, { result: 700 }],
+          }),
+        ],
+      });
+
+      expect(results).toHaveLength(1);
+      expect(results[0].rounds).toMatchObject([
+        {
+          roundId: '333-r1',
+          ranking: 4,
+          best: 500,
+          average: 600,
+        },
+        {
+          roundId: '333-r2',
+          ranking: 3,
+          best: 700,
+          average: 800,
+        },
+        {
+          roundId: '333-r3',
+          ranking: 2,
+          best: 600,
+          average: 700,
+        },
+      ]);
+    });
+
+    it('matches personal WCA API results by name when the competitor has no WCA ID', () => {
+      const results = getPersonalResultsFromSources({
+        wcif,
+        person: persons[2],
+        wcaApiResults: [
+          apiResult({
+            id: 9200,
+            pos: 8,
+            best: 1500,
+            average: 1600,
+            name: 'Casey Solver',
+            wca_id: null,
+          }),
+        ],
+        wcaLiveResults: [],
+      });
+
+      expect(results[0].rounds).toMatchObject([
+        {
+          roundId: '333-r2',
+          ranking: 8,
+          best: 1500,
+          average: 1600,
+        },
+      ]);
+    });
+
+    it('sorts live personal events and rounds before merging them', () => {
+      const secondRound = livePersonalResult({
+        id: 'live-personal-333-r2',
+        round: {
+          id: 'live-round-333-r2',
+          name: 'Second Round',
+          number: 2,
+          competitionEvent: {
+            id: 'live-event-333',
+            event: {
+              id: '333',
+              name: '3x3x3 Cube',
+              rank: 10,
+            },
+          },
+          format: {
+            id: 'a',
+            numberOfAttempts: 5,
+            sortBy: 'average',
+          },
+        },
+      });
+      const earlierRankedEvent = livePersonalResult({
+        id: 'live-personal-222-r1',
+        round: {
+          id: 'live-round-222-r1',
+          name: 'First Round',
+          number: 1,
+          competitionEvent: {
+            id: 'live-event-222',
+            event: {
+              id: '222',
+              name: '2x2x2 Cube',
+              rank: 5,
+            },
+          },
+          format: {
+            id: 'a',
+            numberOfAttempts: 5,
+            sortBy: 'average',
+          },
+        },
+      });
+
+      const results = getPersonalResultsFromSources({
+        wcif,
+        person: persons[0],
+        wcaApiResults: [],
+        wcaLiveResults: [secondRound, livePersonalResult(), earlierRankedEvent],
+      });
+
+      expect(results.map((result) => result.eventId)).toEqual(['333', '222']);
+      expect(results.find((result) => result.eventId === '333')?.rounds).toMatchObject([
+        { roundId: '333-r1', roundNumber: 1 },
+        { roundId: '333-r2', roundNumber: 2 },
+      ]);
+    });
+  });
+});
diff --git a/src/containers/CompetitionResults/resultsProvider.ts b/src/containers/CompetitionResults/resultsProvider.ts
new file mode 100644
index 0000000..b475ff9
--- /dev/null
+++ b/src/containers/CompetitionResults/resultsProvider.ts
@@ -0,0 +1,260 @@
+import { Competition, Person } from '@wca/helpers';
+import { WcaLiveCompetitorResult, WcaLiveRound } from '@/hooks/queries/useWcaLive';
+import { WcaCompetitionResult } from '@/lib/api';
+import { getEventName } from '@/lib/events';
+import { findRoundWithEvent } from '@/lib/rounds';
+import { getAdvancementConditionForRound } from '@/lib/wcif';
+import { PersonalRoundResult } from '../CompetitionPersonalResults/CompetitionPersonalResultsTable';
+import { CompetitionRoundResult } from './CompetitionResultsTable';
+import { normalizeResultRecordTag } from './ResultRecordBadge';
+import { getStoredRoundResults } from './advancement';
+import { getApiRoundResults, getWcaApiResultsByRoundId } from './resultSources';
+import { getRoundRosterResults } from './roundRoster';
+
+type SelectedRound = NonNullable<ReturnType<typeof findRoundWithEvent>>;
+
+export interface EventResults {
+  eventId: string;
+  eventName: string;
+  eventRank: number;
+  rounds: PersonalRoundResult[];
+}
+
+const getResultKey = (result: CompetitionRoundResult) =>
+  result.personId == null ? `result-${result.id}` : `person-${result.personId}`;
+
+const mergeRoundResultSources = (
+  ...sources: CompetitionRoundResult[][]
+): CompetitionRoundResult[] => {
+  const resultsByKey = new Map<string, CompetitionRoundResult>();
+
+  sources.forEach((sourceResults) => {
+    sourceResults.forEach((result) => {
+      const key = getResultKey(result);
+      const existingResult = resultsByKey.get(key);
+
+      resultsByKey.set(key, {
+        ...result,
+        singleRecordTag: result.singleRecordTag ?? existingResult?.singleRecordTag,
+        averageRecordTag: result.averageRecordTag ?? existingResult?.averageRecordTag,
+      });
+    });
+  });
+
+  return [...resultsByKey.values()];
+};
+
+const getLiveRoundResults = (wcaLiveRound: WcaLiveRound | null | undefined) =>
+  wcaLiveRound?.results
+    .filter((result) => result.attempts.length > 0)
+    .map<CompetitionRoundResult>((result) => ({
+      id: result.id,
+      personId: result.person.registrantId,
+      personName: result.person.name,
+      ranking: result.ranking,
+      advancing: result.advancing,
+      advancingQuestionable: result.advancingQuestionable,
+      attempts: result.attempts,
+      best: result.best,
+      average: result.average,
+      singleRecordTag: normalizeResultRecordTag(result.singleRecordTag),
+      averageRecordTag: normalizeResultRecordTag(result.averageRecordTag),
+    })) ?? [];
+
+export const getRoundResultsFromSources = ({
+  wcif,
+  selectedRound,
+  wcaLiveRound,
+  wcaApiResults,
+}: {
+  wcif: Competition | undefined;
+  selectedRound: SelectedRound | undefined;
+  wcaLiveRound: WcaLiveRound | null | undefined;
+  wcaApiResults: WcaCompetitionResult[] | undefined;
+}) => {
+  if (!wcif || !selectedRound) {
+    return [];
+  }
+
+  const liveRoundResults = getLiveRoundResults(wcaLiveRound);
+  const storedRoundResults = getStoredRoundResults(
+    selectedRound.round,
+    getAdvancementConditionForRound(selectedRound.event.rounds, selectedRound.round),
+  );
+  const apiRoundResults = getApiRoundResults(wcif, selectedRound.round.id, wcaApiResults);
+
+  if (liveRoundResults.length === 0) {
+    return mergeRoundResultSources(apiRoundResults, storedRoundResults);
+  }
+
+  return mergeRoundResultSources(
+    getRoundRosterResults(wcif, selectedRound.round.id),
+    apiRoundResults,
+    storedRoundResults,
+    liveRoundResults,
+  );
+};
+
+const getStoredPersonalResults = (wcif: Competition, person: Person): EventResults[] =>
+  wcif.events
+    .map((event, eventIndex) => {
+      const rounds = event.rounds
+        .map<PersonalRoundResult | undefined>((round, index) => {
+          const result = round.results.find(
+            (roundResult) => roundResult.personId === person.registrantId,
+          );
+
+          return result
+            ? {
+                roundId: round.id,
+                roundNumber: index + 1,
+                ranking: result.ranking,
+                advancing: false,
+                advancingQuestionable: false,
+                attempts: result.attempts.map((attempt) => ({ result: attempt.result })),
+                best: result.best,
+                average: result.average,
+              }
+            : undefined;
+        })
+        .filter((roundResult): roundResult is PersonalRoundResult => Boolean(roundResult));
+
+      return {
+        eventId: event.id,
+        eventName: getEventName(event.id, event),
+        eventRank: eventIndex,
+        rounds,
+      };
+    })
+    .filter((eventResults) => eventResults.rounds.length > 0);
+
+const getLivePersonalResults = (
+  wcif: Competition,
+  liveResults: WcaLiveCompetitorResult[],
+): EventResults[] => {
+  const liveResultsWithAttempts = liveResults.filter((result) => result.attempts.length > 0);
+  const eventIds = Array.from(
+    new Set(liveResultsWithAttempts.map((result) => result.round.competitionEvent.event.id)),
+  );
+
+  return eventIds
+    .map((eventId) => {
+      const eventResults = liveResultsWithAttempts.filter(
+        (result) => result.round.competitionEvent.event.id === eventId,
+      );
+      const firstResult = eventResults[0];
+      const wcifEvent = wcif.events.find((event) => event.id === eventId);
+
+      return {
+        eventId,
+        eventName: firstResult.round.competitionEvent.event.name,
+        eventRank: firstResult.round.competitionEvent.event.rank,
+        rounds: eventResults
+          .sort((a, b) => a.round.number - b.round.number)
+          .map((result) => ({
+            roundId:
+              wcifEvent?.rounds[result.round.number - 1]?.id ??
+              `${eventId}-r${result.round.number}`,
+            roundName: result.round.name,
+            roundNumber: result.round.number,
+            ranking: result.ranking,
+            advancing: result.advancing,
+            advancingQuestionable: result.advancingQuestionable,
+            attempts: result.attempts,
+            best: result.best,
+            average: result.average,
+          })),
+      };
+    })
+    .sort((a, b) => a.eventRank - b.eventRank);
+};
+
+const getApiPersonalResults = (
+  wcif: Competition,
+  person: Person,
+  apiResults: WcaCompetitionResult[],
+): EventResults[] => {
+  const personResults = apiResults.filter(
+    (result) =>
+      (person.wcaId && result.wca_id === person.wcaId) ||
+      result.name.toLocaleLowerCase() === person.name.toLocaleLowerCase(),
+  );
+  const resultsByRoundId = getWcaApiResultsByRoundId(wcif, personResults);
+
+  return wcif.events
+    .map((event, eventIndex) => {
+      const rounds = event.rounds
+        .map<PersonalRoundResult | undefined>((round, roundIndex) => {
+          const result = resultsByRoundId.get(round.id)?.[0];
+
+          return result
+            ? {
+                roundId: round.id,
+                roundNumber: roundIndex + 1,
+                ranking: result.pos,
+                advancing: false,
+                advancingQuestionable: false,
+                attempts: result.attempts.map((attempt) => ({ result: attempt })),
+                best: result.best,
+                average: result.average,
+              }
+            : undefined;
+        })
+        .filter((roundResult): roundResult is PersonalRoundResult => Boolean(roundResult));
+
+      return {
+        eventId: event.id,
+        eventName: getEventName(event.id, event),
+        eventRank: eventIndex,
+        rounds,
+      };
+    })
+    .filter((eventResults) => eventResults.rounds.length > 0);
+};
+
+const mergeEventResultSources = (...sources: EventResults[][]): EventResults[] => {
+  const eventsById = new Map<string, EventResults>();
+
+  sources.forEach((sourceEvents) => {
+    sourceEvents.forEach((sourceEvent) => {
+      const existingEvent = eventsById.get(sourceEvent.eventId);
+      const roundsById = new Map(
+        existingEvent?.rounds.map((roundResult) => [roundResult.roundId, roundResult]) ?? [],
+      );
+
+      sourceEvent.rounds.forEach((roundResult) => {
+        roundsById.set(roundResult.roundId, roundResult);
+      });
+
+      eventsById.set(sourceEvent.eventId, {
+        ...sourceEvent,
+        eventRank: existingEvent?.eventRank ?? sourceEvent.eventRank,
+        rounds: [...roundsById.values()].sort((a, b) => a.roundNumber - b.roundNumber),
+      });
+    });
+  });
+
+  return [...eventsById.values()].sort((a, b) => a.eventRank - b.eventRank);
+};
+
+export const getPersonalResultsFromSources = ({
+  wcif,
+  person,
+  wcaLiveResults,
+  wcaApiResults,
+}: {
+  wcif: Competition | undefined;
+  person: Person;
+  wcaLiveResults: WcaLiveCompetitorResult[] | undefined;
+  wcaApiResults: WcaCompetitionResult[] | undefined;
+}) => {
+  if (!wcif) {
+    return [];
+  }
+
+  return mergeEventResultSources(
+    wcaApiResults?.length ? getApiPersonalResults(wcif, person, wcaApiResults) : [],
+    getStoredPersonalResults(wcif, person),
+    wcaLiveResults?.length ? getLivePersonalResults(wcif, wcaLiveResults) : [],
+  );
+};
diff --git a/src/containers/CompetitionResults/roundRoster.ts b/src/containers/CompetitionResults/roundRoster.ts
new file mode 100644
index 0000000..427d526
--- /dev/null
+++ b/src/containers/CompetitionResults/roundRoster.ts
@@ -0,0 +1,34 @@
+import { Competition, Person } from '@wca/helpers';
+import { groupActivitiesByRound } from '@/lib/activities';
+import { CompetitionRoundResult } from './CompetitionResultsTable';
+
+const hasCompetitionAssignmentForActivity = (activityIds: Set<number>) => (person: Person) =>
+  person.assignments?.some(
+    (assignment) =>
+      assignment.assignmentCode === 'competitor' && activityIds.has(assignment.activityId),
+  );
+
+export const getRoundRosterResults = (
+  wcif: Competition,
+  roundId: string,
+): CompetitionRoundResult[] => {
+  const groupActivities = groupActivitiesByRound(wcif, roundId);
+  const groupActivityIds = new Set(groupActivities.map((activity) => activity.id));
+
+  if (groupActivityIds.size === 0) {
+    return [];
+  }
+
+  return wcif.persons
+    .filter(hasCompetitionAssignmentForActivity(groupActivityIds))
+    .map((person) => ({
+      id: `roster-${person.registrantId}`,
+      personId: person.registrantId,
+      ranking: null,
+      advancing: false,
+      advancingQuestionable: false,
+      attempts: [],
+      best: 0,
+      average: 0,
+    }));
+};
diff --git a/src/containers/CompetitionRoom/CompetitionRoom.tsx b/src/containers/CompetitionRoom/CompetitionRoom.tsx
index b52406f..625c91e 100644
--- a/src/containers/CompetitionRoom/CompetitionRoom.tsx
+++ b/src/containers/CompetitionRoom/CompetitionRoom.tsx
@@ -150,7 +150,7 @@ export function CompetitionRoomContainer({
         <div className="flex flex-row justify-between">
           <LinkComponent
             to={`/competitions/${competitionId}/rooms`}
-            className="group my-1 flex w-full cursor-pointer flex-row rounded-md border border-primary bg-primary p-2 px-1 transition-colors hover:bg-primary-strong">
+            className="group my-1 flex w-full cursor-pointer flex-row rounded-md border border-primary bg-primary p-2 px-1 hover-transition hover:bg-primary-strong">
             {t('competition.room.back')}
           </LinkComponent>
         </div>
diff --git a/src/containers/CompetitionRound/CompetitionRound.stories.tsx b/src/containers/CompetitionRound/CompetitionRound.stories.tsx
index 92d0868..15435cc 100644
--- a/src/containers/CompetitionRound/CompetitionRound.stories.tsx
+++ b/src/containers/CompetitionRound/CompetitionRound.stories.tsx
@@ -2,6 +2,8 @@ import type { Meta, StoryObj } from '@storybook/react';
 import {
   makeStorybookCompetitionFixtureWithRound,
   makeStorybookEventCompetitionFixture,
+  storybookParticipationConditionLinkedRoundsFixture,
+  storybookParticipationConditionPercentFixture,
 } from '@/storybook/competitionFixtures';
 import { makeCompetitionContainerDecorator } from '@/storybook/competitionStorybook';
 import { CompetitionRoundContainer } from './CompetitionRound';
@@ -24,6 +26,16 @@ export const RoundOne: Story = {
   },
 };
 
+export const ParticipationConditionPercent: Story = {
+  parameters: {
+    competitionFixture: storybookParticipationConditionPercentFixture,
+  },
+  args: {
+    competitionId: 'SeattleSummerOpen2026',
+    roundId: '333-r1',
+  },
+};
+
 export const RoundTwo: Story = {
   args: {
     competitionId: 'SeattleSummerOpen2026',
@@ -31,6 +43,36 @@ export const RoundTwo: Story = {
   },
 };
 
+export const ParticipationConditionLinkedRounds: Story = {
+  parameters: {
+    competitionFixture: storybookParticipationConditionLinkedRoundsFixture,
+  },
+  args: {
+    competitionId: 'SeattleSummerOpen2026',
+    roundId: '333-r2',
+  },
+};
+
+export const DualRoundWithPreviousRound: Story = {
+  parameters: {
+    competitionFixture: storybookParticipationConditionLinkedRoundsFixture,
+  },
+  args: {
+    competitionId: 'SeattleSummerOpen2026',
+    roundId: '333-r2',
+  },
+};
+
+export const DualRoundWithNextRound: Story = {
+  parameters: {
+    competitionFixture: storybookParticipationConditionLinkedRoundsFixture,
+  },
+  args: {
+    competitionId: 'SeattleSummerOpen2026',
+    roundId: '333-r1',
+  },
+};
+
 export const FinalRound: Story = {
   parameters: {
     competitionFixture: makeStorybookCompetitionFixtureWithRound('333-r3', (round) => ({
diff --git a/src/containers/CompetitionRound/CompetitionRound.test.tsx b/src/containers/CompetitionRound/CompetitionRound.test.tsx
new file mode 100644
index 0000000..7e627dc
--- /dev/null
+++ b/src/containers/CompetitionRound/CompetitionRound.test.tsx
@@ -0,0 +1,203 @@
+import '@testing-library/jest-dom';
+import { render, screen } from '@testing-library/react';
+import { Competition } from '@wca/helpers';
+import { AnchorLink } from '@/lib/linkRenderer';
+import { CompetitionRoundContainer } from './CompetitionRound';
+
+jest.mock('@/components/Breadcrumbs/Breadcrumbs', () => ({
+  Breadcrumbs: () => <div>breadcrumbs</div>,
+}));
+
+jest.mock('@/components/Container', () => ({
+  Container: ({ children }: { children: React.ReactNode }) => <div>{children}</div>,
+}));
+
+jest.mock('@/components/CutoffTimeLimitPanel', () => ({
+  CutoffTimeLimitPanel: () => <div>cutoff panel</div>,
+}));
+
+jest.mock('@/lib/activityCodes', () => ({
+  activityCodeToName: (activityCode: string) => activityCode,
+  parseActivityCodeFlexible: (activityCode: string) => {
+    const groupMatch = activityCode.match(/-g(\d+)$/);
+    return {
+      eventId: '333',
+      roundNumber: 2,
+      groupNumber: groupMatch ? parseInt(groupMatch[1], 10) : null,
+      attemptNumber: null,
+    };
+  },
+  toRoundAttemptId: (activityCode: string) => activityCode.replace(/-g\d+$/, ''),
+}));
+
+jest.mock('@/lib/events', () => ({
+  getAllEvents: (wcif: Competition) => wcif.events,
+}));
+
+jest.mock('react-i18next', () => ({
+  useTranslation: () => ({
+    t: (key: string, options?: Record<string, unknown>) => {
+      if (key === 'competition.groups.allGroups') {
+        return 'All Groups';
+      }
+
+      if (key === 'competition.groups.backToEvents') {
+        return 'Back To Events';
+      }
+
+      if (key === 'competition.round.linkedWith') {
+        return `Dual round with ${options?.rounds}`;
+      }
+
+      if (key === 'competition.results.seeResults') {
+        return 'See Results';
+      }
+
+      if (key === 'common.activityCodeToName.round') {
+        return `Round ${options?.roundNumber}`;
+      }
+
+      return key;
+    },
+  }),
+}));
+
+const linkedRoundsCompetition = {
+  formatVersion: '1.0',
+  id: 'TestComp2026',
+  name: 'Test Competition 2026',
+  shortName: 'Test Comp 2026',
+  persons: [],
+  competitorLimit: null,
+  extensions: [],
+  events: [
+    {
+      id: '333',
+      extensions: [],
+      rounds: [
+        {
+          id: '333-r1',
+          format: 'a',
+          cutoff: null,
+          timeLimit: null,
+          advancementCondition: null,
+          results: [],
+        },
+        {
+          id: '333-r2',
+          format: 'a',
+          cutoff: null,
+          timeLimit: null,
+          advancementCondition: null,
+          results: [],
+        },
+        {
+          id: '333-r3',
+          format: 'a',
+          cutoff: null,
+          timeLimit: null,
+          participationRuleset: {
+            participationSource: {
+              type: 'linkedRounds',
+              roundIds: ['333-r1', '333-r2'],
+              resultCondition: {
+                type: 'ranking',
+                value: 12,
+              },
+            },
+          },
+          results: [],
+        },
+      ],
+    },
+  ],
+  schedule: {
+    numberOfDays: 1,
+    startDate: '2026-05-03',
+    venues: [
+      {
+        id: 1,
+        name: 'Main Venue',
+        latitudeMicrodegrees: 0,
+        longitudeMicrodegrees: 0,
+        countryIso2: 'US',
+        timezone: 'America/Los_Angeles',
+        rooms: [
+          {
+            id: 1,
+            name: 'Main Room',
+            color: '#fff',
+            activities: [
+              {
+                id: 10,
+                activityCode: '333-r2',
+                name: '3x3x3 Cube, Round 2',
+                startTime: '2026-05-03T16:00:00Z',
+                endTime: '2026-05-03T17:00:00Z',
+                childActivities: [
+                  {
+                    id: 11,
+                    activityCode: '333-r2-g1',
+                    name: '3x3x3 Cube, Round 2, Group 1',
+                    startTime: '2026-05-03T16:00:00Z',
+                    endTime: '2026-05-03T16:30:00Z',
+                    childActivities: [],
+                    extensions: [],
+                    scrambleSetId: null,
+                  },
+                ],
+                extensions: [],
+                scrambleSetId: null,
+              },
+            ],
+            extensions: [],
+          },
+        ],
+      },
+    ],
+  },
+} as unknown as Competition;
+
+jest.mock('@/providers/WCIFProvider', () => ({
+  useWCIF: () => ({
+    competitionId: 'TestComp2026',
+    wcif: linkedRoundsCompetition,
+    setTitle: () => {},
+  }),
+  useWcifUtils: () => ({
+    roundActivies: linkedRoundsCompetition.schedule.venues[0].rooms[0].activities,
+  }),
+}));
+
+function renderRound(roundId: string) {
+  return render(
+    <CompetitionRoundContainer
+      competitionId="TestComp2026"
+      roundId={roundId}
+      LinkComponent={AnchorLink}
+    />,
+  );
+}
+
+describe('CompetitionRoundContainer', () => {
+  it('shows linked-round context for rounds in a dual-round advancement set', () => {
+    renderRound('333-r2');
+
+    expect(screen.getByText('Dual round with Round 1')).toBeInTheDocument();
+  });
+
+  it('does not show linked-round context for rounds outside a dual-round advancement set', () => {
+    renderRound('333-r3');
+
+    expect(screen.queryByText(/Dual round with/i)).not.toBeInTheDocument();
+  });
+
+  it('links to results for the selected round', () => {
+    renderRound('333-r2');
+
+    expect(screen.getByText('See Results')).toHaveAttribute(
+      'href',
+      '/competitions/TestComp2026/results/333-r2',
+    );
+  });
+});
diff --git a/src/containers/CompetitionRound/CompetitionRound.tsx b/src/containers/CompetitionRound/CompetitionRound.tsx
index ecd83d4..16e5201 100644
--- a/src/containers/CompetitionRound/CompetitionRound.tsx
+++ b/src/containers/CompetitionRound/CompetitionRound.tsx
@@ -3,6 +3,7 @@ import { useTranslation } from 'react-i18next';
 import { Breadcrumbs } from '@/components/Breadcrumbs/Breadcrumbs';
 import { Container } from '@/components/Container';
 import { CutoffTimeLimitPanel } from '@/components/CutoffTimeLimitPanel';
+import { LinkButton } from '@/components/LinkButton';
 import {
   activityCodeToName,
   parseActivityCodeFlexible,
@@ -10,7 +11,9 @@ import {
 } from '@/lib/activityCodes';
 import { getAllEvents } from '@/lib/events';
 import { AnchorLink, LinkRenderer } from '@/lib/linkRenderer';
+import { activityCodeToRoundName, getEventRoundsForRound, joinLabels } from '@/lib/roundLabels';
 import { formatDateTimeRange } from '@/lib/time';
+import { getAdvancementConditionForRound } from '@/lib/wcif';
 import { useWCIF, useWcifUtils } from '@/providers/WCIFProvider';
 
 export interface CompetitionRoundContainerProps {
@@ -36,6 +39,23 @@ export function CompetitionRoundContainer({
     const events = wcif && getAllEvents(wcif);
     return events?.flatMap((e) => e.rounds).find((r) => r.id === roundId);
   }, [roundId, wcif]);
+  const eventRounds = useMemo(
+    () => getEventRoundsForRound(wcif?.events, roundId),
+    [roundId, wcif?.events],
+  );
+  const advancement = useMemo(
+    () => (round ? getAdvancementConditionForRound(eventRounds, round) : null),
+    [eventRounds, round],
+  );
+  const linkedRoundNames = useMemo(() => {
+    if (!advancement || advancement.sourceType !== 'linkedRounds') {
+      return [];
+    }
+
+    return advancement.sourceRoundIds
+      .filter((sourceRoundId) => sourceRoundId !== roundId)
+      .map((sourceRoundId) => activityCodeToRoundName(t, sourceRoundId));
+  }, [advancement, roundId, t]);
 
   const rounds = roundActivies.filter((ra) => toRoundAttemptId(ra.activityCode) === roundId);
   const groups = rounds.flatMap((r) => r.childActivities);
@@ -53,7 +73,20 @@ export function CompetitionRoundContainer({
           ]}
         />
         <div className="flex flex-col space-y-1">
+          {linkedRoundNames.length > 0 && (
+            <p className="type-meta text-muted">
+              {t('competition.round.linkedWith', { rounds: joinLabels(linkedRoundNames) })}
+            </p>
+          )}
           {round && <CutoffTimeLimitPanel round={round} />}
+          {round && (
+            <LinkButton
+              to={`/competitions/${competitionId}/results/${roundId}`}
+              title={t('competition.results.seeResults')}
+              variant="light"
+              LinkComponent={LinkComponent}
+            />
+          )}
         </div>
       </div>
       <ul className="flex flex-col space-y-2 p-2">
@@ -67,7 +100,7 @@ export function CompetitionRoundContainer({
             <LinkComponent
               key={value}
               to={`/competitions/${competitionId}/events/${roundId}/${groupNumber}`}
-              className="flex flex-row list-none rounded-md border border-tertiary bg-tertiary px-3 py-2 transition-colors hover:bg-tertiary-strong group dark:text-white">
+              className="flex flex-row list-none rounded-md border border-tertiary bg-tertiary px-3 py-2 hover-transition hover:bg-tertiary-strong group dark:text-white">
               <li className="flex flex-col">
                 <span className="type-heading">
                   {t('common.activityCodeToName.group', { groupNumber })}
@@ -81,7 +114,7 @@ export function CompetitionRoundContainer({
       <div className="p-2">
         <LinkComponent
           to={`/competitions/${competitionId}/events/`}
-          className="my-1 flex w-full flex-row rounded-md border border-primary bg-primary p-2 px-1 transition-colors hover:bg-primary-strong group dark:text-gray-100">
+          className="my-1 flex w-full flex-row rounded-md border border-primary bg-primary p-2 px-1 hover-transition hover:bg-primary-strong group dark:text-gray-100">
           {t('competition.groups.backToEvents')}
         </LinkComponent>
       </div>
diff --git a/src/containers/CompetitionStats/CompetitionStats.tsx b/src/containers/CompetitionStats/CompetitionStats.tsx
index 4928009..56e9a42 100644
--- a/src/containers/CompetitionStats/CompetitionStats.tsx
+++ b/src/containers/CompetitionStats/CompetitionStats.tsx
@@ -21,29 +21,26 @@ export function CompetitionStatsContainer() {
   const acceptedRegistrationsCount = acceptedRegistrations?.length || 0;
 
   return (
-    <Container className="space-y-2 p-2">
-      <div className="type-heading flex justify-evenly">
+    <Container className="space-y-4 p-2">
+      <div className="grid grid-cols-2 gap-2 type-heading">
         <StatsBox title="Competitors" value={acceptedRegistrationsCount} />
         <StatsBox title="Events" value={eventCount} />
       </div>
-      <hr />
-      <div
-        className="grid w-full"
-        style={{
-          gridTemplateColumns: `repeat(${eventCount}, 1fr)`,
-        }}>
-        {wcif?.events?.map(({ id }) => (
-          <span key={id} className={`cubing-icon event-${id} mx-1 type-body`} />
-        ))}
-        {wcif?.events?.map(({ id }) => (
-          <span key={id} className="type-body-sm text-center">
-            {
-              acceptedRegistrations?.filter(({ registration }) =>
-                registration?.eventIds.includes(id),
-              ).length
-            }
-          </span>
-        ))}
+      <div className="grid grid-cols-2 gap-2 sm:grid-cols-3 md:grid-cols-4">
+        {wcif?.events?.map(({ id }) => {
+          const registrationCount =
+            acceptedRegistrations?.filter(({ registration }) => registration?.eventIds.includes(id))
+              .length ?? 0;
+
+          return (
+            <div
+              key={id}
+              className="flex items-center justify-between gap-2 rounded-md border border-tertiary-weak bg-panel px-3 py-2 shadow-sm">
+              <span className={`cubing-icon event-${id} shrink-0 type-body`} />
+              <span className="type-label text-default">{registrationCount}</span>
+            </div>
+          );
+        })}
       </div>
     </Container>
   );
diff --git a/src/containers/CompetitionSumOfRanks/CompetitionSumOfRanks.tsx b/src/containers/CompetitionSumOfRanks/CompetitionSumOfRanks.tsx
new file mode 100644
index 0000000..3352cec
--- /dev/null
+++ b/src/containers/CompetitionSumOfRanks/CompetitionSumOfRanks.tsx
@@ -0,0 +1,133 @@
+import classNames from 'classnames';
+import { useEffect, useMemo, useState } from 'react';
+import { Popover } from 'react-tiny-popover';
+import { Container } from '@/components/Container';
+import { useWcaCompetitionResults } from '@/hooks/queries/useWcaResults';
+import { AnchorLink, LinkRenderer } from '@/lib/linkRenderer';
+import { useWCIF } from '@/providers/WCIFProvider';
+import { SumOfRanksPersonRanking, getSumOfRanks } from './rankings';
+
+export interface CompetitionSumOfRanksContainerProps {
+  competitionId: string;
+  LinkComponent?: LinkRenderer;
+}
+
+const formatKinch = (kinch: number) => (kinch * 100).toFixed(2);
+
+const formatMedals = (ranking: SumOfRanksPersonRanking) =>
+  ranking.medals.length > 0
+    ? `${ranking.medals.length} (${ranking.medals.map((medal) => medal.eventId).join(', ')})`
+    : '';
+
+function KinchTooltip() {
+  const [open, setOpen] = useState(false);
+
+  return (
+    <Popover
+      isOpen={open}
+      positions={['bottom', 'left']}
+      padding={8}
+      onClickOutside={() => setOpen(false)}
+      content={
+        <div
+          className={classNames(
+            'z-1000 max-w-xs space-y-2 rounded border border-tertiary-weak bg-panel p-3 text-left type-body-sm text-default shadow-md transition-opacity duration-300 opacity-0',
+            {
+              'opacity-100': open,
+            },
+          )}>
+          <p>Kinch is averaged across counted rounds.</p>
+          <p>
+            Each round compares the winning result to the competitor&apos;s result. Missed or
+            invalid results count as 0.
+          </p>
+        </div>
+      }>
+      <button
+        type="button"
+        className="inline-flex h-5 w-5 items-center justify-center rounded-full text-gray-500 hover:bg-gray-200 hover:text-gray-700"
+        aria-label="Explain Kinch"
+        onClick={() => setOpen((current) => !current)}>
+        ?
+      </button>
+    </Popover>
+  );
+}
+
+export function CompetitionSumOfRanksContainer({
+  competitionId,
+  LinkComponent = AnchorLink,
+}: CompetitionSumOfRanksContainerProps) {
+  const { wcif, setTitle } = useWCIF();
+  const { data: wcaApiResults, status: wcaApiResultsStatus } = useWcaCompetitionResults(
+    competitionId,
+    {
+      enabled: Boolean(wcif),
+    },
+  );
+
+  useEffect(() => {
+    setTitle(`${wcif?.name ?? competitionId} Sum of Rankings`);
+  }, [competitionId, setTitle, wcif?.name]);
+
+  const rankings = useMemo(
+    () => (wcif ? getSumOfRanks(wcif, wcaApiResults) : []),
+    [wcaApiResults, wcif],
+  );
+  const isLoadingResults = wcaApiResultsStatus === 'pending' && rankings.length === 0;
+  const roundsCounted = rankings[0]?.roundsCounted ?? 0;
+  const summary =
+    rankings.length > 0
+      ? `${rankings.length} competitors across ${roundsCounted} rounds`
+      : 'No ranked rounds yet.';
+
+  return (
+    <Container className="mx-auto max-w-screen-lg space-y-4 p-2" fullWidth>
+      <h1 className="type-heading">Sum of Rankings</h1>
+
+      {!isLoadingResults && <div className="type-body-sm text-gray-600">{summary}</div>}
+
+      {rankings.length > 0 && (
+        <div className="overflow-x-auto rounded border border-gray-200 shadow-sm">
+          <table className="w-full table-auto whitespace-nowrap type-body">
+            <thead className="bg-gray-100 text-left">
+              <tr>
+                <th className="px-3 py-2 text-right font-semibold">#</th>
+                <th className="px-3 py-2 font-semibold">Competitor</th>
+                <th className="px-3 py-2 text-right font-semibold">Sum</th>
+                <th className="px-3 py-2 text-right font-semibold">
+                  <span className="inline-flex items-center justify-end gap-1">
+                    Kinch
+                    <KinchTooltip />
+                  </span>
+                </th>
+                <th className="hidden px-3 py-2 text-right font-semibold md:table-cell">Medals</th>
+              </tr>
+            </thead>
+            <tbody>
+              {rankings.map((ranking) => (
+                <tr key={ranking.person.registrantId} className="border-t border-gray-200">
+                  <td className="px-3 py-2 text-right">{ranking.position}</td>
+                  <td className="px-3 py-2">
+                    <LinkComponent
+                      className="text-blue-600 hover:underline"
+                      to={`/competitions/${competitionId}/persons/${ranking.person.registrantId}/results`}>
+                      {ranking.person.name}
+                    </LinkComponent>
+                  </td>
+                  <td className="px-3 py-2 text-right font-semibold">{ranking.sumOfRanks}</td>
+                  <td className="px-3 py-2 text-right">{formatKinch(ranking.kinch)}</td>
+                  <td className="hidden px-3 py-2 text-right md:table-cell">
+                    {formatMedals(ranking)}
+                  </td>
+                </tr>
+              ))}
+            </tbody>
+          </table>
+        </div>
+      )}
+
+      {isLoadingResults && <div className="type-body text-gray-600">Loading results...</div>}
+    </Container>
+  );
+}
diff --git a/src/containers/CompetitionSumOfRanks/index.ts b/src/containers/CompetitionSumOfRanks/index.ts
new file mode 100644
index 0000000..7a04def
--- /dev/null
+++ b/src/containers/CompetitionSumOfRanks/index.ts
@@ -0,0 +1 @@
+export * from './CompetitionSumOfRanks';
diff --git a/src/containers/CompetitionSumOfRanks/rankings.test.ts b/src/containers/CompetitionSumOfRanks/rankings.test.ts
new file mode 100644
index 0000000..830286d
--- /dev/null
+++ b/src/containers/CompetitionSumOfRanks/rankings.test.ts
@@ -0,0 +1,201 @@
+import { Competition, Person } from '@wca/helpers';
+import { WcaCompetitionResult } from '@/lib/api';
+import { getSumOfRanks } from './rankings';
+
+jest.mock('@/lib/events', () => ({
+  getAllEvents: (wcif: Competition) => wcif.events,
+  getEventName: (eventId: string) => (eventId === '333' ? '3x3x3 Cube' : eventId),
+}));
+
+const persons: Person[] = [
+  {
+    registrantId: 1,
+    name: 'Alice Solver',
+    wcaUserId: 1001,
+    wcaId: '2010ALIC01',
+    countryIso2: 'US',
+    registration: null,
+    assignments: [],
+    extensions: [],
+  },
+  {
+    registrantId: 2,
+    name: 'Bob Solver',
+    wcaUserId: 1002,
+    wcaId: '2010BOBS01',
+    countryIso2: 'US',
+    registration: null,
+    assignments: [],
+    extensions: [],
+  },
+  {
+    registrantId: 3,
+    name: 'Casey Solver',
+    wcaUserId: 1003,
+    wcaId: null,
+    countryIso2: 'US',
+    registration: null,
+    assignments: [],
+    extensions: [],
+  },
+  {
+    registrantId: 4,
+    name: 'No Results',
+    wcaUserId: 1004,
+    wcaId: null,
+    countryIso2: 'US',
+    registration: null,
+    assignments: [],
+    extensions: [],
+  },
+];
+
+const wcif = {
+  formatVersion: '1.0',
+  id: 'SumRanksTest2026',
+  name: 'Sum Ranks Test 2026',
+  shortName: 'Sum Ranks Test',
+  persons,
+  competitorLimit: null,
+  extensions: [],
+  events: [
+    {
+      id: '333',
+      extensions: [],
+      rounds: [
+        {
+          id: '333-r1',
+          format: 'a',
+          cutoff: null,
+          timeLimit: null,
+          advancementCondition: null,
+          extensions: [],
+          results: [
+            {
+              personId: 1,
+              ranking: 1,
+              attempts: [{ result: 1200, reconstruction: null }],
+              best: 1200,
+              average: 1200,
+            },
+            {
+              personId: 2,
+              ranking: 2,
+              attempts: [{ result: 1300, reconstruction: null }],
+              best: 1300,
+              average: 1300,
+            },
+          ],
+        },
+        {
+          id: '333-r2',
+          format: 'a',
+          cutoff: null,
+          timeLimit: null,
+          advancementCondition: null,
+          extensions: [],
+          results: [
+            {
+              personId: 2,
+              ranking: 1,
+              attempts: [{ result: 1100, reconstruction: null }],
+              best: 1100,
+              average: 1100,
+            },
+          ],
+        },
+        {
+          id: '333-r3',
+          format: 'a',
+          cutoff: null,
+          timeLimit: null,
+          advancementCondition: null,
+          extensions: [],
+          results: [],
+        },
+      ],
+    },
+  ],
+  schedule: { numberOfDays: 1, startDate: '2026-05-03', venues: [] },
+} as Competition;
+
+const apiResult = (overrides: Partial<WcaCompetitionResult> = {}): WcaCompetitionResult => ({
+  id: 9000,
+  pos: 1,
+  best: 1000,
+  average: 1100,
+  name: 'Casey Solver',
+  country_iso2: 'US',
+  competition_id: wcif.id,
+  event_id: '333',
+  round_type_id: '3',
+  format_id: 'a',
+  wca_id: null,
+  attempts: [1000, 1100, 1200],
+  ...overrides,
+});
+
+describe('getSumOfRanks', () => {
+  it('sums rankings across ranked rounds and penalizes missed ranked rounds', () => {
+    const rankings = getSumOfRanks(wcif, []);
+
+    expect(rankings.map((ranking) => [ranking.person.name, ranking.sumOfRanks])).toEqual([
+      ['Bob Solver', 3],
+      ['Alice Solver', 3],
+    ]);
+    expect(rankings.find((ranking) => ranking.person.name === 'Alice Solver')?.missedRounds).toBe(
+      1,
+    );
+    expect(rankings.find((ranking) => ranking.person.name === 'No Results')).toBeUndefined();
+  });
+
+  it('uses WCA API fallback results when WCIF results are missing for a round', () => {
+    const rankings = getSumOfRanks(wcif, [
+      apiResult(),
+      apiResult({
+        id: 9001,
+        pos: 2,
+        name: 'Bob Solver',
+        wca_id: '2010BOBS01',
+        best: 1300,
+        average: 1400,
+      }),
+    ]);
+
+    expect(rankings.map((ranking) => [ranking.person.name, ranking.sumOfRanks])).toEqual([
+      ['Bob Solver', 5],
+      ['Alice Solver', 6],
+      ['Casey Solver', 6],
+    ]);
+    expect(rankings.find((ranking) => ranking.person.name === 'Casey Solver')?.scores).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          roundId: '333-r3',
+          ranking: 1,
+          kinch: 1,
+          medal: true,
+          missed: false,
+        }),
+      ]),
+    );
+    expect(rankings.find((ranking) => ranking.person.name === 'Bob Solver')?.medals).toEqual([
+      expect.objectContaining({ eventId: '333', roundNumber: 3 }),
+    ]);
+  });
+
+  it('ignores rounds that have no WCIF or fallback results', () => {
+    const rankings = getSumOfRanks(wcif, []);
+
+    expect(rankings[0]?.roundsCounted).toBe(2);
+  });
+
+  it('averages Kinch across counted rounds with missed rounds scored as zero', () => {
+    const rankings = getSumOfRanks(wcif, []);
+
+    expect(rankings.find((ranking) => ranking.person.name === 'Alice Solver')?.kinch).toBe(0.5);
+    expect(rankings.find((ranking) => ranking.person.name === 'Bob Solver')?.kinch).toBeCloseTo(
+      0.9615,
+      4,
+    );
+  });
+});
diff --git a/src/containers/CompetitionSumOfRanks/rankings.ts b/src/containers/CompetitionSumOfRanks/rankings.ts
new file mode 100644
index 0000000..9c50049
--- /dev/null
+++ b/src/containers/CompetitionSumOfRanks/rankings.ts
@@ -0,0 +1,219 @@
+import { Competition, Person, Round } from '@wca/helpers';
+import { WcaCompetitionResult } from '@/lib/api';
+import { getEventName } from '@/lib/events';
+import { getAllRoundsWithEvents, RoundWithEvent } from '@/lib/rounds';
+import {
+  findPersonForApiResult,
+  getWcaApiResultsByRoundId,
+} from '../CompetitionResults/resultSources';
+
+export interface SumOfRanksRoundScore {
+  roundId: string;
+  eventId: string;
+  eventName: string;
+  roundNumber: number;
+  ranking: number;
+  kinch: number;
+  medal: boolean;
+  resultCount: number;
+  missed: boolean;
+}
+
+export interface SumOfRanksPersonRanking {
+  person: Person;
+  position: number;
+  sumOfRanks: number;
+  kinch: number;
+  medals: SumOfRanksRoundScore[];
+  roundsCounted: number;
+  missedRounds: number;
+  scores: SumOfRanksRoundScore[];
+}
+
+interface RoundRanking {
+  personId: number;
+  ranking: number;
+  best: number;
+  average: number;
+}
+
+interface RoundWithRankings extends RoundWithEvent {
+  rankings: RoundRanking[];
+  winningResult: RoundRanking | undefined;
+}
+
+const hasAcceptedRegistration = (person: Person) =>
+  !person.registration || person.registration.status === 'accepted';
+
+const getStoredRoundRankings = (round: Round): RoundRanking[] =>
+  round.results
+    .map((result) =>
+      result.ranking == null
+        ? null
+        : {
+            personId: result.personId,
+            ranking: result.ranking,
+            best: result.best,
+            average: result.average,
+          },
+    )
+    .filter((result): result is RoundRanking => Boolean(result));
+
+const getApiRoundRankings = (
+  wcif: Competition,
+  apiResultsByRoundId: Map<string, WcaCompetitionResult[]>,
+  round: Round,
+): RoundRanking[] =>
+  (apiResultsByRoundId.get(round.id) ?? [])
+    .map((result) => {
+      const person = findPersonForApiResult(wcif.persons, result);
+
+      if (!person || result.pos == null) {
+        return null;
+      }
+
+      return {
+        personId: person.registrantId,
+        ranking: result.pos,
+        best: result.best,
+        average: result.average,
+      };
+    })
+    .filter((result): result is RoundRanking => Boolean(result));
+
+const getRoundRankings = (
+  wcif: Competition,
+  apiResultsByRoundId: Map<string, WcaCompetitionResult[]>,
+  round: Round,
+) => {
+  const storedRankings = getStoredRoundRankings(round);
+
+  if (storedRankings.length > 0) {
+    return storedRankings;
+  }
+
+  return getApiRoundRankings(wcif, apiResultsByRoundId, round);
+};
+
+const getRoundsWithRankings = (
+  wcif: Competition,
+  wcaApiResults: WcaCompetitionResult[] | undefined,
+): RoundWithRankings[] => {
+  const apiResultsByRoundId = wcaApiResults?.length
+    ? getWcaApiResultsByRoundId(wcif, wcaApiResults)
+    : new Map<string, WcaCompetitionResult[]>();
+
+  return getAllRoundsWithEvents(wcif)
+    .map((roundWithEvent) => ({
+      ...roundWithEvent,
+      rankings: getRoundRankings(wcif, apiResultsByRoundId, roundWithEvent.round),
+    }))
+    .filter((roundWithEvent) => roundWithEvent.rankings.length > 0)
+    .map((roundWithEvent) => ({
+      ...roundWithEvent,
+      winningResult: roundWithEvent.rankings.find((result) => result.ranking === 1),
+    }));
+};
+
+const getPersonIdsWithResults = (rounds: RoundWithRankings[]) =>
+  new Set(rounds.flatMap((round) => round.rankings.map((result) => result.personId)));
+
+const getRankingResult = (round: Round, result: RoundRanking | undefined) => {
+  if (!result) {
+    return 0;
+  }
+
+  if (['1', '2', '3'].includes(round.format)) {
+    return result.best;
+  }
+
+  return result.average;
+};
+
+const getKinch = (roundWithRankings: RoundWithRankings, result: RoundRanking | undefined) => {
+  const winningResult = getRankingResult(roundWithRankings.round, roundWithRankings.winningResult);
+  const rankingResult = getRankingResult(roundWithRankings.round, result);
+
+  if (!winningResult || rankingResult <= 0) {
+    return 0;
+  }
+
+  if (roundWithRankings.event.id === '333mbf') {
+    return rankingResult / winningResult;
+  }
+
+  return winningResult / rankingResult;
+};
+
+const getScoreForRound = (
+  person: Person,
+  roundWithRankings: RoundWithRankings,
+): SumOfRanksRoundScore => {
+  const personResult = roundWithRankings.rankings.find(
+    (result) => result.personId === person.registrantId,
+  );
+  const resultCount = roundWithRankings.rankings.length;
+
+  return {
+    roundId: roundWithRankings.round.id,
+    eventId: roundWithRankings.event.id,
+    eventName: getEventName(roundWithRankings.event.id, roundWithRankings.event),
+    roundNumber: roundWithRankings.roundNumber,
+    ranking: personResult?.ranking ?? resultCount + 1,
+    kinch: getKinch(roundWithRankings, personResult),
+    medal:
+      roundWithRankings.roundNumber === roundWithRankings.event.rounds.length &&
+      Boolean(personResult?.ranking && personResult.ranking <= 3),
+    resultCount,
+    missed: !personResult,
+  };
+};
+
+const compareRankings = (a: SumOfRanksPersonRanking, b: SumOfRanksPersonRanking) => {
+  const sumDiff = a.sumOfRanks - b.sumOfRanks;
+  const missedDiff = a.missedRounds - b.missedRounds;
+
+  if (sumDiff !== 0) {
+    return sumDiff;
+  }
+
+  if (missedDiff !== 0) {
+    return missedDiff;
+  }
+
+  return a.person.name.localeCompare(b.person.name);
+};
+
+export const getSumOfRanks = (
+  wcif: Competition,
+  wcaApiResults: WcaCompetitionResult[] | undefined,
+): SumOfRanksPersonRanking[] => {
+  const roundsWithRankings = getRoundsWithRankings(wcif, wcaApiResults);
+  const personIdsWithResults = getPersonIdsWithResults(roundsWithRankings);
+
+  return wcif.persons
+    .filter(
+      (person) => hasAcceptedRegistration(person) && personIdsWithResults.has(person.registrantId),
+    )
+    .map<SumOfRanksPersonRanking>((person) => {
+      const scores = roundsWithRankings.map((roundWithRankings) =>
+        getScoreForRound(person, roundWithRankings),
+      );
+
+      return {
+        person,
+        position: 0,
+        sumOfRanks: scores.reduce((total, score) => total + score.ranking, 0),
+        kinch: scores.reduce((total, score) => total + score.kinch, 0) / scores.length,
+        medals: scores.filter((score) => score.medal),
+        roundsCounted: scores.length,
+        missedRounds: scores.filter((score) => score.missed).length,
+        scores,
+      };
+    })
+    .sort(compareRankings)
+    .map((ranking, index) => ({
+      ...ranking,
+      position: index + 1,
+    }));
+};
diff --git a/src/containers/Competitors/CompetitorListItem.tsx b/src/containers/Competitors/CompetitorListItem.tsx
index 77b3f17..a74b476 100644
--- a/src/containers/Competitors/CompetitorListItem.tsx
+++ b/src/containers/Competitors/CompetitorListItem.tsx
@@ -20,7 +20,7 @@ export const CompetitorListItem = ({
 
   return (
     <Link key={person.registrantId} to={`persons/${person.registrantId}`}>
-      <li className="border border-tertiary-weak bg-panel list-none rounded-md flex justify-between cursor-pointer hover:table-bg-row-hover group transition-colors my-1 flex-row min-h-[40px] items-center text-gray-900 dark:text-white type-body">
+      <li className="border border-tertiary-weak bg-panel list-none rounded-md flex justify-between cursor-pointer hover:table-bg-row-hover group hover-transition my-1 flex-row min-h-[40px] items-center text-gray-900 dark:text-white type-body">
         <div className="flex space-x-1">
           {highlight && (
             <div className="flex flex-shrink">
@@ -42,19 +42,21 @@ export const CompetitorListItem = ({
             )}
           </div>
         </div>
-        {bookmarked && !currentAssignmentCode && (
-          <div className="flex items-center flex-shrink px-2 type-title">
-            <span className="text-yellow-500 fa fa-bookmark" />
-          </div>
-        )}
-        {currentAssignmentCode ? (
-          <AssignmentCodeCell
-            as="div"
-            className="p-1 type-body-sm text-muted rounded-md"
-            assignmentCode={currentAssignmentCode}
-            grammar="verb"
-          />
-        ) : null}
+        <div className="flex mr-2 space-x-2">
+          {currentAssignmentCode ? (
+            <AssignmentCodeCell
+              as="div"
+              className="px-1 rounded-[3px] type-body-sm text-muted" //  border radius 3px
+              assignmentCode={currentAssignmentCode}
+              grammar="verb"
+            />
+          ) : null}
+          {bookmarked && !currentAssignmentCode && (
+            <div className="flex items-center flex-shrink type-title">
+              <span className="text-[1.25rem] text-yellow-500 text-md fa fa-bookmark" />
+            </div>
+          )}
+        </div>
       </li>
     </Link>
   );
diff --git a/src/containers/MyCompetitions/MyCompetitions.query.ts b/src/containers/MyCompetitions/MyCompetitions.query.ts
index ecc0b8b..1be874c 100644
--- a/src/containers/MyCompetitions/MyCompetitions.query.ts
+++ b/src/containers/MyCompetitions/MyCompetitions.query.ts
@@ -5,9 +5,9 @@ import { fetchUserWithCompetitions, UserCompsResponse } from '@/lib/api';
 import { FIVE_MINUTES } from '@/lib/constants';
 import { getLocalStorage, setLocalStorage } from '@/lib/localStorage';
 
-export const useMyCompetitionsQuery = (userId?: number) => {
+export const useMyCompetitionsQuery = (userId?: number, options: { enabled?: boolean } = {}) => {
   const { data, ...props } = useQuery<UserCompsResponse, string>({
-    queryKey: ['userCompetitions'],
+    queryKey: ['userCompetitions', userId],
     queryFn: async () => {
       const res = await fetchUserWithCompetitions(userId!.toString());
 
@@ -16,10 +16,15 @@ export const useMyCompetitionsQuery = (userId?: number) => {
 
       return res;
     },
+    staleTime: FIVE_MINUTES,
     gcTime: FIVE_MINUTES,
-    enabled: !!userId,
+    enabled: Boolean(userId && (options.enabled ?? true)),
     initialData: () => {
       const user = JSON.parse(getLocalStorage('user') || 'null') as User;
+      if (user?.id !== userId) {
+        return undefined;
+      }
+
       const upcoming_competitions = JSON.parse(
         getLocalStorage('my.upcoming_competitions') || '[]',
       ) as ApiCompetition[];
diff --git a/src/containers/OngoingActivities/OngoingActivities.tsx b/src/containers/OngoingActivities/OngoingActivities.tsx
index 77937fa..7c6816c 100644
--- a/src/containers/OngoingActivities/OngoingActivities.tsx
+++ b/src/containers/OngoingActivities/OngoingActivities.tsx
@@ -19,20 +19,13 @@ export const OngoingActivities = ({ competitionId }: OngoingActivitiesProps) =>
   );
 
   if (!ongoingActivities?.length) {
-    const subject = `[${wcif?.shortName}]%20NotifyComp%20Support%20Request`;
-    const body = `Hello, I am a ${
-      roles?.some((i) => i.includes('delegate')) ? 'delegate' : 'organizer'
-    } for ${wcif?.shortName} and I would like to learn more about live activity support.`;
-
     return isInChargeOfComp && wcif?.id ? (
       <div className="py-2">
-        <a
-          className="border border-assignment-competitor rounded-md p-2 px-1 flex cursor-pointer hover:bg-assignment-competitor-muted group transition-colors flex-row"
-          href={`mailto:support@notifycomp.com?subject=${subject}&body=${body}`}
-          target="_blank"
-          rel="noreferrer">
-          Elevate your competition, learn about live activity support
-        </a>
+        <Link
+          className="border border-assignment-competitor rounded-md p-2 px-1 flex cursor-pointer hover:bg-assignment-competitor-muted group hover-transition flex-row"
+          to="/live-activities">
+          Learn how to use Live Activities for this competition
+        </Link>
       </div>
     ) : null;
   }
diff --git a/src/containers/PersonalBests/PersonalBests.tsx b/src/containers/PersonalBests/PersonalBests.tsx
index 7c1cd37..3b19aa0 100644
--- a/src/containers/PersonalBests/PersonalBests.tsx
+++ b/src/containers/PersonalBests/PersonalBests.tsx
@@ -1,10 +1,7 @@
 import { Competition, Person } from '@wca/helpers';
-import { hasFlag } from 'country-flag-icons';
-import getUnicodeFlagIcon from 'country-flag-icons/unicode';
 import { Fragment } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Link } from 'react-router-dom';
-import { LinkButton } from '@/components/LinkButton';
 import { eventNameById } from '@/lib/events';
 import { renderResultByEventId } from '@/lib/results';
 import { Ranking } from './Ranking';
@@ -19,26 +16,6 @@ export function PersonalBestsContainer({ wcif, person }: PersonalBestsContainerP
 
   return (
     <>
-      <div className="flex items-center justify-between px-1 text-gray-900 min-h-10 dark:text-white">
-        <div className="flex items-center flex-shrink w-full space-x-1">
-          {hasFlag(person.countryIso2) && (
-            <div className="flex flex-shrink mx-1 type-body sm:type-heading">
-              {getUnicodeFlagIcon(person.countryIso2)}
-            </div>
-          )}
-          <h3 className="type-heading sm:type-title">{person.name}</h3>
-        </div>
-        <a
-          className="w-48 font-mono text-blue-600 type-body sm:type-heading hover:underline dark:text-blue-400"
-          href={`https://www.worldcubeassociation.org/persons/${person.wcaId}`}
-          target="_blank"
-          rel="noreferrer">
-          {person.wcaId}
-          <i className="ml-2 fa fa-solid fa-arrow-up-right-from-square" />
-        </a>
-      </div>
-      <hr className="my-2 border-tertiary-weak" />
-
       <table className="w-full type-body-sm">
         <thead className="bg-assignment-competitor shadow-md dark:shadow-none">
           <tr className="text-assignment-competitor">
@@ -115,14 +92,6 @@ export function PersonalBestsContainer({ wcif, person }: PersonalBestsContainerP
             })}
         </tbody>
       </table>
-      <br />
-      <div className="flex px-1">
-        <LinkButton
-          variant="blue"
-          title={t('competition.personalRecords.viewSchedule')}
-          to={`/competitions/${wcif.id}/persons/${person.registrantId}`}
-        />
-      </div>
     </>
   );
 }
diff --git a/src/containers/PersonalSchedule/PersonHeader.tsx b/src/containers/PersonalSchedule/PersonHeader.tsx
index 12b6f1b..6f1f280 100644
--- a/src/containers/PersonalSchedule/PersonHeader.tsx
+++ b/src/containers/PersonalSchedule/PersonHeader.tsx
@@ -5,9 +5,8 @@ import getUnicodeFlagIcon from 'country-flag-icons/unicode';
 import { useMemo } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Link } from 'react-router-dom';
-import { Button, ExternalLink, LinkButton } from '@/components';
+import { Button } from '@/components/Button';
 import { usePinnedPersons } from '@/hooks/UsePinnedPersons';
-import { useWcaLiveCompetitorLink } from '@/hooks/queries/useWcaLive';
 import { useWCIF } from '@/providers/WCIFProvider';
 
 const fallbackAvatarUrl =
@@ -25,11 +24,6 @@ export const PersonHeader: React.FC<PersonHeaderProps> = ({ person }) => {
   const { pinnedPersons, pinPerson, unpinPerson } = usePinnedPersons(competitionId);
   const isPinned = pinnedPersons.some((i) => i === person.registrantId);
 
-  const { data: wcaLiveLink, status: wcaLiveFetchStatus } = useWcaLiveCompetitorLink(
-    competitionId,
-    person.registrantId.toString(),
-  );
-
   const registeredEventIconClassNames = useMemo(() => {
     const officialEventIds = person.registration?.eventIds || [];
 
@@ -98,23 +92,6 @@ export const PersonHeader: React.FC<PersonHeaderProps> = ({ person }) => {
           </div>
         </div>
       </div>
-      {person.wcaId && (
-        <>
-          <hr className="my-2 border-tertiary-weak" />
-          <div className="flex flex-col px-1 space-y-2">
-            <LinkButton
-              variant="green"
-              title={t('competition.personalSchedule.viewPersonalRecords')}
-              to={`/competitions/${competitionId}/personal-records/${person.wcaId}`}
-            />
-            {wcaLiveFetchStatus === 'success' && (
-              <ExternalLink href={wcaLiveLink}>
-                {t('competition.personalSchedule.viewResults')}
-              </ExternalLink>
-            )}
-          </div>
-        </>
-      )}
     </>
   );
 };
diff --git a/src/containers/PersonalSchedule/PersonalPageLayout.tsx b/src/containers/PersonalSchedule/PersonalPageLayout.tsx
new file mode 100644
index 0000000..f419d36
--- /dev/null
+++ b/src/containers/PersonalSchedule/PersonalPageLayout.tsx
@@ -0,0 +1,106 @@
+import { Person } from '@wca/helpers';
+import classNames from 'classnames';
+import { useTranslation } from 'react-i18next';
+import { Link } from 'react-router-dom';
+import { Container } from '@/components/Container';
+import { PersonHeader } from './PersonHeader';
+
+export type PersonalPage = 'schedule' | 'results' | 'records';
+
+interface PersonalPageLayoutProps {
+  activePage: PersonalPage;
+  children: React.ReactNode;
+  competitionId: string;
+  person: Person;
+}
+
+interface PersonalPageTab {
+  id: PersonalPage;
+  iconClassName: string;
+  label: string;
+  to: string;
+}
+
+const usePersonalPageTabs = (competitionId: string, person: Person) => {
+  const { t } = useTranslation();
+
+  return [
+    {
+      id: 'schedule',
+      iconClassName: 'fa-calendar-days',
+      label: t('competition.personalSchedule.schedule'),
+      to: `/competitions/${competitionId}/persons/${person.registrantId}`,
+    },
+    {
+      id: 'results',
+      iconClassName: 'fa-chart-simple',
+      label: t('competition.personalSchedule.results'),
+      to: `/competitions/${competitionId}/persons/${person.registrantId}/results`,
+    },
+    ...(person.wcaId
+      ? [
+          {
+            id: 'records' as const,
+            iconClassName: 'fa-trophy',
+            label: t('competition.personalSchedule.records'),
+            to: `/competitions/${competitionId}/persons/${person.registrantId}/records`,
+          },
+        ]
+      : []),
+  ] satisfies PersonalPageTab[];
+};
+
+function PersonalPageTabs({
+  activePage,
+  tabs,
+}: {
+  activePage: PersonalPage;
+  tabs: PersonalPageTab[];
+}) {
+  return (
+    <nav className="overflow-hidden rounded-md border border-tertiary-weak bg-panel shadow-sm">
+      <div className="grid grid-flow-col auto-cols-fr">
+        {tabs.map((tab) => {
+          const isActive = tab.id === activePage;
+
+          return (
+            <Link
+              key={tab.id}
+              to={tab.to}
+              className={classNames(
+                'flex min-h-12 items-center justify-center gap-2 border-r border-tertiary-weak px-2 py-2 text-center type-body-sm hover-transition hover:bg-gray-100 last:border-r-0 dark:hover:bg-gray-700 sm:type-body',
+                {
+                  'bg-active text-primary': isActive,
+                  'text-muted': !isActive,
+                },
+              )}>
+              <span className={`fa ${tab.iconClassName}`} aria-hidden="true" />
+              <span className="truncate">{tab.label}</span>
+            </Link>
+          );
+        })}
+      </div>
+    </nav>
+  );
+}
+
+export function PersonalPageLayout({
+  activePage,
+  children,
+  competitionId,
+  person,
+}: PersonalPageLayoutProps) {
+  const tabs = usePersonalPageTabs(competitionId, person);
+
+  return (
+    <div className="w-full pt-4">
+      <Container className="mx-auto w-full">
+        <div className="flex flex-col space-y-4 p-2 type-body">
+          <PersonHeader competitionId={competitionId} person={person} />
+          <PersonalPageTabs activePage={activePage} tabs={tabs} />
+          {children}
+        </div>
+      </Container>
+    </div>
+  );
+}
diff --git a/src/containers/PersonalSchedule/PersonalSchedule.tsx b/src/containers/PersonalSchedule/PersonalSchedule.tsx
index 5974803..9fdcbf1 100644
--- a/src/containers/PersonalSchedule/PersonalSchedule.tsx
+++ b/src/containers/PersonalSchedule/PersonalSchedule.tsx
@@ -3,26 +3,22 @@ import { useTranslation } from 'react-i18next';
 import { DisclaimerText } from '@/components';
 import { useWCIF } from '@/providers/WCIFProvider';
 import { Assignments } from './Assignments';
-import { PersonHeader } from './PersonHeader';
+import { PersonalPageLayout } from './PersonalPageLayout';
 
 export interface PersonalScheduleContainerProps {
   person: Person;
 }
 
-export function PersonalScheduleContainer({ person }: PersonalScheduleContainerProps) {
+export function PersonalScheduleContent({ person }: PersonalScheduleContainerProps) {
   const { t } = useTranslation();
 
-  const { wcif, competitionId } = useWCIF();
+  const { wcif } = useWCIF();
 
   const anyAssignmentsHasStationNumber = !!person.assignments?.some((a) => a.stationNumber);
 
   return (
-    <div className="flex flex-col pt-1 type-body">
-      <PersonHeader competitionId={competitionId} person={person} />
-
-      <hr className="my-2 border-tertiary-weak" />
+    <>
       <DisclaimerText className="mx-1" />
-      <hr className="my-2 border-tertiary-weak" />
 
       {wcif && (
         <>
@@ -40,6 +36,16 @@ export function PersonalScheduleContainer({ person }: PersonalScheduleContainerP
           )}
         </>
       )}
-    </div>
+    </>
+  );
+}
+
+export function PersonalScheduleContainer({ person }: PersonalScheduleContainerProps) {
+  const { competitionId } = useWCIF();
+
+  return (
+    <PersonalPageLayout activePage="schedule" competitionId={competitionId} person={person}>
+      <PersonalScheduleContent person={person} />
+    </PersonalPageLayout>
   );
 }
diff --git a/src/containers/Schedule/Schedule.tsx b/src/containers/Schedule/Schedule.tsx
index 18f3f0c..40006ba 100644
--- a/src/containers/Schedule/Schedule.tsx
+++ b/src/containers/Schedule/Schedule.tsx
@@ -1,15 +1,11 @@
 import { Competition } from '@wca/helpers';
 import { useCallback, useEffect, useMemo } from 'react';
-import { ActivityRow } from '@/components';
 import { useCollapse } from '@/hooks/UseCollapse';
-import {
-  getRoomData,
-  getScheduledDays,
-  getVenueForActivity,
-  hasMultipleScheduleLocations,
-} from '@/lib/activities';
+import { getScheduledDays, hasMultipleScheduleLocations } from '@/lib/activities';
 import { LinkRenderer } from '@/lib/linkRenderer';
 import { ActivityWithRoomOrParent } from '@/lib/types';
+import { ScheduleActivityRow } from './ScheduleActivityRow';
+import { getScheduleActivityGroups } from './scheduleActivityGroups';
 
 const key = (compId: string) => `${compId}-schedule`;
 
@@ -27,10 +23,10 @@ const ScheduleDay = ({
   LinkComponent?: LinkRenderer;
 }) => {
   const { collapsedDates, toggleDate } = useCollapse(key(wcif.id));
-
-  const findVenue = useCallback(() => {
-    return getVenueForActivity(wcif);
-  }, [wcif]);
+  const activityGroups = useMemo(
+    () => getScheduleActivityGroups(wcif, activities),
+    [activities, wcif],
+  );
 
   const collapsed = collapsedDates.includes(date);
   const toggleCollapsed = useCallback(() => {
@@ -40,30 +36,20 @@ const ScheduleDay = ({
   return (
     <div className="flex flex-col">
       <div
-        className="w-full text-center bg-gray-50 dark:bg-gray-800 hover:bg-gray-100 dark:hover:bg-gray-700 text-default font-bold type-heading mb-1 select-none cursor-pointer h-10 transition-colors duration-150"
+        className="w-full text-center bg-gray-50 dark:bg-gray-800 hover:bg-gray-100 dark:hover:bg-gray-700 text-default font-bold type-heading mb-1 select-none cursor-pointer h-10 hover-transition"
         onClick={() => toggleCollapsed()}>
         <span>{date}</span>
         <span className="p-2 flex-end">{collapsed ? ' ▼' : ' ▲'}</span>
       </div>
       <div className="flex flex-col">
-        {(collapsed ? [] : activities).map((activity) => {
-          const venue = findVenue()(activity);
-          const timeZone = venue?.timezone ?? wcif.schedule.venues?.[0]?.timezone ?? '';
-          const room = activity?.parent?.parent?.room || activity?.parent?.room || activity?.room;
-          const stage = room ? getRoomData(room, activity) : undefined;
-
-          return (
-            <ActivityRow
-              key={activity.id}
-              activity={activity}
-              competitionId={wcif.id}
-              LinkComponent={LinkComponent}
-              timeZone={timeZone}
-              stage={stage || room}
-              showRoom={showRoom}
-            />
-          );
-        })}
+        {(collapsed ? [] : activityGroups).map((group) => (
+          <ScheduleActivityRow
+            key={group.id}
+            group={group}
+            LinkComponent={LinkComponent}
+            showRoom={showRoom}
+          />
+        ))}
       </div>
     </div>
   );
diff --git a/src/containers/Schedule/ScheduleActivityRow.tsx b/src/containers/Schedule/ScheduleActivityRow.tsx
new file mode 100644
index 0000000..524229f
--- /dev/null
+++ b/src/containers/Schedule/ScheduleActivityRow.tsx
@@ -0,0 +1,54 @@
+import classNames from 'classnames';
+import { Link } from 'react-router-dom';
+import { RoomPill } from '@/components/Pill';
+import { useNow } from '@/hooks/useNow';
+import { LinkRenderer } from '@/lib/linkRenderer';
+import { formatTimeRange } from '@/lib/time';
+import { ScheduleActivityGroup } from './scheduleActivityGroups';
+
+interface ScheduleActivityRowProps {
+  group: ScheduleActivityGroup;
+  LinkComponent?: LinkRenderer;
+  showRoom?: boolean;
+}
+
+export function ScheduleActivityRow({
+  group,
+  LinkComponent = Link,
+  showRoom = true,
+}: ScheduleActivityRowProps) {
+  const now = useNow();
+  const isOver = new Date(group.endTime).getTime() < now.getTime();
+
+  return (
+    <LinkComponent
+      className={classNames(
+        'flex w-full flex-col p-2 text-left type-body even:table-bg-row-alt hover:table-bg-row-hover',
+        {
+          'opacity-50': isOver,
+        },
+      )}
+      to={group.to}>
+      <span className="type-body">{group.name}</span>
+      <span className="flex items-start justify-between gap-4 type-meta">
+        {showRoom && (
+          <span className="flex min-w-0 flex-wrap gap-2">
+            {group.rooms.map((room) => (
+              <RoomPill
+                key={room.id}
+                className="px-1"
+                style={{
+                  backgroundColor: `${room.color}70`,
+                }}>
+                {room.name}
+              </RoomPill>
+            ))}
+          </span>
+        )}
+        <span className="ml-auto shrink-0 whitespace-nowrap text-right">
+          {formatTimeRange(group.startTime, group.endTime, 5, group.timeZone)}
+        </span>
+      </span>
+    </LinkComponent>
+  );
+}
diff --git a/src/containers/Schedule/scheduleActivityGroups.test.ts b/src/containers/Schedule/scheduleActivityGroups.test.ts
new file mode 100644
index 0000000..b9ffd66
--- /dev/null
+++ b/src/containers/Schedule/scheduleActivityGroups.test.ts
@@ -0,0 +1,111 @@
+import { getScheduleActivityGroups, getScheduleActivityPath } from './scheduleActivityGroups';
+
+jest.mock('@/i18n', () => ({
+  __esModule: true,
+  default: {
+    t: (key: string, options?: { groupNumber?: number; roundNumber?: number }) =>
+      key === 'common.activityCodeToName.group'
+        ? `Group ${options?.groupNumber}`
+        : key === 'common.activityCodeToName.round'
+          ? `Round ${options?.roundNumber}`
+          : key,
+  },
+  t: (key: string, options?: { groupNumber?: number; roundNumber?: number }) =>
+    key === 'common.activityCodeToName.group'
+      ? `Group ${options?.groupNumber}`
+      : key === 'common.activityCodeToName.round'
+        ? `Round ${options?.roundNumber}`
+        : key,
+}));
+
+const makeActivity = ({
+  activityCode,
+  id,
+  name,
+  room,
+}: {
+  activityCode: string;
+  id: number;
+  name: string;
+  room: { color: string; id: number; name: string };
+}) => ({
+  activityCode,
+  childActivities: [],
+  endTime: '2026-06-01T10:10:00Z',
+  extensions: [],
+  id,
+  name,
+  parent: {
+    activityCode: '333-r1',
+    childActivities: [],
+    endTime: '2026-06-01T11:00:00Z',
+    extensions: [],
+    id: id + 1000,
+    name: '3x3x3 Cube, Round 1',
+    room,
+    startTime: '2026-06-01T10:00:00Z',
+  },
+  startTime: '2026-06-01T10:00:00Z',
+});
+
+describe('scheduleActivityGroups', () => {
+  it('groups matching activity codes and keeps unique room chips', () => {
+    const firstRoom = { color: '#ff0000', id: 1, name: 'Red room' };
+    const secondRoom = { color: '#0000ff', id: 2, name: 'Blue room' };
+    const firstActivity = makeActivity({
+      activityCode: '333-r1-g1',
+      id: 101,
+      name: '3x3x3 Cube, Round 1, Group 1',
+      room: firstRoom,
+    });
+    const secondActivity = makeActivity({
+      activityCode: '333-r1-g1',
+      id: 102,
+      name: '3x3x3 Cube, Round 1, Group 1',
+      room: secondRoom,
+    });
+    const wcif = {
+      id: 'ExampleComp2026',
+      schedule: {
+        venues: [
+          {
+            rooms: [
+              {
+                ...firstRoom,
+                activities: [{ ...firstActivity.parent, childActivities: [firstActivity] }],
+              },
+              {
+                ...secondRoom,
+                activities: [{ ...secondActivity.parent, childActivities: [secondActivity] }],
+              },
+            ],
+            timezone: 'America/Los_Angeles',
+          },
+        ],
+      },
+    };
+
+    const groups = getScheduleActivityGroups(
+      wcif as never,
+      [firstActivity, secondActivity] as never,
+    );
+
+    expect(groups).toHaveLength(1);
+    expect(groups[0].activityCode).toBe('333-r1-g1');
+    expect(groups[0].rooms.map((room) => room.name)).toEqual(['Red room', 'Blue room']);
+    expect(groups[0].to).toBe('/competitions/ExampleComp2026/events/333-r1/1');
+  });
+
+  it('links grouped activities to the group page', () => {
+    const activity = makeActivity({
+      activityCode: '333-r2-g3',
+      id: 201,
+      name: '3x3x3 Cube, Round 2, Group 3',
+      room: { color: '#ff0000', id: 1, name: 'Red room' },
+    });
+
+    expect(getScheduleActivityPath('ExampleComp2026', activity as never)).toBe(
+      '/competitions/ExampleComp2026/events/333-r2/3',
+    );
+  });
+});
diff --git a/src/containers/Schedule/scheduleActivityGroups.ts b/src/containers/Schedule/scheduleActivityGroups.ts
new file mode 100644
index 0000000..73023b6
--- /dev/null
+++ b/src/containers/Schedule/scheduleActivityGroups.ts
@@ -0,0 +1,117 @@
+import { Competition, Room, Venue } from '@wca/helpers';
+import { getRoomData, getVenueForActivity } from '@/lib/activities';
+import { activityCodeToName, parseActivityCodeFlexible, toRoundId } from '@/lib/activityCodes';
+import { ActivityWithRoomOrParent } from '@/lib/types';
+
+export interface ScheduleActivityLocation {
+  color: string;
+  id: string;
+  name: string;
+}
+
+export interface ScheduleActivityGroup {
+  activities: ActivityWithRoomOrParent[];
+  activityCode: string;
+  endTime: string;
+  id: string;
+  name: string;
+  rooms: ScheduleActivityLocation[];
+  startTime: string;
+  timeZone?: Venue['timezone'];
+  to: string;
+}
+
+const getActivityRoom = (activity: ActivityWithRoomOrParent): Room | undefined =>
+  activity?.parent?.parent?.room || activity?.parent?.room || activity?.room;
+
+const getActivityLocation = (
+  activity: ActivityWithRoomOrParent,
+): ScheduleActivityLocation | undefined => {
+  const room = getActivityRoom(activity);
+  if (!room) {
+    return undefined;
+  }
+
+  const roomData = getRoomData(room, activity);
+  return {
+    color: roomData.color,
+    id: `${room.id}-${roomData.name}`,
+    name: roomData.name,
+  };
+};
+
+const uniqueLocations = (activities: ActivityWithRoomOrParent[]) =>
+  Array.from(
+    new Map(
+      activities
+        .map(getActivityLocation)
+        .filter((location): location is ScheduleActivityLocation => Boolean(location))
+        .map((location) => [location.id, location]),
+    ).values(),
+  );
+
+const getActivityName = (activity: ActivityWithRoomOrParent) =>
+  activity.activityCode.startsWith('other')
+    ? activity.name || activity.activityCode
+    : activityCodeToName(activity.activityCode);
+
+export const getScheduleActivityPath = (
+  competitionId: string,
+  activity: ActivityWithRoomOrParent,
+) => {
+  try {
+    const { groupNumber, roundNumber } = parseActivityCodeFlexible(activity.activityCode);
+
+    if (roundNumber && groupNumber) {
+      return `/competitions/${competitionId}/events/${toRoundId(activity.activityCode)}/${groupNumber}`;
+    }
+
+    if (roundNumber) {
+      return `/competitions/${competitionId}/events/${toRoundId(activity.activityCode)}`;
+    }
+  } catch {
+    return `/competitions/${competitionId}/activities/${activity.id}`;
+  }
+
+  return `/competitions/${competitionId}/activities/${activity.id}`;
+};
+
+export const getScheduleActivityGroups = (
+  wcif: Competition,
+  activities: ActivityWithRoomOrParent[],
+): ScheduleActivityGroup[] => {
+  const findVenue = getVenueForActivity(wcif);
+  const groupsByActivityCode = activities.reduce((groups, activity) => {
+    const group = groups.get(activity.activityCode) || [];
+    group.push(activity);
+    groups.set(activity.activityCode, group);
+    return groups;
+  }, new Map<string, ActivityWithRoomOrParent[]>());
+
+  return Array.from(groupsByActivityCode.entries())
+    .map(([activityCode, groupedActivities]) => {
+      const sortedActivities = groupedActivities.toSorted((a, b) =>
+        a.startTime.localeCompare(b.startTime),
+      );
+      const firstActivity = sortedActivities[0];
+      const startTime = sortedActivities.map((activity) => activity.startTime).toSorted()[0];
+      const endTime =
+        sortedActivities
+          .map((activity) => activity.endTime)
+          .toSorted()
+          .at(-1) || '';
+
+      return {
+        activities: sortedActivities,
+        activityCode,
+        endTime,
+        id: activityCode,
+        name: firstActivity ? getActivityName(firstActivity) : activityCode,
+        rooms: uniqueLocations(sortedActivities),
+        startTime,
+        timeZone: firstActivity ? findVenue(firstActivity)?.timezone : undefined,
+        to: firstActivity ? getScheduleActivityPath(wcif.id, firstActivity) : '',
+      };
+    })
+    .sort((a, b) => a.startTime.localeCompare(b.startTime));
+};
diff --git a/src/hooks/queries/useWcaLive.ts b/src/hooks/queries/useWcaLive.ts
index a4b6b40..66e9013 100644
--- a/src/hooks/queries/useWcaLive.ts
+++ b/src/hooks/queries/useWcaLive.ts
@@ -1,12 +1,38 @@
 import { useQuery } from '@tanstack/react-query';
 
+const WCA_LIVE_ORIGIN = 'https://live.worldcubeassociation.org';
+
 export const useWcaLiveCompetitionLink = (competitionId: string) => {
   return useQuery({
     retry: false,
     queryKey: ['wca-live/competition-link', competitionId],
+    queryFn: async () => {
+      const response = await fetch(`${WCA_LIVE_ORIGIN}/link/competitions/${competitionId}`);
+      if (!response.ok && response.status === 404) {
+        const { errors } = (await response.json()) as {
+          errors: {
+            detail: string;
+          };
+        };
+        throw new Error(errors.detail);
+      }
+      return response.url;
+    },
+  });
+};
+
+export const useWcaLiveCompetitorLink = (
+  competitionId: string,
+  competitorId: string,
+  options: { enabled?: boolean } = {},
+) => {
+  return useQuery({
+    enabled: options.enabled ?? true,
+    retry: false,
+    queryKey: ['wca-live/competition-competitor-link', competitionId, competitorId],
     queryFn: async () => {
       const response = await fetch(
-        `https://live.worldcubeassociation.org/link/competitions/${competitionId}`,
+        `${WCA_LIVE_ORIGIN}/link/competitions/${competitionId}/competitors/${competitorId}`,
       );
       if (!response.ok && response.status === 404) {
         const { errors } = (await response.json()) as {
@@ -21,13 +47,19 @@ export const useWcaLiveCompetitionLink = (competitionId: string) => {
   });
 };
 
-export const useWcaLiveCompetitorLink = (competitionId: string, competitorId: string) => {
+export const useWcaLiveRoundLink = (
+  competitionId: string,
+  eventId: string,
+  roundNumber: number,
+  options: { enabled?: boolean } = {},
+) => {
   return useQuery({
+    enabled: options.enabled ?? true,
     retry: false,
-    queryKey: ['wca-live/competition-competitor-link', competitionId, competitorId],
+    queryKey: ['wca-live/competition-round-link', competitionId, eventId, roundNumber],
     queryFn: async () => {
       const response = await fetch(
-        `https://live.worldcubeassociation.org/link/competitions/${competitionId}/competitors/${competitorId}`,
+        `${WCA_LIVE_ORIGIN}/link/competitions/${competitionId}/rounds/${eventId}/${roundNumber}`,
       );
       if (!response.ok && response.status === 404) {
         const { errors } = (await response.json()) as {
@@ -41,3 +73,251 @@ export const useWcaLiveCompetitorLink = (competitionId: string, competitorId: st
     },
   });
 };
+
+export interface WcaLiveCompetitorResult {
+  id: string;
+  ranking: number | null;
+  advancing: boolean;
+  advancingQuestionable: boolean;
+  attempts: {
+    result: number;
+  }[];
+  best: number;
+  average: number;
+  singleRecordTag?: string | null;
+  averageRecordTag?: string | null;
+  round: {
+    id: string;
+    name: string;
+    number: number;
+    competitionEvent: {
+      id: string;
+      event: {
+        id: string;
+        name: string;
+        rank: number;
+      };
+    };
+    format: {
+      id: string;
+      numberOfAttempts: number;
+      sortBy: string;
+    };
+  };
+}
+
+export interface WcaLiveRoundResult {
+  id: string;
+  ranking: number | null;
+  advancing: boolean;
+  advancingQuestionable: boolean;
+  attempts: {
+    result: number;
+  }[];
+  best: number;
+  average: number;
+  singleRecordTag?: string | null;
+  averageRecordTag?: string | null;
+  person: {
+    id: string;
+    registrantId: number | null;
+    name: string;
+  };
+}
+
+export interface WcaLiveRound {
+  id: string;
+  results: WcaLiveRoundResult[];
+  format: {
+    id: string;
+    numberOfAttempts: number;
+    sortBy: string;
+  };
+}
+
+interface WcaLiveCompetitorResultsResponse {
+  data?: {
+    person?: {
+      id: string;
+      results: WcaLiveCompetitorResult[];
+    } | null;
+  };
+  errors?: {
+    message: string;
+  }[];
+}
+
+interface WcaLiveRoundResultsResponse {
+  data?: {
+    round?: WcaLiveRound | null;
+  };
+  errors?: {
+    message: string;
+  }[];
+}
+
+const WCA_LIVE_COMPETITOR_RESULTS_QUERY = `
+  query Competitor($id: ID!) {
+    person(id: $id) {
+      id
+      results {
+        id
+        ranking
+        advancing
+        advancingQuestionable
+        attempts {
+          result
+        }
+        best
+        average
+        singleRecordTag
+        averageRecordTag
+        round {
+          id
+          name
+          number
+          competitionEvent {
+            id
+            event {
+              id
+              name
+              rank
+            }
+          }
+          format {
+            id
+            numberOfAttempts
+            sortBy
+          }
+        }
+      }
+    }
+  }
+`;
+
+const WCA_LIVE_ROUND_RESULTS_QUERY = `
+  query Round($id: ID!) {
+    round(id: $id) {
+      id
+      format {
+        id
+        numberOfAttempts
+        sortBy
+      }
+      results {
+        id
+        ranking
+        advancing
+        advancingQuestionable
+        attempts {
+          result
+        }
+        best
+        average
+        singleRecordTag
+        averageRecordTag
+        person {
+          id
+          registrantId
+          name
+        }
+      }
+    }
+  }
+`;
+
+const getCompetitorIdFromWcaLiveUrl = (url: string) => {
+  const match = url.match(/\/competitors\/([^/?#]+)/);
+  return match?.[1];
+};
+
+const getRoundIdFromWcaLiveUrl = (url: string) => {
+  const match = url.match(/\/rounds\/([^/?#]+)/);
+  return match?.[1];
+};
+
+const fetchWcaLiveCompetitorResults = async (competitorUrl: string) => {
+  const competitorId = getCompetitorIdFromWcaLiveUrl(competitorUrl);
+
+  if (!competitorId) {
+    throw new Error('Could not resolve WCA Live competitor id.');
+  }
+
+  const response = await fetch(`${WCA_LIVE_ORIGIN}/api`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify({
+      query: WCA_LIVE_COMPETITOR_RESULTS_QUERY,
+      variables: { id: competitorId },
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`WCA Live results request failed with status ${response.status}.`);
+  }
+
+  const payload = (await response.json()) as WcaLiveCompetitorResultsResponse;
+
+  if (payload.errors?.length) {
+    throw new Error(payload.errors.map((error) => error.message).join('\n'));
+  }
+
+  return payload.data?.person?.results ?? [];
+};
+
+const fetchWcaLiveRoundResults = async (roundUrl: string) => {
+  const roundId = getRoundIdFromWcaLiveUrl(roundUrl);
+
+  if (!roundId) {
+    throw new Error('Could not resolve WCA Live round id.');
+  }
+
+  const response = await fetch(`${WCA_LIVE_ORIGIN}/api`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify({
+      query: WCA_LIVE_ROUND_RESULTS_QUERY,
+      variables: { id: roundId },
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`WCA Live round results request failed with status ${response.status}.`);
+  }
+
+  const payload = (await response.json()) as WcaLiveRoundResultsResponse;
+
+  if (payload.errors?.length) {
+    throw new Error(payload.errors.map((error) => error.message).join('\n'));
+  }
+
+  return payload.data?.round;
+};
+
+export const useWcaLiveCompetitorResults = (
+  competitorUrl: string | undefined,
+  options: { enabled?: boolean } = {},
+) =>
+  useQuery({
+    enabled: Boolean(competitorUrl) && (options.enabled ?? true),
+    queryKey: ['wca-live/competitor-results', competitorUrl],
+    queryFn: () => fetchWcaLiveCompetitorResults(competitorUrl!),
+    refetchInterval: 5 * 60 * 1000,
+    refetchIntervalInBackground: false,
+  });
+
+export const useWcaLiveRoundResults = (
+  roundUrl: string | undefined,
+  options: { enabled?: boolean } = {},
+) =>
+  useQuery({
+    enabled: Boolean(roundUrl) && (options.enabled ?? true),
+    queryKey: ['wca-live/round-results', roundUrl],
+    queryFn: () => fetchWcaLiveRoundResults(roundUrl!),
+    refetchInterval: 5 * 60 * 1000,
+    refetchIntervalInBackground: false,
+  });
diff --git a/src/hooks/queries/useWcaResults.ts b/src/hooks/queries/useWcaResults.ts
new file mode 100644
index 0000000..0731a01
--- /dev/null
+++ b/src/hooks/queries/useWcaResults.ts
@@ -0,0 +1,14 @@
+import { useQuery } from '@tanstack/react-query';
+import { fetchCompetitionResults } from '@/lib/api';
+
+export const useWcaCompetitionResults = (
+  competitionId: string | undefined,
+  options: { enabled?: boolean } = {},
+) =>
+  useQuery({
+    enabled: Boolean(competitionId) && (options.enabled ?? true),
+    queryKey: ['wca/competition-results', competitionId],
+    queryFn: () => fetchCompetitionResults(competitionId!),
+    refetchInterval: 5 * 60 * 1000,
+    refetchIntervalInBackground: false,
+  });
diff --git a/src/hooks/queries/useWcif.ts b/src/hooks/queries/useWcif.ts
index 7e6096c..2bca2c8 100644
--- a/src/hooks/queries/useWcif.ts
+++ b/src/hooks/queries/useWcif.ts
@@ -21,7 +21,10 @@ export const useWcif = (competitionId?: string) =>
         queryClient
           .getQueryData<InfiniteData<CondensedApiCompetiton[]>>(['upcomingCompetitions'])
           ?.pages?.flat() || [];
-      const myUpcomingComps = queryClient?.getQueryData<UserCompsResponse>(['userCompetitions']);
+      const myUpcomingComps = queryClient
+        ?.getQueriesData<UserCompsResponse>({ queryKey: ['userCompetitions'] })
+        .map(([, data]) => data)
+        .find(Boolean);
 
       const allComps = [
         ...upcomingComps,
diff --git a/src/hooks/useAssignmentNotifications/index.ts b/src/hooks/useAssignmentNotifications/index.ts
new file mode 100644
index 0000000..203cfca
--- /dev/null
+++ b/src/hooks/useAssignmentNotifications/index.ts
@@ -0,0 +1 @@
+export * from './useAssignmentNotifications';
diff --git a/src/hooks/useAssignmentNotifications/useAssignmentNotifications.ts b/src/hooks/useAssignmentNotifications/useAssignmentNotifications.ts
new file mode 100644
index 0000000..a16e9ab
--- /dev/null
+++ b/src/hooks/useAssignmentNotifications/useAssignmentNotifications.ts
@@ -0,0 +1,85 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import {
+  AssignmentNotificationStatus,
+  disableAssignmentNotifications,
+  enableAssignmentNotifications,
+  getAssignmentNotificationStatus,
+  isAssignmentNotificationsEnabled,
+} from '@/lib/notifications/assignmentNotifications';
+
+interface UseAssignmentNotificationsParams {
+  competitions: ApiCompetition[];
+  user: User | null;
+}
+
+export function useAssignmentNotifications({
+  competitions,
+  user,
+}: UseAssignmentNotificationsParams) {
+  const [status, setStatus] = useState<AssignmentNotificationStatus>(
+    getAssignmentNotificationStatus,
+  );
+  const [isSaving, setIsSaving] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [isEnabled, setIsEnabled] = useState(isAssignmentNotificationsEnabled);
+
+  useEffect(() => {
+    setStatus(getAssignmentNotificationStatus());
+    setIsEnabled(isAssignmentNotificationsEnabled());
+  }, [user]);
+
+  const watches = useMemo(
+    () =>
+      user
+        ? competitions.map((competition) => ({
+            competitionId: competition.id,
+            wcaUserId: user.id,
+          }))
+        : [],
+    [competitions, user],
+  );
+
+  const enable = useCallback(async () => {
+    setIsSaving(true);
+    setError(null);
+
+    try {
+      const nextStatus = await enableAssignmentNotifications(watches);
+      setStatus(nextStatus);
+      setIsEnabled(isAssignmentNotificationsEnabled());
+    } catch (e) {
+      setError(e instanceof Error ? e.message : 'Unable to enable assignment notifications.');
+      setStatus(getAssignmentNotificationStatus());
+      setIsEnabled(isAssignmentNotificationsEnabled());
+    } finally {
+      setIsSaving(false);
+    }
+  }, [watches]);
+
+  const disable = useCallback(async () => {
+    setIsSaving(true);
+    setError(null);
+
+    try {
+      await disableAssignmentNotifications();
+      setStatus(getAssignmentNotificationStatus());
+      setIsEnabled(isAssignmentNotificationsEnabled());
+    } catch (e) {
+      setError(e instanceof Error ? e.message : 'Unable to disable assignment notifications.');
+      setIsEnabled(isAssignmentNotificationsEnabled());
+    } finally {
+      setIsSaving(false);
+    }
+  }, []);
+
+  return {
+    canEnable: (status === 'default' || status === 'granted') && !isEnabled && watches.length > 0,
+    canDisable: status === 'granted' && isEnabled,
+    enable,
+    disable,
+    error,
+    isSaving,
+    status,
+    watchCount: watches.length,
+  };
+}
diff --git a/src/hooks/useCompetitionRemoteControl/index.ts b/src/hooks/useCompetitionRemoteControl/index.ts
new file mode 100644
index 0000000..bd761ca
--- /dev/null
+++ b/src/hooks/useCompetitionRemoteControl/index.ts
@@ -0,0 +1 @@
+export * from './useCompetitionRemoteControl';
diff --git a/src/hooks/useCompetitionRemoteControl/useCompetitionRemoteControl.test.ts b/src/hooks/useCompetitionRemoteControl/useCompetitionRemoteControl.test.ts
new file mode 100644
index 0000000..1694987
--- /dev/null
+++ b/src/hooks/useCompetitionRemoteControl/useCompetitionRemoteControl.test.ts
@@ -0,0 +1,296 @@
+import { renderHook, act } from '@testing-library/react';
+import { useNotifyCompRemoteActivities } from '@/hooks/useNotifyCompRemoteActivities';
+import { useAuth } from '@/providers/AuthProvider';
+import { useNotifyCompRemoteAuth } from '@/providers/NotifyCompRemoteAuthProvider';
+import { useWCIF } from '@/providers/WCIFProvider';
+import { useCompetitionRemoteControl } from './useCompetitionRemoteControl';
+
+jest.mock('@/hooks/useNotifyCompRemoteActivities', () => ({
+  useNotifyCompRemoteActivities: jest.fn(),
+}));
+jest.mock('@/providers/AuthProvider', () => ({
+  useAuth: jest.fn(),
+}));
+jest.mock('@/providers/NotifyCompRemoteAuthProvider', () => ({
+  useNotifyCompRemoteAuth: jest.fn(),
+}));
+jest.mock('@/providers/WCIFProvider', () => ({
+  useWCIF: jest.fn(),
+}));
+
+const activity = ({
+  activityCode,
+  id,
+  name,
+  startTime,
+}: {
+  activityCode: string;
+  id: number;
+  name: string;
+  startTime: string;
+}) => ({
+  activityCode,
+  childActivities: [],
+  endTime: '2026-06-01T10:10:00Z',
+  extensions: [],
+  id,
+  name,
+  startTime,
+});
+
+const wcif = {
+  persons: [
+    {
+      roles: ['delegate'],
+      wcaUserId: 1,
+    },
+    {
+      roles: ['staff-dataentry'],
+      wcaUserId: 2,
+    },
+  ],
+  schedule: {
+    venues: [
+      {
+        rooms: [
+          {
+            activities: [
+              activity({
+                activityCode: '333-r1-g1',
+                id: 101,
+                name: '3x3x3 Cube, Round 1, Group 1',
+                startTime: '2026-06-01T10:00:00Z',
+              }),
+              activity({
+                activityCode: '222-r1-g1',
+                id: 102,
+                name: '2x2x2 Cube, Round 1, Group 1',
+                startTime: '2026-06-01T10:20:00Z',
+              }),
+            ],
+            id: 1,
+            name: 'Stage 1',
+          },
+        ],
+      },
+    ],
+  },
+};
+
+const wcifWithFourGroups = {
+  ...wcif,
+  schedule: {
+    venues: [
+      {
+        rooms: [
+          {
+            activities: [
+              activity({
+                activityCode: '333-r1-g1',
+                id: 101,
+                name: '3x3x3 Cube, Round 1, Group 1',
+                startTime: '2026-06-01T10:00:00Z',
+              }),
+              activity({
+                activityCode: '333-r1-g2',
+                id: 102,
+                name: '3x3x3 Cube, Round 1, Group 2',
+                startTime: '2026-06-01T10:20:00Z',
+              }),
+              activity({
+                activityCode: '333-r1-g3',
+                id: 103,
+                name: '3x3x3 Cube, Round 1, Group 3',
+                startTime: '2026-06-01T10:40:00Z',
+              }),
+              activity({
+                activityCode: '333-r1-g4',
+                id: 104,
+                name: '3x3x3 Cube, Round 1, Group 4',
+                startTime: '2026-06-01T11:00:00Z',
+              }),
+            ],
+            id: 1,
+            name: 'Stage 1',
+          },
+        ],
+      },
+    ],
+  },
+};
+
+describe('useCompetitionRemoteControl', () => {
+  it('stops and resets the current group before starting the previous group', async () => {
+    const resetActivities = jest.fn().mockResolvedValue(undefined);
+    const startActivities = jest.fn().mockResolvedValue(undefined);
+    const stopActivities = jest.fn().mockResolvedValue(undefined);
+
+    jest.mocked(useWCIF).mockReturnValue({ wcif } as unknown as ReturnType<typeof useWCIF>);
+    jest.mocked(useAuth).mockReturnValue({
+      user: { id: 1 },
+    } as unknown as ReturnType<typeof useAuth>);
+    jest.mocked(useNotifyCompRemoteAuth).mockReturnValue({
+      isAuthenticatedForCompetition: () => true,
+    } as unknown as ReturnType<typeof useNotifyCompRemoteAuth>);
+    jest.mocked(useNotifyCompRemoteActivities).mockReturnValue({
+      activities: [
+        {
+          activityId: 101,
+          endTime: '2026-06-01T10:09:00Z',
+          startTime: '2026-06-01T10:01:00Z',
+        },
+        {
+          activityId: 102,
+          endTime: null,
+          startTime: '2026-06-01T10:21:00Z',
+        },
+      ],
+      resetActivities,
+      startActivities,
+      stopActivities,
+    } as unknown as ReturnType<typeof useNotifyCompRemoteActivities>);
+
+    const { result } = renderHook(() =>
+      useCompetitionRemoteControl({ competitionId: 'ExampleComp2026' }),
+    );
+
+    await act(async () => {
+      await result.current.switchToPreviousGroup();
+    });
+
+    expect(stopActivities).toHaveBeenCalledWith([102]);
+    expect(resetActivities).toHaveBeenCalledWith([102]);
+    expect(startActivities).toHaveBeenCalledWith([101]);
+    expect(stopActivities.mock.invocationCallOrder[0]).toBeLessThan(
+      resetActivities.mock.invocationCallOrder[0],
+    );
+    expect(resetActivities.mock.invocationCallOrder[0]).toBeLessThan(
+      startActivities.mock.invocationCallOrder[0],
+    );
+  });
+
+  it('does not load or perform remote actions for users who are not listed delegates or organizers', async () => {
+    const startActivities = jest.fn().mockResolvedValue(undefined);
+
+    jest.mocked(useWCIF).mockReturnValue({ wcif } as unknown as ReturnType<typeof useWCIF>);
+    jest.mocked(useAuth).mockReturnValue({
+      user: { id: 2 },
+    } as unknown as ReturnType<typeof useAuth>);
+    jest.mocked(useNotifyCompRemoteAuth).mockReturnValue({
+      isAuthenticatedForCompetition: () => true,
+    } as unknown as ReturnType<typeof useNotifyCompRemoteAuth>);
+    jest.mocked(useNotifyCompRemoteActivities).mockReturnValue({
+      activities: [],
+      importCompetition: jest.fn(),
+      resetAllActivities: jest.fn(),
+      startActivities,
+      updateAutoAdvance: jest.fn(),
+    } as unknown as ReturnType<typeof useNotifyCompRemoteActivities>);
+
+    const { result } = renderHook(() =>
+      useCompetitionRemoteControl({ competitionId: 'ExampleComp2026' }),
+    );
+
+    expect(useNotifyCompRemoteActivities).toHaveBeenCalledWith({
+      competitionId: 'ExampleComp2026',
+      enabled: false,
+      roomId: undefined,
+    });
+    expect(result.current.canManageRemote).toBe(false);
+
+    await expect(result.current.startGroup(result.current.activityGroups[0])).rejects.toThrow(
+      'Only listed competition delegates and organizers can manage remote control.',
+    );
+    expect(startActivities).not.toHaveBeenCalled();
+  });
+
+  it('finishes every started activity that has no end time', async () => {
+    const stopActivities = jest.fn().mockResolvedValue(undefined);
+
+    jest.mocked(useWCIF).mockReturnValue({ wcif } as unknown as ReturnType<typeof useWCIF>);
+    jest.mocked(useAuth).mockReturnValue({
+      user: { id: 1 },
+    } as unknown as ReturnType<typeof useAuth>);
+    jest.mocked(useNotifyCompRemoteAuth).mockReturnValue({
+      isAuthenticatedForCompetition: () => true,
+    } as unknown as ReturnType<typeof useNotifyCompRemoteAuth>);
+    jest.mocked(useNotifyCompRemoteActivities).mockReturnValue({
+      activities: [
+        {
+          activityId: 101,
+          endTime: null,
+          startTime: '2026-06-01T10:01:00Z',
+        },
+        {
+          activityId: 102,
+          endTime: '2026-06-01T10:25:00Z',
+          startTime: '2026-06-01T10:21:00Z',
+        },
+        {
+          activityId: 103,
+          endTime: null,
+          startTime: null,
+        },
+      ],
+      stopActivities,
+    } as unknown as ReturnType<typeof useNotifyCompRemoteActivities>);
+
+    const { result } = renderHook(() =>
+      useCompetitionRemoteControl({ competitionId: 'ExampleComp2026' }),
+    );
+
+    await act(async () => {
+      await result.current.finishAllActivities();
+    });
+
+    expect(stopActivities).toHaveBeenCalledWith([101]);
+  });
+
+  it('starts and stops skipped next groups before starting a later target group', async () => {
+    const startActivities = jest.fn().mockResolvedValue(undefined);
+    const stopActivities = jest.fn().mockResolvedValue(undefined);
+
+    jest.mocked(useWCIF).mockReturnValue({
+      wcif: wcifWithFourGroups,
+    } as unknown as ReturnType<typeof useWCIF>);
+    jest.mocked(useAuth).mockReturnValue({
+      user: { id: 1 },
+    } as unknown as ReturnType<typeof useAuth>);
+    jest.mocked(useNotifyCompRemoteAuth).mockReturnValue({
+      isAuthenticatedForCompetition: () => true,
+    } as unknown as ReturnType<typeof useNotifyCompRemoteAuth>);
+    jest.mocked(useNotifyCompRemoteActivities).mockReturnValue({
+      activities: [
+        {
+          activityId: 101,
+          endTime: null,
+          startTime: '2026-06-01T10:01:00Z',
+        },
+      ],
+      startActivities,
+      stopActivities,
+    } as unknown as ReturnType<typeof useNotifyCompRemoteActivities>);
+
+    const { result } = renderHook(() =>
+      useCompetitionRemoteControl({ competitionId: 'ExampleComp2026' }),
+    );
+
+    await act(async () => {
+      await result.current.startGroup(result.current.activityGroups[3]);
+    });
+
+    expect(stopActivities).toHaveBeenNthCalledWith(1, [101]);
+    expect(startActivities).toHaveBeenNthCalledWith(1, [102, 103]);
+    expect(stopActivities).toHaveBeenNthCalledWith(2, [102, 103]);
+    expect(startActivities).toHaveBeenNthCalledWith(2, [104]);
+    expect(stopActivities.mock.invocationCallOrder[0]).toBeLessThan(
+      startActivities.mock.invocationCallOrder[0],
+    );
+    expect(startActivities.mock.invocationCallOrder[0]).toBeLessThan(
+      stopActivities.mock.invocationCallOrder[1],
+    );
+    expect(stopActivities.mock.invocationCallOrder[1]).toBeLessThan(
+      startActivities.mock.invocationCallOrder[1],
+    );
+  });
+});
diff --git a/src/hooks/useCompetitionRemoteControl/useCompetitionRemoteControl.ts b/src/hooks/useCompetitionRemoteControl/useCompetitionRemoteControl.ts
new file mode 100644
index 0000000..6d9529e
--- /dev/null
+++ b/src/hooks/useCompetitionRemoteControl/useCompetitionRemoteControl.ts
@@ -0,0 +1,226 @@
+import { useMemo } from 'react';
+import { useNotifyCompRemoteActivities } from '@/hooks/useNotifyCompRemoteActivities';
+import { isCompetitionDelegateOrOrganizer } from '@/lib/competitionAuthorization';
+import {
+  getRemoteActiveGroups,
+  getRemoteActivityGroups,
+  getRemoteActivityStates,
+  getRemoteNextGroup,
+  getRemotePreviousGroup,
+  getRemoteScheduledActivities,
+  RemoteActivityGroup,
+} from '@/lib/notifyCompRemoteActivities';
+import { useAuth } from '@/providers/AuthProvider';
+import { useNotifyCompRemoteAuth } from '@/providers/NotifyCompRemoteAuthProvider';
+import { useWCIF } from '@/providers/WCIFProvider';
+
+interface UseCompetitionRemoteControlParams {
+  competitionId: string;
+  enabled?: boolean;
+  roomId?: number;
+}
+
+const activityIdsForGroup = (group: RemoteActivityGroup) =>
+  group.scheduledActivities.map((activity) => activity.id);
+
+const isActiveGroup = (group: RemoteActivityGroup) =>
+  group.status === 'current' || group.status === 'mixed';
+
+export function useCompetitionRemoteControl({
+  competitionId,
+  enabled = true,
+  roomId,
+}: UseCompetitionRemoteControlParams) {
+  const { wcif } = useWCIF();
+  const { user } = useAuth();
+  const remoteAuth = useNotifyCompRemoteAuth();
+  const canManageRemote = isCompetitionDelegateOrOrganizer(wcif, user);
+  const isAuthenticated = remoteAuth.isAuthenticatedForCompetition(competitionId);
+  const isEnabled = enabled && isAuthenticated && canManageRemote;
+
+  const remote = useNotifyCompRemoteActivities({
+    competitionId,
+    enabled: isEnabled,
+    roomId,
+  });
+
+  const scheduledActivities = useMemo(
+    () => (wcif ? getRemoteScheduledActivities(wcif, roomId) : []),
+    [roomId, wcif],
+  );
+
+  const activityStates = useMemo(
+    () => getRemoteActivityStates(scheduledActivities, remote.activities),
+    [remote.activities, scheduledActivities],
+  );
+
+  const activityGroups = useMemo(
+    () => getRemoteActivityGroups(scheduledActivities, remote.activities),
+    [remote.activities, scheduledActivities],
+  );
+
+  const activeGroups = useMemo(() => getRemoteActiveGroups(activityGroups), [activityGroups]);
+  const previousGroup = useMemo(() => getRemotePreviousGroup(activityGroups), [activityGroups]);
+  const nextGroup = useMemo(() => getRemoteNextGroup(activityGroups), [activityGroups]);
+
+  const requireRemoteAccess = () => {
+    if (!canManageRemote) {
+      throw new Error(
+        'Only listed competition delegates and organizers can manage remote control.',
+      );
+    }
+  };
+
+  const finishSkippedGroupsBefore = async (group: RemoteActivityGroup) => {
+    const targetIndex = activityGroups.findIndex((candidate) => candidate.id === group.id);
+
+    if (targetIndex < 0) {
+      return;
+    }
+
+    const skippedActivityIds = activityGroups
+      .slice(0, targetIndex)
+      .filter((candidate) => candidate.status === 'next')
+      .flatMap(activityIdsForGroup);
+
+    if (skippedActivityIds.length === 0) {
+      return;
+    }
+
+    await remote.startActivities(skippedActivityIds);
+    await remote.stopActivities(skippedActivityIds);
+  };
+
+  const startGroup = async (group: RemoteActivityGroup) => {
+    requireRemoteAccess();
+    const currentActivityIds = activeGroups.flatMap(activityIdsForGroup);
+
+    if (currentActivityIds.length > 0) {
+      await remote.stopActivities(currentActivityIds);
+    }
+
+    await finishSkippedGroupsBefore(group);
+    return remote.startActivities(activityIdsForGroup(group));
+  };
+  const stopGroup = (group: RemoteActivityGroup) => {
+    requireRemoteAccess();
+    return remote.stopActivities(activityIdsForGroup(group));
+  };
+  const resetGroup = (group: RemoteActivityGroup) => {
+    requireRemoteAccess();
+    return remote.resetActivities(activityIdsForGroup(group));
+  };
+  const startActivity = (activityId: number) => {
+    requireRemoteAccess();
+    return remote.startActivity(activityId);
+  };
+  const stopActivity = (activityId: number) => {
+    requireRemoteAccess();
+    return remote.stopActivity(activityId);
+  };
+  const resetActivity = (activityId: number) => {
+    requireRemoteAccess();
+    return remote.resetActivity(activityId);
+  };
+  const startActivities = (activityIds: number[]) => {
+    requireRemoteAccess();
+    return remote.startActivities(activityIds);
+  };
+  const stopActivities = (activityIds: number[]) => {
+    requireRemoteAccess();
+    return remote.stopActivities(activityIds);
+  };
+  const resetActivities = (activityIds: number[]) => {
+    requireRemoteAccess();
+    return remote.resetActivities(activityIds);
+  };
+  const importCompetition = () => {
+    requireRemoteAccess();
+    return remote.importCompetition();
+  };
+  const resetAllActivities = () => {
+    requireRemoteAccess();
+    return remote.resetAllActivities();
+  };
+  const finishAllActivities = () => {
+    requireRemoteAccess();
+    const unfinishedActivityIds = remote.activities
+      .filter((activity) => activity.startTime && !activity.endTime)
+      .map((activity) => activity.activityId);
+
+    if (unfinishedActivityIds.length === 0) {
+      return Promise.resolve();
+    }
+
+    return remote.stopActivities(unfinishedActivityIds);
+  };
+  const updateAutoAdvance = (autoAdvance: boolean) => {
+    requireRemoteAccess();
+    return remote.updateAutoAdvance(autoAdvance);
+  };
+
+  const switchToGroup = async (group?: RemoteActivityGroup) => {
+    requireRemoteAccess();
+
+    if (!group) {
+      return;
+    }
+
+    const currentActivityIds = activeGroups.flatMap(activityIdsForGroup);
+
+    if (currentActivityIds.length > 0) {
+      await remote.stopActivities(currentActivityIds);
+    }
+
+    if (!isActiveGroup(group)) {
+      await finishSkippedGroupsBefore(group);
+    }
+
+    await remote.startActivities(activityIdsForGroup(group));
+  };
+
+  const switchToPreviousGroup = async () => {
+    requireRemoteAccess();
+
+    if (!previousGroup) {
+      return;
+    }
+
+    const currentActivityIds = activeGroups.flatMap(activityIdsForGroup);
+
+    if (currentActivityIds.length > 0) {
+      await remote.stopActivities(currentActivityIds);
+      await remote.resetActivities(currentActivityIds);
+    }
+
+    await remote.startActivities(activityIdsForGroup(previousGroup));
+  };
+
+  return {
+    ...remote,
+    activeGroups,
+    activityGroups,
+    activityStates,
+    canManageRemote,
+    finishAllActivities,
+    importCompetition,
+    isAuthenticated,
+    isEnabled,
+    nextGroup,
+    previousGroup,
+    resetActivities,
+    resetActivity,
+    resetAllActivities,
+    resetGroup,
+    scheduledActivities,
+    startActivities,
+    startActivity,
+    startGroup,
+    stopActivities,
+    stopActivity,
+    stopGroup,
+    switchToPreviousGroup,
+    switchToGroup,
+    updateAutoAdvance,
+  };
+}
diff --git a/src/hooks/useNotifyCompRemoteActivities/index.ts b/src/hooks/useNotifyCompRemoteActivities/index.ts
new file mode 100644
index 0000000..de57cc4
--- /dev/null
+++ b/src/hooks/useNotifyCompRemoteActivities/index.ts
@@ -0,0 +1 @@
+export * from './useNotifyCompRemoteActivities';
diff --git a/src/hooks/useNotifyCompRemoteActivities/useNotifyCompRemoteActivities.ts b/src/hooks/useNotifyCompRemoteActivities/useNotifyCompRemoteActivities.ts
new file mode 100644
index 0000000..1d780b9
--- /dev/null
+++ b/src/hooks/useNotifyCompRemoteActivities/useNotifyCompRemoteActivities.ts
@@ -0,0 +1,206 @@
+import { useMutation, useQuery } from '@apollo/client';
+import { useEffect, useMemo, useState } from 'react';
+import {
+  ImportRemoteCompetitionDocument,
+  NotifyCompActivity,
+  NotifyCompCompetition,
+  RemoteActivitiesDocument,
+  RemoteActivitiesSubscriptionDocument,
+  RemoteCompetitionDocument,
+  ResetRemoteActivitiesDocument,
+  ResetRemoteActivityDocument,
+  StartRemoteActivitiesDocument,
+  StartRemoteActivityDocument,
+  StopRemoteActivitiesDocument,
+  StopRemoteActivityDocument,
+  UpdateRemoteAutoAdvanceDocument,
+} from '@/lib/notifyCompRemoteGraphql';
+
+interface UseNotifyCompRemoteActivitiesParams {
+  competitionId: string;
+  enabled?: boolean;
+  roomId?: number;
+}
+
+export function useNotifyCompRemoteActivities({
+  competitionId,
+  enabled = true,
+  roomId,
+}: UseNotifyCompRemoteActivitiesParams) {
+  const [mutationError, setMutationError] = useState<string | null>(null);
+
+  const activitiesQuery = useQuery<{ activities: NotifyCompActivity[] }>(RemoteActivitiesDocument, {
+    variables: { competitionId, roomId },
+    skip: !competitionId || !enabled,
+  });
+
+  const competitionQuery = useQuery<{ competition: NotifyCompCompetition | null }>(
+    RemoteCompetitionDocument,
+    {
+      variables: { competitionId },
+      skip: !competitionId || !enabled,
+    },
+  );
+  const { subscribeToMore } = activitiesQuery;
+
+  useEffect(() => {
+    if (!competitionId || !enabled || !subscribeToMore) {
+      return;
+    }
+
+    const unsubscribe = subscribeToMore<{ activity: NotifyCompActivity }>({
+      document: RemoteActivitiesSubscriptionDocument,
+      variables: { competitionIds: [competitionId] },
+      updateQuery: (prev, { subscriptionData }) => {
+        if (!subscriptionData.data?.activity) {
+          return prev;
+        }
+
+        const activity = subscriptionData.data.activity;
+
+        return {
+          ...prev,
+          activities: [
+            ...(prev.activities || []).filter(
+              (candidate) => candidate.activityId !== activity.activityId,
+            ),
+            activity,
+          ],
+        };
+      },
+    });
+
+    return () => unsubscribe();
+  }, [competitionId, enabled, subscribeToMore]);
+
+  const refetchQueries = useMemo(
+    () => [
+      {
+        query: RemoteActivitiesDocument,
+        variables: { competitionId, roomId },
+      },
+      {
+        query: RemoteCompetitionDocument,
+        variables: { competitionId },
+      },
+    ],
+    [competitionId, roomId],
+  );
+
+  const mutationOptions = {
+    refetchQueries,
+    onError: (error: Error) => {
+      setMutationError(error.message);
+    },
+  };
+
+  const [startActivity, startActivityStatus] = useMutation(
+    StartRemoteActivityDocument,
+    mutationOptions,
+  );
+  const [stopActivity, stopActivityStatus] = useMutation(
+    StopRemoteActivityDocument,
+    mutationOptions,
+  );
+  const [resetActivity, resetActivityStatus] = useMutation(
+    ResetRemoteActivityDocument,
+    mutationOptions,
+  );
+  const [startActivities, startActivitiesStatus] = useMutation(
+    StartRemoteActivitiesDocument,
+    mutationOptions,
+  );
+  const [stopActivities, stopActivitiesStatus] = useMutation(
+    StopRemoteActivitiesDocument,
+    mutationOptions,
+  );
+  const [resetActivities, resetActivitiesStatus] = useMutation(
+    ResetRemoteActivitiesDocument,
+    mutationOptions,
+  );
+  const [updateAutoAdvance, updateAutoAdvanceStatus] = useMutation(
+    UpdateRemoteAutoAdvanceDocument,
+    mutationOptions,
+  );
+  const [importCompetition, importCompetitionStatus] = useMutation(
+    ImportRemoteCompetitionDocument,
+    mutationOptions,
+  );
+
+  const runMutation = async (operation: () => Promise<unknown>) => {
+    setMutationError(null);
+    await operation();
+  };
+
+  return {
+    activities: activitiesQuery.data?.activities || [],
+    autoAdvance: competitionQuery.data?.competition?.autoAdvance,
+    competition: competitionQuery.data?.competition || null,
+    error:
+      mutationError || activitiesQuery.error?.message || competitionQuery.error?.message || null,
+    isLoading: activitiesQuery.loading || competitionQuery.loading,
+    isSaving:
+      importCompetitionStatus.loading ||
+      startActivityStatus.loading ||
+      stopActivityStatus.loading ||
+      resetActivityStatus.loading ||
+      startActivitiesStatus.loading ||
+      stopActivitiesStatus.loading ||
+      resetActivitiesStatus.loading ||
+      updateAutoAdvanceStatus.loading,
+    importCompetition: () =>
+      runMutation(() =>
+        importCompetition({
+          variables: { competitionId },
+        }),
+      ),
+    resetActivities: (activityIds: number[]) =>
+      runMutation(() =>
+        resetActivities({
+          variables: { competitionId, activityIds },
+        }),
+      ),
+    resetAllActivities: () =>
+      runMutation(() =>
+        resetActivities({
+          variables: { competitionId },
+        }),
+      ),
+    resetActivity: (activityId: number) =>
+      runMutation(() =>
+        resetActivity({
+          variables: { competitionId, activityId },
+        }),
+      ),
+    startActivities: (activityIds: number[]) =>
+      runMutation(() =>
+        startActivities({
+          variables: { competitionId, activityIds },
+        }),
+      ),
+    startActivity: (activityId: number) =>
+      runMutation(() =>
+        startActivity({
+          variables: { competitionId, activityId },
+        }),
+      ),
+    stopActivities: (activityIds: number[]) =>
+      runMutation(() =>
+        stopActivities({
+          variables: { competitionId, activityIds },
+        }),
+      ),
+    stopActivity: (activityId: number) =>
+      runMutation(() =>
+        stopActivity({
+          variables: { competitionId, activityId },
+        }),
+      ),
+    updateAutoAdvance: (autoAdvance: boolean) =>
+      runMutation(() =>
+        updateAutoAdvance({
+          variables: { competitionId, autoAdvance },
+        }),
+      ),
+  };
+}
diff --git a/src/hooks/useNotifyCompWebSocketStatus.ts b/src/hooks/useNotifyCompWebSocketStatus.ts
new file mode 100644
index 0000000..d434225
--- /dev/null
+++ b/src/hooks/useNotifyCompWebSocketStatus.ts
@@ -0,0 +1,12 @@
+import { useSyncExternalStore } from 'react';
+import {
+  getNotifyCompWebSocketStatus,
+  subscribeToNotifyCompWebSocketStatus,
+} from '@/lib/notifyCompWebSocketStatus';
+
+export const useNotifyCompWebSocketStatus = () =>
+  useSyncExternalStore(
+    subscribeToNotifyCompWebSocketStatus,
+    getNotifyCompWebSocketStatus,
+    getNotifyCompWebSocketStatus,
+  );
diff --git a/src/i18n/en/translation.yaml b/src/i18n/en/translation.yaml
index b47cf89..33b4f57 100644
--- a/src/i18n/en/translation.yaml
+++ b/src/i18n/en/translation.yaml
@@ -31,9 +31,20 @@ common:
     cumulativeTimelimit: 'Time Limit: <b>{{time}} Cumulative</b>'
     cumulativeTimelimitWithrounds: 'Time Limit: <b>{{time}} Total</b> with: '
     advancement:
-      ranking: 'Top <b>{{level}}</b> to next round'
-      percent: 'Top <b>{{level}}%</b> to next round'
+      ranking: 'Top {{level}} advance to {{what}}'
+      percent: 'Top {{level}}% advance to {{what}}'
+      linkedRanking: 'Top {{level}} in dual rounds {{rounds}} advance to {{what}}'
+      linkedPercent: 'Top {{level}}% in dual rounds {{rounds}} advance to {{what}}'
       attemptResult: Result better than <b>{level}</b> advances to next round. Minimum of 25% of competitors must be eliminated.
+      resultAchieved: '{{scope}} < {{result}} advance to {{what}}; minimum of 25% of competitors must be eliminated'
+      linkedResultAchieved: '{{scope}} < {{result}} in dual rounds {{rounds}} advance to {{what}}; minimum of 25% of competitors must be eliminated'
+      resultThresholdUnknown: an unknown result
+      nextRound: next round
+      final: final
+      unknown: unknown
+      scope:
+        single: Singles
+        average: Averages
     resultType:
       single: single
       average: Average
@@ -128,6 +139,7 @@ common:
   loading: 'Loading...'
   search: 'Search'
   view: 'View'
+  close: Close
   name: Name
   stage: Stage
   login: 'Login'
@@ -143,8 +155,12 @@ header:
     events: 'Events'
     schedule: 'Schedule'
     rankings: 'Rankings'
+    results: 'Results'
     scramblers: 'Scramblers'
     stream: 'Stream'
+    admin: 'Admin'
+    sumOfRanks: 'Sum of Rankings'
+    stats: 'Stats'
 home:
   subtitle: 'Learn all you need about your WCA competition assignments!'
   explanation: 'Note: This site is a convenience tool for organizers, delegates, and competitors. It uses scheduled data, so check with organizers for the latest details. Start and end times may change.'
@@ -180,10 +196,33 @@ competition:
   rankings:
     title: Rankings
     name: Name
+  results:
+    title: Results
+    seeResults: See Results
+    back: Back
+    roundNotFound: Round not found.
+    noResults: No results yet.
+    rank: '#'
+    competitor: Competitor
+    average: Avg
+    best: Best
+    attempts: Attempts
+    unknownCompetitor: 'Competitor #{{personId}}'
+    allResults: All results
+    viewLiveResults: View live results
+    liveResultsDelayNote: Data is pulled from WCA Live and may be delayed.
+  personalResults:
+    eventResults: Event results
+  round:
+    linkedWith: 'Dual round with {{rounds}}'
   personalSchedule:
+    schedule: Schedule
+    results: Results
+    records: Records
     registeredEvents: Registered Events
     viewPersonalRecords: View Personal Records
     viewResults: View Results
+    viewWcaLiveResults: View WCA Live Results
     noAssignments:
       line1: No Assignments
       line2: Check back later for updates!
diff --git a/src/i18n/fr/translation.yaml b/src/i18n/fr/translation.yaml
index f80680f..4ef61ae 100644
--- a/src/i18n/fr/translation.yaml
+++ b/src/i18n/fr/translation.yaml
@@ -118,6 +118,9 @@ header:
     rankings: 'Classements'
     scramblers: 'Mélangeurs'
     stream: 'Stream'
+    admin: 'Admin'
+    sumOfRanks: 'Somme des classements'
+    stats: 'Stats'
 home:
   subtitle: 'Apprenez tout ce que vous devez savoir sur les tâches qui vous ont été attribuées aux compétitions WCA !'
   explanation: 'Remarque : Ce site web est un outil pratique pour les organisateurs, délégués et compétiteurs. Les informations fournies sont basées sur le planning prévisionnel. Pensez à consulter régulièrement la page de la compétition pour obtenir les informations les plus récentes. Les horaires de début et de fin peuvent varier.'
diff --git a/src/layouts/CompetitionLayout/CompetitionLayout.tabs.tsx b/src/layouts/CompetitionLayout/CompetitionLayout.tabs.tsx
index 31ecf9f..7e66508 100644
--- a/src/layouts/CompetitionLayout/CompetitionLayout.tabs.tsx
+++ b/src/layouts/CompetitionLayout/CompetitionLayout.tabs.tsx
@@ -2,6 +2,7 @@ import { Competition } from '@wca/helpers';
 import { useMemo } from 'react';
 import { useTranslation } from 'react-i18next';
 import { streamActivities } from '@/lib/activities';
+import { isCompetitionDelegateOrOrganizer } from '@/lib/competitionAuthorization';
 import { isStaff } from '@/lib/person';
 import { useAuth } from '@/providers/AuthProvider';
 
@@ -10,20 +11,31 @@ interface CompetitionLayoutTabsProps {
   wcif?: Competition;
 }
 
+export interface CompetitionLayoutTab {
+  href: string;
+  text: string;
+  end?: boolean;
+  hiddenOnMobile?: boolean;
+}
+
+interface CompetitionLayoutTabs {
+  tabs: CompetitionLayoutTab[];
+  adminTabs: CompetitionLayoutTab[];
+}
+
 export const useCompetitionLayoutTabs = ({ competitionId, wcif }: CompetitionLayoutTabsProps) => {
   const { t } = useTranslation();
   const { user } = useAuth();
+  const userId = user?.id;
 
-  return useMemo(() => {
+  return useMemo<CompetitionLayoutTabs>(() => {
     const hasStream = wcif && streamActivities(wcif).length > 0;
-    const person = wcif?.persons.find((p) => p.wcaUserId === user?.id);
+    const person = wcif?.persons.find((p) => p.wcaUserId === userId);
     const isPersonStaff = person && isStaff(person);
+    const canManageRemote = isCompetitionDelegateOrOrganizer(wcif, userId ? { id: userId } : null);
 
-    const _tabs: {
-      href: string;
-      text: string;
-      hiddenOnMobile?: boolean;
-    }[] = [];
+    const _tabs: CompetitionLayoutTab[] = [];
+    const _adminTabs: CompetitionLayoutTab[] = [];
 
     _tabs.push({
       href: `/competitions/${competitionId}`,
@@ -44,15 +56,29 @@ export const useCompetitionLayoutTabs = ({ competitionId, wcif }: CompetitionLay
         href: `/competitions/${competitionId}/psych-sheet`,
         text: t('header.tabs.rankings'),
       },
+      {
+        href: `/competitions/${competitionId}/results`,
+        text: t('header.tabs.results'),
+        end: false,
+      },
     );
 
     if (isPersonStaff) {
-      _tabs.push({
-        href: `/competitions/${competitionId}/scramblers`,
+      _adminTabs.push({
+        href: `/competitions/${competitionId}/admin/scramblers`,
         text: t('header.tabs.scramblers'),
       });
     }
 
+    if (canManageRemote) {
+      _adminTabs.push({
+        href: `/competitions/${competitionId}/admin/remote`,
+        text: t('header.tabs.remote', {
+          defaultValue: 'Remote',
+        }),
+      });
+    }
+
     if (hasStream) {
       _tabs.push({
         href: `/competitions/${competitionId}/stream`,
@@ -60,6 +86,34 @@ export const useCompetitionLayoutTabs = ({ competitionId, wcif }: CompetitionLay
       });
     }
 
-    return _tabs;
-  }, [wcif, competitionId, user?.id, t]);
+    if (isPersonStaff || canManageRemote) {
+      _adminTabs.push(
+        {
+          href: `/competitions/${competitionId}/admin/sum-of-ranks`,
+          text: t('header.tabs.sumOfRanks', {
+            defaultValue: 'Sum of Rankings',
+          }),
+        },
+        {
+          href: `/competitions/${competitionId}/admin/stats`,
+          text: t('header.tabs.stats', {
+            defaultValue: 'Stats',
+          }),
+        },
+      );
+    }
+
+    if (_adminTabs.length > 0) {
+      _tabs.push({
+        href: `/competitions/${competitionId}/admin`,
+        text: t('header.tabs.admin'),
+        end: false,
+      });
+    }
+
+    return {
+      tabs: _tabs,
+      adminTabs: _adminTabs,
+    };
+  }, [wcif, competitionId, userId, t]);
 };
diff --git a/src/layouts/CompetitionLayout/CompetitionLayout.tsx b/src/layouts/CompetitionLayout/CompetitionLayout.tsx
index 115040f..a8f40b1 100644
--- a/src/layouts/CompetitionLayout/CompetitionLayout.tsx
+++ b/src/layouts/CompetitionLayout/CompetitionLayout.tsx
@@ -3,7 +3,7 @@ import { useEffect, useRef } from 'react';
 import { ErrorBoundary } from 'react-error-boundary';
 import { Outlet, useLocation, useParams } from 'react-router-dom';
 import { BarLoader } from 'react-spinners';
-import { ErrorFallback, LastFetchedAt, NoteBox } from '@/components';
+import { ErrorFallback, LastFetchedAt, NoteBox, NotifyCompRemoteBar } from '@/components';
 import { Container } from '@/components/Container';
 import { StyledNavLink } from '@/components/StyledNavLink/StyledNavLink';
 import { useWcif } from '@/hooks/queries/useWcif';
@@ -20,7 +20,7 @@ export function CompetitionLayout() {
 
   const { data: wcif, dataUpdatedAt, isFetching } = useWcif(competitionId!);
 
-  const tabs = useCompetitionLayoutTabs({
+  const { tabs } = useCompetitionLayoutTabs({
     competitionId: competitionId!,
     wcif: wcif,
   });
@@ -39,6 +39,7 @@ export function CompetitionLayout() {
               className={classNames({
                 'hidden md:block': i.hiddenOnMobile,
               })}
+              end={i.end}
               to={i.href}
               text={i.text}
             />
@@ -65,7 +66,7 @@ export function CompetitionLayout() {
         )}
         {isFetching ? <BarLoader width="100%" /> : <div style={{ height: '4px' }} />}
         <div
-          className="flex flex-col w-full items-center overflow-y-auto [scrollbar-gutter:stable;]"
+          className="flex flex-1 flex-col w-full items-center overflow-y-auto [scrollbar-gutter:stable;]"
           ref={ref}>
           <ErrorBoundary FallbackComponent={ErrorFallback}>
             <Outlet />
@@ -80,6 +81,7 @@ export function CompetitionLayout() {
             </Container>
           )}
         </div>
+        {competitionId && <NotifyCompRemoteBar competitionId={competitionId} />}
       </div>
     </WCIFProvider>
   );
diff --git a/src/layouts/RootLayout/Header.tsx b/src/layouts/RootLayout/Header.tsx
index 260a2ee..b0cf4c2 100644
--- a/src/layouts/RootLayout/Header.tsx
+++ b/src/layouts/RootLayout/Header.tsx
@@ -4,6 +4,8 @@ import { useTranslation } from 'react-i18next';
 import { Link, useParams } from 'react-router-dom';
 import { Popover } from 'react-tiny-popover';
 import { useCompetition } from '@/hooks/queries/useCompetition';
+import { UserCompsResponse } from '@/lib/api';
+import { FEATURE_FLAGS } from '@/lib/featureFlags';
 import { useAuth } from '@/providers/AuthProvider';
 import { useWCIF } from '@/providers/WCIFProvider';
 
@@ -30,13 +32,15 @@ export default function Header() {
     const upcomingCompetitions = queryClient.getQueryData<{ pages: CondensedApiCompetiton[][] }>([
       'upcomingCompetitions',
     ]);
-    const myCompetitions = queryClient.getQueryData<{ pages: CondensedApiCompetiton[][] }>([
-      'userCompetitions',
-    ]);
+    const myCompetitions = queryClient
+      .getQueriesData<UserCompsResponse>({ queryKey: ['userCompetitions'] })
+      .map(([, data]) => data)
+      .find(Boolean);
 
     const allCompetitions = [
       ...(upcomingCompetitions?.pages?.flat() || []),
-      ...(myCompetitions?.pages?.flat() || []),
+      ...(myCompetitions?.upcoming_competitions || []),
+      ...(myCompetitions?.ongoing_competitions || []),
     ];
 
     const competition = allCompetitions?.find((c) => c.id === competitionId);
@@ -73,6 +77,11 @@ export default function Header() {
             <div
               className="z-50 mt-2 border-2 shadow-xl bg-panel border-tertiary-weak"
               onClick={() => setIsPopoverOpen(!isPopoverOpen)}>
+              {FEATURE_FLAGS.personalUserPage && (
+                <Link to="/me" className="block w-32 px-3 py-2 link-inline hover-bg-tertiary">
+                  My profile
+                </Link>
+              )}
               <Link to="/settings" className="block w-32 px-3 py-2 link-inline hover-bg-tertiary">
                 Settings
               </Link>
diff --git a/src/lib/api.ts b/src/lib/api.ts
index 1867f06..1ec9fc1 100644
--- a/src/lib/api.ts
+++ b/src/lib/api.ts
@@ -55,6 +55,49 @@ export const fetchUserWithCompetitions = async (userId: string) =>
 export const fetchWcif = async (competitionId: string) =>
   wcaApiFetch<Competition>(`/competitions/${competitionId}/wcif/public`);
 
+export interface WcaCompetitionResult {
+  id: number;
+  pos: number;
+  best: number;
+  average: number;
+  name: string;
+  country_iso2: string;
+  competition_id: string;
+  event_id: string;
+  round_type_id: string;
+  format_id: string;
+  wca_id: string | null;
+  attempts: number[];
+  best_index?: number | null;
+  worst_index?: number | null;
+  regional_single_record?: string | null;
+  regional_average_record?: string | null;
+}
+
+export type WcaPersonCompetition = Pick<
+  ApiCompetition,
+  | 'id'
+  | 'name'
+  | 'short_name'
+  | 'city'
+  | 'country_iso2'
+  | 'start_date'
+  | 'end_date'
+  | 'announced_at'
+  | 'cancelled_at'
+  | 'latitude_degrees'
+  | 'longitude_degrees'
+  | 'venue_address'
+  | 'venue_details'
+  | 'website'
+>;
+
+export const fetchCompetitionResults = async (competitionId: string) =>
+  wcaApiFetch<WcaCompetitionResult[]>(`/competitions/${competitionId}/results`);
+
+export const fetchPersonCompetitions = async (wcaId: string) =>
+  wcaApiFetch<WcaPersonCompetition[]>(`/persons/${wcaId}/competitions`);
+
 export const fetchCompetition = async (competitionId: string) =>
   await wcaApiFetch<ApiCompetition>(`/competitions/${competitionId}`);
 
diff --git a/src/lib/competitionAuthorization.test.ts b/src/lib/competitionAuthorization.test.ts
new file mode 100644
index 0000000..e4837ba
--- /dev/null
+++ b/src/lib/competitionAuthorization.test.ts
@@ -0,0 +1,31 @@
+import { isCompetitionDelegateOrOrganizer } from './competitionAuthorization';
+
+const wcif = {
+  persons: [
+    {
+      roles: ['organizer'],
+      wcaUserId: 1,
+    },
+    {
+      roles: ['trainee-delegate'],
+      wcaUserId: 2,
+    },
+    {
+      roles: ['staff-dataentry'],
+      wcaUserId: 3,
+    },
+  ],
+};
+
+describe('isCompetitionDelegateOrOrganizer', () => {
+  it('allows listed organizers and delegates', () => {
+    expect(isCompetitionDelegateOrOrganizer(wcif as never, { id: 1 })).toBe(true);
+    expect(isCompetitionDelegateOrOrganizer(wcif as never, { id: 2 })).toBe(true);
+  });
+
+  it('rejects non-manager staff and missing users', () => {
+    expect(isCompetitionDelegateOrOrganizer(wcif as never, { id: 3 })).toBe(false);
+    expect(isCompetitionDelegateOrOrganizer(wcif as never, { id: 4 })).toBe(false);
+    expect(isCompetitionDelegateOrOrganizer(wcif as never, null)).toBe(false);
+  });
+});
diff --git a/src/lib/competitionAuthorization.ts b/src/lib/competitionAuthorization.ts
new file mode 100644
index 0000000..30e0a36
--- /dev/null
+++ b/src/lib/competitionAuthorization.ts
@@ -0,0 +1,18 @@
+import { Competition } from '@wca/helpers';
+import { isDelegate, isOrganizer } from './person';
+
+interface CompetitionManager {
+  id?: number;
+}
+
+export const isCompetitionDelegateOrOrganizer = (
+  wcif: Competition | null | undefined,
+  user: CompetitionManager | null | undefined,
+) => {
+  if (!wcif || !user?.id) {
+    return false;
+  }
+
+  const person = wcif.persons.find((candidate) => candidate.wcaUserId === user.id);
+  return Boolean(person && (isDelegate(person) || isOrganizer(person)));
+};
diff --git a/src/lib/competitionDates.test.ts b/src/lib/competitionDates.test.ts
new file mode 100644
index 0000000..f98859d
--- /dev/null
+++ b/src/lib/competitionDates.test.ts
@@ -0,0 +1,16 @@
+import { isCompetitionDayOrAfter } from './competitionDates';
+
+const wcif = {
+  schedule: {
+    numberOfDays: 2,
+    startDate: '2026-06-01',
+  },
+};
+
+describe('competitionDates', () => {
+  it('detects dates on or after the competition start date', () => {
+    expect(isCompetitionDayOrAfter(wcif as never, new Date(2026, 4, 31))).toBe(false);
+    expect(isCompetitionDayOrAfter(wcif as never, new Date(2026, 5, 1))).toBe(true);
+    expect(isCompetitionDayOrAfter(wcif as never, new Date(2026, 5, 3))).toBe(true);
+  });
+});
diff --git a/src/lib/competitionDates.ts b/src/lib/competitionDates.ts
new file mode 100644
index 0000000..629dc41
--- /dev/null
+++ b/src/lib/competitionDates.ts
@@ -0,0 +1,29 @@
+import { Competition } from '@wca/helpers';
+
+const getDateKey = (date: Date) =>
+  `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(
+    date.getDate(),
+  ).padStart(2, '0')}`;
+
+const getLocalDateFromKey = (dateKey: string) => {
+  const [year, month, day] = dateKey.split('-').map(Number);
+  return new Date(year, month - 1, day);
+};
+
+export const isCompetitionDay = (wcif: Competition, date = new Date()) => {
+  const currentDateKey = getDateKey(date);
+  const startDate = getLocalDateFromKey(wcif.schedule.startDate);
+
+  return Array.from({ length: wcif.schedule.numberOfDays }, (_, dayOffset) => {
+    const competitionDate = new Date(startDate);
+    competitionDate.setDate(startDate.getDate() + dayOffset);
+    return getDateKey(competitionDate);
+  }).includes(currentDateKey);
+};
+
+export const isCompetitionDayOrAfter = (wcif: Competition, date = new Date()) => {
+  const currentDate = getLocalDateFromKey(getDateKey(date));
+  const startDate = getLocalDateFromKey(wcif.schedule.startDate);
+
+  return currentDate >= startDate;
+};
diff --git a/src/lib/featureFlags.ts b/src/lib/featureFlags.ts
new file mode 100644
index 0000000..04ea327
--- /dev/null
+++ b/src/lib/featureFlags.ts
@@ -0,0 +1,8 @@
+const enabledValues = new Set(['1', 'true', 'yes', 'on']);
+
+const isEnabled = (value: string | undefined) =>
+  value ? enabledValues.has(value.toLowerCase()) : false;
+
+export const FEATURE_FLAGS = {
+  personalUserPage: isEnabled(import.meta.env.VITE_FEATURE_PERSONAL_USER_PAGE),
+};
diff --git a/src/lib/notifications/assignmentNotifications.ts b/src/lib/notifications/assignmentNotifications.ts
new file mode 100644
index 0000000..e97cb13
--- /dev/null
+++ b/src/lib/notifications/assignmentNotifications.ts
@@ -0,0 +1,218 @@
+import { deleteLocalStorage, getLocalStorage, setLocalStorage } from '@/lib/localStorage';
+import { getStoredWcaAccessToken } from '@/lib/wcaAccessToken';
+
+const NOTIFY_COMP_ORIGIN =
+  import.meta.env.VITE_NOTIFY_COMP_ORIGIN ?? 'https://api.notifycomp.com/api';
+const NOTIFY_COMP_TOKEN_URL = '/.netlify/functions/notify-comp-token';
+const ENABLED_STORAGE_KEY = 'assignmentNotifications.enabled';
+const SERVICE_WORKER_TIMEOUT_MS = 10000;
+
+interface PushSubscriptionJson {
+  endpoint?: string;
+  keys?: {
+    p256dh?: string;
+    auth?: string;
+  };
+}
+
+export interface AssignmentNotificationWatch {
+  competitionId: string;
+  wcaUserId: number;
+}
+
+export type AssignmentNotificationStatus = NotificationPermission | 'reauthorize' | 'unsupported';
+
+const notifyCompUrl = (path: string) => `${NOTIFY_COMP_ORIGIN}${path}`;
+
+export const isAssignmentNotificationsEnabled = () =>
+  getLocalStorage(ENABLED_STORAGE_KEY) === 'true';
+
+const toUint8Array = (base64: string) => {
+  const padding = '='.repeat((4 - (base64.length % 4)) % 4);
+  const normalized = `${base64}${padding}`.replace(/-/g, '+').replace(/_/g, '/');
+  const raw = window.atob(normalized);
+  const output = new Uint8Array(raw.length);
+
+  for (let index = 0; index < raw.length; index += 1) {
+    output[index] = raw.charCodeAt(index);
+  }
+
+  return output;
+};
+
+export const getAssignmentNotificationStatus = (): AssignmentNotificationStatus => {
+  if (
+    !('Notification' in window) ||
+    !('serviceWorker' in navigator) ||
+    !('PushManager' in window)
+  ) {
+    return 'unsupported';
+  }
+
+  if (!getStoredWcaAccessToken()) {
+    return 'reauthorize';
+  }
+
+  return Notification.permission;
+};
+
+export const requestAssignmentNotificationPermission = async () => {
+  if (!('Notification' in window)) {
+    return 'unsupported' as const;
+  }
+
+  if (Notification.permission === 'granted') {
+    return 'granted' as const;
+  }
+
+  return await Notification.requestPermission();
+};
+
+const readErrorMessage = async (response: Response) => {
+  const text = await response.text();
+
+  try {
+    const payload = JSON.parse(text) as { message?: string };
+    return payload.message || text;
+  } catch {
+    return text;
+  }
+};
+
+const fetchNotifyCompToken = async () => {
+  const accessToken = getStoredWcaAccessToken();
+  if (!accessToken) {
+    throw new Error('Refresh your WCA authorization to enable assignment notifications.');
+  }
+
+  const response = await fetch(NOTIFY_COMP_TOKEN_URL, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ accessToken }),
+  });
+
+  if (!response.ok) {
+    throw new Error(await readErrorMessage(response));
+  }
+
+  const payload = (await response.json()) as { token?: string };
+  if (!payload.token) {
+    throw new Error('Notification token response was missing a token.');
+  }
+
+  return payload.token;
+};
+
+const fetchVapidPublicKey = async () => {
+  const response = await fetch(notifyCompUrl('/v0/external/push/vapid-public-key'));
+
+  if (!response.ok) {
+    throw new Error(await readErrorMessage(response));
+  }
+
+  const payload = (await response.json()) as { publicKey?: string };
+  if (!payload.publicKey) {
+    throw new Error('NotifyComp did not return a VAPID public key.');
+  }
+
+  return payload.publicKey;
+};
+
+const withTimeout = async <T>(promise: Promise<T>, message: string) =>
+  await Promise.race([
+    promise,
+    new Promise<never>((_, reject) => {
+      window.setTimeout(() => reject(new Error(message)), SERVICE_WORKER_TIMEOUT_MS);
+    }),
+  ]);
+
+const getServiceWorkerRegistration = async () => {
+  if (import.meta.env.DEV) {
+    return await navigator.serviceWorker.register('/notification-sw.js');
+  }
+
+  return await withTimeout(
+    navigator.serviceWorker.ready,
+    'Notification service worker was not ready. Refresh the page and try again.',
+  );
+};
+
+const getPushSubscription = async () => {
+  const registration = await getServiceWorkerRegistration();
+  const existing = await registration.pushManager.getSubscription();
+
+  if (existing) {
+    return existing;
+  }
+
+  return await registration.pushManager.subscribe({
+    userVisibleOnly: true,
+    applicationServerKey: toUint8Array(await fetchVapidPublicKey()),
+  });
+};
+
+export const enableAssignmentNotifications = async (watches: AssignmentNotificationWatch[]) => {
+  const permission = await requestAssignmentNotificationPermission();
+  if (permission !== 'granted') {
+    return permission;
+  }
+
+  const token = await fetchNotifyCompToken();
+  const subscription = await getPushSubscription();
+  const payload = subscription.toJSON() as PushSubscriptionJson;
+
+  if (!payload.endpoint || !payload.keys?.p256dh || !payload.keys.auth) {
+    throw new Error('Browser push subscription is missing required keys.');
+  }
+
+  const response = await fetch(notifyCompUrl('/v0/external/push/subscriptions'), {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      endpoint: payload.endpoint,
+      p256dh: payload.keys.p256dh,
+      auth: payload.keys.auth,
+      watches,
+    }),
+  });
+
+  if (!response.ok) {
+    deleteLocalStorage(ENABLED_STORAGE_KEY);
+    throw new Error(await readErrorMessage(response));
+  }
+
+  setLocalStorage(ENABLED_STORAGE_KEY, 'true');
+  return permission;
+};
+
+export const disableAssignmentNotifications = async () => {
+  const registration = await getServiceWorkerRegistration();
+  const subscription = await registration.pushManager.getSubscription();
+
+  if (!subscription) {
+    deleteLocalStorage(ENABLED_STORAGE_KEY);
+    return;
+  }
+
+  const token = await fetchNotifyCompToken();
+  const payload = subscription.toJSON() as PushSubscriptionJson;
+
+  if (payload.endpoint) {
+    await fetch(notifyCompUrl('/v0/external/push/subscriptions'), {
+      method: 'DELETE',
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ endpoint: payload.endpoint }),
+    });
+  }
+
+  await subscription.unsubscribe();
+  deleteLocalStorage(ENABLED_STORAGE_KEY);
+};
diff --git a/src/lib/notifyCompRemoteActivities.test.ts b/src/lib/notifyCompRemoteActivities.test.ts
new file mode 100644
index 0000000..7fd78ea
--- /dev/null
+++ b/src/lib/notifyCompRemoteActivities.test.ts
@@ -0,0 +1,148 @@
+import {
+  getRemoteActivityGroups,
+  getRemoteActivityState,
+  getRemoteNextGroup,
+  getRemotePreviousGroup,
+  RemoteScheduledActivity,
+} from './notifyCompRemoteActivities';
+
+const room = {
+  id: 1,
+  name: 'Stage 1',
+} as RemoteScheduledActivity['room'];
+
+const activity = (overrides: Partial<RemoteScheduledActivity>): RemoteScheduledActivity =>
+  ({
+    activityCode: '333-r1-g1',
+    childActivities: [],
+    endTime: '2026-06-01T10:10:00Z',
+    extensions: [],
+    id: 101,
+    name: '3x3x3 Cube Round 1 Group 1',
+    room,
+    startTime: '2026-06-01T10:00:00Z',
+    ...overrides,
+  }) as RemoteScheduledActivity;
+
+describe('notifyCompRemoteActivities', () => {
+  it('marks an activity as next when NotifyComp has no live record', () => {
+    expect(getRemoteActivityState(activity({}), []).status).toBe('next');
+  });
+
+  it('marks an activity as current when it has a start without an end', () => {
+    expect(
+      getRemoteActivityState(activity({ id: 102 }), [
+        {
+          activityId: 102,
+          startTime: '2026-06-01T10:01:00Z',
+          endTime: null,
+        },
+      ]).status,
+    ).toBe('current');
+  });
+
+  it('marks an activity as done when it has an end time', () => {
+    expect(
+      getRemoteActivityState(activity({ id: 103 }), [
+        {
+          activityId: 103,
+          startTime: '2026-06-01T10:01:00Z',
+          endTime: '2026-06-01T10:09:00Z',
+        },
+      ]).status,
+    ).toBe('done');
+  });
+
+  it('groups matching start times and activity codes across rooms', () => {
+    const groups = getRemoteActivityGroups(
+      [
+        activity({ id: 201, activityCode: '333-r1-g1', room }),
+        activity({
+          id: 202,
+          activityCode: '333-r1-g1',
+          room: {
+            ...room,
+            id: 2,
+            name: 'Stage 2',
+          },
+        }),
+      ],
+      [],
+    );
+
+    expect(groups).toHaveLength(1);
+    expect(groups[0].scheduledActivities.map((candidate) => candidate.id)).toEqual([201, 202]);
+  });
+
+  it('keeps matching activity codes separate when their start times differ', () => {
+    const groups = getRemoteActivityGroups(
+      [
+        activity({ id: 211, activityCode: '333-r1-g1' }),
+        activity({
+          id: 212,
+          activityCode: '333-r1-g1',
+          startTime: '2026-06-01T10:20:00Z',
+        }),
+      ],
+      [],
+    );
+
+    expect(groups).toHaveLength(2);
+  });
+
+  it('keeps different group activity codes separate at the same start time', () => {
+    const groups = getRemoteActivityGroups(
+      [
+        activity({ id: 221, activityCode: '333-r1-g1' }),
+        activity({ id: 222, activityCode: '333-r1-g2' }),
+      ],
+      [],
+    );
+
+    expect(groups).toHaveLength(2);
+  });
+
+  it('finds the next group after the current activity group', () => {
+    const groups = getRemoteActivityGroups(
+      [
+        activity({ id: 301, activityCode: '333-r1-g1' }),
+        activity({
+          id: 302,
+          activityCode: '222-r1-g1',
+          name: '2x2x2 Cube Round 1 Group 1',
+          startTime: '2026-06-01T10:20:00Z',
+        }),
+      ],
+      [{ activityId: 301, startTime: '2026-06-01T10:01:00Z', endTime: null }],
+    );
+
+    expect(getRemoteNextGroup(groups)?.scheduledActivities[0].id).toBe(302);
+  });
+
+  it('finds the previous group before the current activity group', () => {
+    const groups = getRemoteActivityGroups(
+      [
+        activity({
+          id: 401,
+          activityCode: '222-r1-g1',
+          name: '2x2x2 Cube Round 1 Group 1',
+        }),
+        activity({
+          id: 402,
+          activityCode: '333-r1-g1',
+          startTime: '2026-06-01T10:20:00Z',
+        }),
+      ],
+      [
+        {
+          activityId: 401,
+          startTime: '2026-06-01T10:01:00Z',
+          endTime: '2026-06-01T10:09:00Z',
+        },
+        { activityId: 402, startTime: '2026-06-01T10:21:00Z', endTime: null },
+      ],
+    );
+
+    expect(getRemotePreviousGroup(groups)?.scheduledActivities[0].id).toBe(401);
+  });
+});
diff --git a/src/lib/notifyCompRemoteActivities.ts b/src/lib/notifyCompRemoteActivities.ts
new file mode 100644
index 0000000..81059ae
--- /dev/null
+++ b/src/lib/notifyCompRemoteActivities.ts
@@ -0,0 +1,177 @@
+import { Activity, Competition, Room } from '@wca/helpers';
+import { getRooms } from './activities';
+import { NotifyCompActivity } from './notifyCompRemoteGraphql';
+
+export interface RemoteScheduledActivity extends Activity {
+  parent?: Activity;
+  room: Room;
+}
+
+export interface RemoteActivityState {
+  liveActivity?: NotifyCompActivity;
+  scheduledActivity: RemoteScheduledActivity;
+  status: 'next' | 'current' | 'done';
+}
+
+export interface RemoteActivityGroup {
+  id: string;
+  name: string;
+  scheduledActivities: RemoteScheduledActivity[];
+  liveActivities: NotifyCompActivity[];
+  status: 'next' | 'current' | 'done' | 'mixed';
+}
+
+export const getRemoteScheduledActivities = (wcif: Competition, roomId?: number) =>
+  getRooms(wcif)
+    .filter((room) => roomId === undefined || room.id === roomId)
+    .flatMap((room) =>
+      room.activities.flatMap((activity) => {
+        const childActivities = activity.childActivities.map((child) => ({
+          ...child,
+          parent: activity,
+        }));
+        const activities = childActivities.length ? childActivities : [activity];
+
+        return activities.map((scheduledActivity) => ({
+          ...scheduledActivity,
+          room,
+        }));
+      }),
+    )
+    .sort((a, b) => a.startTime.localeCompare(b.startTime));
+
+export const getRemoteActivityState = (
+  scheduledActivity: RemoteScheduledActivity,
+  liveActivities: NotifyCompActivity[],
+): RemoteActivityState => {
+  const liveActivity = liveActivities.find(
+    (activity) => activity.activityId === scheduledActivity.id,
+  );
+
+  if (liveActivity?.startTime && !liveActivity.endTime) {
+    return {
+      liveActivity,
+      scheduledActivity,
+      status: 'current',
+    };
+  }
+
+  if (liveActivity?.endTime) {
+    return {
+      liveActivity,
+      scheduledActivity,
+      status: 'done',
+    };
+  }
+
+  return {
+    liveActivity,
+    scheduledActivity,
+    status: 'next',
+  };
+};
+
+export const getRemoteActivityStates = (
+  scheduledActivities: RemoteScheduledActivity[],
+  liveActivities: NotifyCompActivity[],
+) => scheduledActivities.map((activity) => getRemoteActivityState(activity, liveActivities));
+
+const getGroupActivityCode = (activity: Activity) => {
+  const code = activity.activityCode || activity.name;
+  return code;
+};
+
+const getGroupKey = (activity: Activity) =>
+  `${activity.startTime}-${getGroupActivityCode(activity)}`;
+
+export const getRemoteActivityGroups = (
+  scheduledActivities: RemoteScheduledActivity[],
+  liveActivities: NotifyCompActivity[],
+): RemoteActivityGroup[] => {
+  const groups = scheduledActivities.reduce<Record<string, RemoteScheduledActivity[]>>(
+    (acc, activity) => {
+      const key = getGroupKey(activity);
+      acc[key] = [...(acc[key] || []), activity];
+      return acc;
+    },
+    {},
+  );
+
+  return Object.entries(groups).map(([id, activities]) => {
+    const activityIds = new Set(activities.map((activity) => activity.id));
+    const groupLiveActivities = liveActivities.filter((activity) =>
+      activityIds.has(activity.activityId),
+    );
+    const states = getRemoteActivityStates(activities, liveActivities);
+    const statuses = new Set(states.map((state) => state.status));
+
+    return {
+      id,
+      name: activities[0]?.name || activities[0]?.parent?.name || id,
+      scheduledActivities: activities,
+      liveActivities: groupLiveActivities,
+      status: statuses.size === 1 ? states[0].status : 'mixed',
+    };
+  });
+};
+
+export const splitRemoteActivityGroups = (groups: RemoteActivityGroup[]) => ({
+  current: groups.filter((group) => group.status === 'current' || group.status === 'mixed'),
+  next: groups.filter((group) => group.status === 'next'),
+  done: groups.filter((group) => group.status === 'done'),
+});
+
+export const getRemoteActiveGroups = (groups: RemoteActivityGroup[]) =>
+  groups.filter((group) => group.status === 'current' || group.status === 'mixed');
+
+export const getRemoteNavigationFocusIndex = (groups: RemoteActivityGroup[]) => {
+  const activeIndex = groups.findIndex(
+    (group) => group.status === 'current' || group.status === 'mixed',
+  );
+
+  if (activeIndex >= 0) {
+    return activeIndex;
+  }
+
+  const nextIndex = groups.findIndex((group) => group.status === 'next');
+
+  return nextIndex >= 0 ? nextIndex : groups.length - 1;
+};
+
+export const getRemotePreviousGroup = (groups: RemoteActivityGroup[]) => {
+  const focusIndex = getRemoteNavigationFocusIndex(groups);
+
+  if (focusIndex <= 0) {
+    return undefined;
+  }
+
+  return [...groups.slice(0, focusIndex)]
+    .reverse()
+    .find((group) => group.status !== 'current' && group.status !== 'mixed');
+};
+
+export const getRemoteNextGroup = (groups: RemoteActivityGroup[]) => {
+  const activeIndex = groups.findIndex(
+    (group) => group.status === 'current' || group.status === 'mixed',
+  );
+
+  if (activeIndex < 0) {
+    return groups.find((group) => group.status === 'next');
+  }
+
+  const focusIndex = getRemoteNavigationFocusIndex(groups);
+
+  if (focusIndex < 0) {
+    return groups.find((group) => group.status === 'next');
+  }
+
+  return groups
+    .slice(focusIndex + 1)
+    .find((group) => group.status !== 'done' && group.status !== 'current');
+};
+
+export const splitRemoteActivityStates = (states: RemoteActivityState[]) => ({
+  current: states.filter((state) => state.status === 'current'),
+  next: states.filter((state) => state.status === 'next'),
+  done: states.filter((state) => state.status === 'done'),
+});
diff --git a/src/lib/notifyCompRemoteAuth.test.ts b/src/lib/notifyCompRemoteAuth.test.ts
new file mode 100644
index 0000000..5bc153f
--- /dev/null
+++ b/src/lib/notifyCompRemoteAuth.test.ts
@@ -0,0 +1,51 @@
+import {
+  clearNotifyCompRemoteToken,
+  getNotifyCompRemoteClaims,
+  hasNotifyCompRemoteToken,
+  setNotifyCompRemoteToken,
+} from './notifyCompRemoteAuth';
+
+jest.mock('./localStorage', () => ({
+  deleteLocalStorage: (key: string) => localStorage.removeItem(key),
+  getLocalStorage: (key: string) => localStorage.getItem(key),
+  setLocalStorage: (key: string, value: string) => localStorage.setItem(key, value),
+}));
+
+const base64Url = (value: unknown) =>
+  Buffer.from(JSON.stringify(value)).toString('base64url').replace(/=/g, '');
+
+const jwtWithClaims = (claims: Record<string, unknown>) =>
+  `${base64Url({ alg: 'HS256', typ: 'JWT' })}.${base64Url(claims)}.signature`;
+
+describe('notifyCompRemoteAuth', () => {
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  afterEach(() => {
+    clearNotifyCompRemoteToken();
+  });
+
+  it('reads an unpadded remote JWT payload as an authenticated session', () => {
+    setNotifyCompRemoteToken(
+      jwtWithClaims({
+        competitionIds: ['KentSpring2026'],
+        exp: Math.floor(Date.now() / 1000) + 60,
+        name: 'Test Delegate',
+      }),
+    );
+
+    expect(getNotifyCompRemoteClaims()?.name).toBe('Test Delegate');
+    expect(hasNotifyCompRemoteToken()).toBe(true);
+  });
+
+  it('clears expired remote JWT payloads', () => {
+    setNotifyCompRemoteToken(
+      jwtWithClaims({
+        exp: Math.floor(Date.now() / 1000) - 60,
+      }),
+    );
+
+    expect(hasNotifyCompRemoteToken()).toBe(false);
+  });
+});
diff --git a/src/lib/notifyCompRemoteAuth.ts b/src/lib/notifyCompRemoteAuth.ts
new file mode 100644
index 0000000..d8d4f1a
--- /dev/null
+++ b/src/lib/notifyCompRemoteAuth.ts
@@ -0,0 +1,59 @@
+import { deleteLocalStorage, getLocalStorage, setLocalStorage } from './localStorage';
+
+const REMOTE_JWT_KEY = 'notifyComp.jwt';
+
+interface JwtClaims {
+  competitionIds?: string[];
+  competition_ids?: string[];
+  exp?: number;
+  id?: number;
+  name?: string;
+  scope?: string | string[];
+  scopes?: string[];
+  wcaUserId?: number;
+}
+
+const decodeJwtPayload = (token: string): JwtClaims | null => {
+  try {
+    const payload = token.split('.')[1];
+    if (!payload) {
+      return null;
+    }
+
+    const base64 = payload.replace(/-/g, '+').replace(/_/g, '/');
+    const normalized = base64.padEnd(base64.length + ((4 - (base64.length % 4)) % 4), '=');
+    return JSON.parse(window.atob(normalized)) as JwtClaims;
+  } catch {
+    return null;
+  }
+};
+
+export const getNotifyCompRemoteToken = () => {
+  const token = getLocalStorage(REMOTE_JWT_KEY);
+  if (!token) {
+    return null;
+  }
+
+  const claims = decodeJwtPayload(token);
+  if (claims?.exp && claims.exp * 1000 <= Date.now()) {
+    deleteLocalStorage(REMOTE_JWT_KEY);
+    return null;
+  }
+
+  return token;
+};
+
+export const getNotifyCompRemoteClaims = () => {
+  const token = getNotifyCompRemoteToken();
+  return token ? decodeJwtPayload(token) : null;
+};
+
+export const hasNotifyCompRemoteToken = () => Boolean(getNotifyCompRemoteClaims());
+
+export const setNotifyCompRemoteToken = (token: string) => {
+  setLocalStorage(REMOTE_JWT_KEY, token);
+};
+
+export const clearNotifyCompRemoteToken = () => {
+  deleteLocalStorage(REMOTE_JWT_KEY);
+};
diff --git a/src/lib/notifyCompRemoteGraphql.ts b/src/lib/notifyCompRemoteGraphql.ts
new file mode 100644
index 0000000..ddaf9ce
--- /dev/null
+++ b/src/lib/notifyCompRemoteGraphql.ts
@@ -0,0 +1,135 @@
+import { gql } from '@apollo/client';
+
+export interface NotifyCompActivity {
+  activityId: number;
+  startTime: string | null;
+  endTime: string | null;
+  scheduledStartTime?: string | null;
+  scheduledEndTime?: string | null;
+}
+
+export interface NotifyCompCompetition {
+  id: string;
+  autoAdvance?: boolean | null;
+  autoAdvanceDelay?: number | null;
+}
+
+export const RemoteActivityFragment = gql`
+  fragment RemoteActivityFragment on Activity {
+    activityId
+    startTime
+    endTime
+    scheduledStartTime
+    scheduledEndTime
+  }
+`;
+
+export const RemoteCompetitionDocument = gql`
+  query RemoteCompetition($competitionId: String!) {
+    competition(competitionId: $competitionId) {
+      id
+      autoAdvance
+      autoAdvanceDelay
+    }
+  }
+`;
+
+export const RemoteActivitiesDocument = gql`
+  query RemoteActivities($competitionId: String!, $roomId: Int) {
+    activities(competitionId: $competitionId, roomId: $roomId) {
+      ...RemoteActivityFragment
+    }
+  }
+  ${RemoteActivityFragment}
+`;
+
+export const RemoteActivitiesSubscriptionDocument = gql`
+  subscription RemoteActivities($competitionIds: [String!]!) {
+    activity: activityUpdated(competitionIds: $competitionIds) {
+      ...RemoteActivityFragment
+    }
+  }
+  ${RemoteActivityFragment}
+`;
+
+export const ImportRemoteCompetitionDocument = gql`
+  mutation ImportRemoteCompetition($competitionId: String!) {
+    importCompetition(competitionId: $competitionId) {
+      id
+      autoAdvance
+      autoAdvanceDelay
+    }
+  }
+`;
+
+export const StartRemoteActivityDocument = gql`
+  mutation StartRemoteActivity($competitionId: String!, $activityId: Int!) {
+    startActivity(competitionId: $competitionId, activityId: $activityId) {
+      ...RemoteActivityFragment
+    }
+  }
+  ${RemoteActivityFragment}
+`;
+
+export const StopRemoteActivityDocument = gql`
+  mutation StopRemoteActivity($competitionId: String!, $activityId: Int!) {
+    stopActivity(competitionId: $competitionId, activityId: $activityId) {
+      ...RemoteActivityFragment
+    }
+  }
+  ${RemoteActivityFragment}
+`;
+
+export const ResetRemoteActivityDocument = gql`
+  mutation ResetRemoteActivity($competitionId: String!, $activityId: Int!) {
+    resetActivity(competitionId: $competitionId, activityId: $activityId) {
+      ...RemoteActivityFragment
+    }
+  }
+  ${RemoteActivityFragment}
+`;
+
+export const StartRemoteActivitiesDocument = gql`
+  mutation StartRemoteActivities($competitionId: String!, $activityIds: [Int!]!) {
+    startActivities(competitionId: $competitionId, activityIds: $activityIds) {
+      ...RemoteActivityFragment
+    }
+  }
+  ${RemoteActivityFragment}
+`;
+
+export const StopRemoteActivitiesDocument = gql`
+  mutation StopRemoteActivities($competitionId: String!, $activityIds: [Int!]!) {
+    stopActivities(competitionId: $competitionId, activityIds: $activityIds) {
+      ...RemoteActivityFragment
+    }
+  }
+  ${RemoteActivityFragment}
+`;
+
+export const ResetRemoteActivitiesDocument = gql`
+  mutation ResetRemoteActivities($competitionId: String!, $activityIds: [Int!]) {
+    resetActivities(competitionId: $competitionId, activityIds: $activityIds) {
+      ...RemoteActivityFragment
+    }
+  }
+  ${RemoteActivityFragment}
+`;
+
+export const UpdateRemoteAutoAdvanceDocument = gql`
+  mutation UpdateRemoteAutoAdvance(
+    $competitionId: String!
+    $autoAdvance: Boolean
+    $autoAdvanceDelay: Int
+  ) {
+    updateAutoAdvance(
+      competitionId: $competitionId
+      autoAdvance: $autoAdvance
+      autoAdvanceDelay: $autoAdvanceDelay
+    ) {
+      id
+      autoAdvance
+      autoAdvanceDelay
+    }
+  }
+`;
diff --git a/src/lib/notifyCompWebSocketStatus.ts b/src/lib/notifyCompWebSocketStatus.ts
new file mode 100644
index 0000000..310756c
--- /dev/null
+++ b/src/lib/notifyCompWebSocketStatus.ts
@@ -0,0 +1,31 @@
+export type NotifyCompWebSocketStatus = 'idle' | 'connecting' | 'connected' | 'disconnected';
+
+export interface NotifyCompWebSocketStatusState {
+  message?: string;
+  status: NotifyCompWebSocketStatus;
+}
+
+type Listener = () => void;
+
+let state: NotifyCompWebSocketStatusState = {
+  status: 'idle',
+};
+const listeners = new Set<Listener>();
+
+export const getNotifyCompWebSocketStatus = () => state;
+
+export const subscribeToNotifyCompWebSocketStatus = (listener: Listener) => {
+  listeners.add(listener);
+
+  return () => {
+    listeners.delete(listener);
+  };
+};
+
+export const setNotifyCompWebSocketStatus = (nextState: NotifyCompWebSocketStatusState) => {
+  state = nextState;
+  listeners.forEach((listener) => listener());
+};
+
+export const canUseNotifyCompRemoteControls = (status: NotifyCompWebSocketStatus) =>
+  status === 'connected';
diff --git a/src/lib/remoteConfig.ts b/src/lib/remoteConfig.ts
new file mode 100644
index 0000000..77afa57
--- /dev/null
+++ b/src/lib/remoteConfig.ts
@@ -0,0 +1,11 @@
+const rawNotifyCompApiOrigin =
+  import.meta.env.VITE_NOTIFYCOMP_API_ORIGIN || 'https://api.notifycomp.com/api';
+
+export const NOTIFYCOMP_GRAPHQL_ORIGIN = rawNotifyCompApiOrigin.endsWith('/graphql')
+  ? rawNotifyCompApiOrigin
+  : `${rawNotifyCompApiOrigin.replace(/\/$/, '')}/graphql`;
+
+export const NOTIFYCOMP_API_ORIGIN = NOTIFYCOMP_GRAPHQL_ORIGIN.replace(/\/graphql$/, '');
+
+export const NOTIFYCOMP_WS_ORIGIN =
+  import.meta.env.VITE_NOTIFYCOMP_WS_ORIGIN || NOTIFYCOMP_GRAPHQL_ORIGIN.replace(/^http/, 'ws');
diff --git a/src/lib/roundLabels.ts b/src/lib/roundLabels.ts
new file mode 100644
index 0000000..b2b3fab
--- /dev/null
+++ b/src/lib/roundLabels.ts
@@ -0,0 +1,31 @@
+import { Competition, parseActivityCode } from '@wca/helpers';
+import { TFunction } from 'i18next';
+import { CompatibleRound } from './wcif';
+
+export function getEventRoundsForRound(events: Competition['events'] | undefined, roundId: string) {
+  const { eventId } = parseActivityCode(roundId);
+
+  return (
+    events
+      ?.find((event) => event.id === eventId)
+      ?.rounds?.map((candidate) => candidate as CompatibleRound) || []
+  );
+}
+
+export function activityCodeToRoundName(t: TFunction, roundId: string) {
+  const { roundNumber } = parseActivityCode(roundId);
+
+  return t('common.activityCodeToName.round', { roundNumber });
+}
+
+export function joinLabels(labels: string[]) {
+  if (labels.length <= 1) {
+    return labels[0] || '';
+  }
+
+  if (labels.length === 2) {
+    return `${labels[0]} & ${labels[1]}`;
+  }
+
+  return `${labels.slice(0, -1).join(', ')}, & ${labels[labels.length - 1]}`;
+}
diff --git a/src/lib/rounds.ts b/src/lib/rounds.ts
new file mode 100644
index 0000000..9752646
--- /dev/null
+++ b/src/lib/rounds.ts
@@ -0,0 +1,21 @@
+import { Competition, Round } from '@wca/helpers';
+import { CompetitionEvent } from '@/extensions/com.delegatedashboard.unofficialEvents';
+import { getAllEvents } from './events';
+
+export interface RoundWithEvent {
+  event: CompetitionEvent;
+  round: Round;
+  roundNumber: number;
+}
+
+export const getAllRoundsWithEvents = (wcif: Competition): RoundWithEvent[] =>
+  getAllEvents(wcif).flatMap((event) =>
+    event.rounds.map((round, index) => ({
+      event,
+      round,
+      roundNumber: index + 1,
+    })),
+  );
+
+export const findRoundWithEvent = (wcif: Competition, roundId: string) =>
+  getAllRoundsWithEvents(wcif).find(({ round }) => round.id === roundId);
diff --git a/src/lib/wcaAccessToken.ts b/src/lib/wcaAccessToken.ts
new file mode 100644
index 0000000..f60588c
--- /dev/null
+++ b/src/lib/wcaAccessToken.ts
@@ -0,0 +1,12 @@
+import { getLocalStorage } from './localStorage';
+
+export const getStoredWcaAccessToken = () => {
+  const expiresAt = Number(getLocalStorage('expirationTime') ?? 0);
+  const accessToken = getLocalStorage('accessToken');
+
+  if (!accessToken || !expiresAt || expiresAt <= Date.now()) {
+    return null;
+  }
+
+  return accessToken;
+};
diff --git a/src/lib/wcif.test.ts b/src/lib/wcif.test.ts
new file mode 100644
index 0000000..4bb141c
--- /dev/null
+++ b/src/lib/wcif.test.ts
@@ -0,0 +1,111 @@
+import { Round } from '@wca/helpers';
+import { getAdvancementConditionForRound, getRoundParticipationRuleset } from './wcif';
+
+describe('wcif participation helpers', () => {
+  it('backfills stable advancement conditions into a participation ruleset', () => {
+    const rounds = [
+      {
+        id: '333-r1',
+        format: 'a',
+        results: [],
+      },
+      {
+        id: '333-r2',
+        format: 'a',
+        advancementCondition: {
+          type: 'ranking',
+          level: 16,
+        },
+        results: [],
+      },
+    ] as unknown as Round[];
+
+    expect(getRoundParticipationRuleset(rounds, rounds[1])).toEqual({
+      participationSource: {
+        type: 'round',
+        roundId: '333-r1',
+        resultCondition: {
+          type: 'ranking',
+          value: 16,
+        },
+      },
+    });
+  });
+
+  it('derives current-round advancement from the next round participation ruleset', () => {
+    const rounds = [
+      {
+        id: '333-r1',
+        format: 'a',
+        results: [],
+      },
+      {
+        id: '333-r2',
+        format: 'a',
+        participationRuleset: {
+          participationSource: {
+            type: 'round',
+            roundId: '333-r1',
+            resultCondition: {
+              type: 'percent',
+              value: 75,
+            },
+          },
+        },
+        results: [],
+      },
+    ] as unknown as Round[];
+
+    expect(getAdvancementConditionForRound(rounds, rounds[0])).toEqual({
+      sourceType: 'round',
+      sourceRoundIds: ['333-r1'],
+      targetRoundId: '333-r2',
+      resultCondition: {
+        type: 'percent',
+        value: 75,
+      },
+      reservedPlaces: null,
+    });
+  });
+
+  it('derives linked-round advancement from the next round participation ruleset', () => {
+    const rounds = [
+      {
+        id: '333-r1',
+        format: 'a',
+        results: [],
+      },
+      {
+        id: '333-r2',
+        format: 'a',
+        results: [],
+      },
+      {
+        id: '333-r3',
+        format: 'a',
+        participationRuleset: {
+          participationSource: {
+            type: 'linkedRounds',
+            roundIds: ['333-r1', '333-r2'],
+            resultCondition: {
+              type: 'ranking',
+              value: 12,
+            },
+          },
+        },
+        results: [],
+      },
+    ] as unknown as Round[];
+
+    expect(getAdvancementConditionForRound(rounds, rounds[1])).toEqual({
+      sourceType: 'linkedRounds',
+      sourceRoundIds: ['333-r1', '333-r2'],
+      targetRoundId: '333-r3',
+      resultCondition: {
+        type: 'ranking',
+        value: 12,
+      },
+      reservedPlaces: null,
+    });
+  });
+});
diff --git a/src/lib/wcif.ts b/src/lib/wcif.ts
new file mode 100644
index 0000000..c2b2f59
--- /dev/null
+++ b/src/lib/wcif.ts
@@ -0,0 +1,153 @@
+import {
+  ParticipationResultCondition,
+  ParticipationRuleset,
+  ParticipationSource,
+  ReservedPlaces,
+  Round,
+  parseActivityCode,
+} from '@wca/helpers';
+
+type LegacyAdvancementCondition = NonNullable<Round['advancementCondition']>;
+
+export type ResultCondition = ParticipationResultCondition;
+
+export interface RoundAdvancementCondition {
+  sourceType: ParticipationSource['type'];
+  sourceRoundIds: string[];
+  targetRoundId?: string | null;
+  resultCondition: ResultCondition;
+  reservedPlaces?: ReservedPlaces | null;
+}
+
+export type CompatibleRound = Round;
+
+const averagedFormats = new Set(['a', 'm', '5', 'h']);
+
+const getRoundResultType = (round: Pick<Round, 'format'>): 'single' | 'average' =>
+  averagedFormats.has(round.format) ? 'average' : 'single';
+
+const getLegacyResultCondition = (
+  advancementCondition: LegacyAdvancementCondition,
+  sourceRound?: Round,
+): ResultCondition => {
+  switch (advancementCondition.type) {
+    case 'ranking':
+      return {
+        type: 'ranking',
+        value: advancementCondition.level,
+      };
+    case 'percent':
+      return {
+        type: 'percent',
+        value: advancementCondition.level,
+      };
+    case 'attemptResult':
+      return {
+        type: 'resultAchieved',
+        scope: sourceRound ? getRoundResultType(sourceRound) : 'single',
+        value: advancementCondition.level,
+      };
+  }
+};
+
+const getPreviousRound = (eventRounds: Round[], round: Round): Round | undefined => {
+  const { eventId, roundNumber } = parseActivityCode(round.id);
+
+  if (!roundNumber || roundNumber <= 1) {
+    return undefined;
+  }
+
+  return eventRounds.find((candidate) => candidate.id === `${eventId}-r${roundNumber - 1}`);
+};
+
+export const getRoundParticipationRuleset = (
+  eventRounds: Round[],
+  round: Round,
+): ParticipationRuleset | null => {
+  if (round.participationRuleset) {
+    return round.participationRuleset;
+  }
+
+  if (!round.advancementCondition) {
+    return null;
+  }
+
+  const previousRound = getPreviousRound(eventRounds, round);
+  if (!previousRound) {
+    return null;
+  }
+
+  return {
+    participationSource: {
+      type: 'round',
+      roundId: previousRound.id,
+      resultCondition: getLegacyResultCondition(round.advancementCondition, previousRound),
+    },
+  };
+};
+
+const getRoundParticipationSource = (
+  eventRounds: Round[],
+  round: Round,
+): ParticipationSource | null =>
+  getRoundParticipationRuleset(eventRounds, round)?.participationSource ?? null;
+
+export const getAdvancementConditionForRound = (
+  eventRounds: Round[],
+  round: Round,
+): RoundAdvancementCondition | null => {
+  if (round.advancementCondition) {
+    const { eventId, roundNumber } = parseActivityCode(round.id);
+    const targetRoundId =
+      roundNumber != null
+        ? eventRounds.find((candidate) => candidate.id === `${eventId}-r${roundNumber + 1}`)?.id
+        : null;
+
+    return {
+      sourceType: 'round',
+      sourceRoundIds: [round.id],
+      targetRoundId: targetRoundId ?? null,
+      resultCondition: getLegacyResultCondition(round.advancementCondition, round),
+      reservedPlaces: null,
+    };
+  }
+
+  const { roundNumber } = parseActivityCode(round.id);
+  const futureRounds = eventRounds.filter((candidate) => {
+    const parsedCandidate = parseActivityCode(candidate.id);
+    return (parsedCandidate.roundNumber ?? 0) > (roundNumber ?? 0);
+  });
+
+  const nextEligibleRound = futureRounds.find((candidate) => {
+    const source = getRoundParticipationSource(eventRounds, candidate);
+
+    if (!source || source.type === 'registrations') {
+      return false;
+    }
+
+    if (source.type === 'round') {
+      return source.roundId === round.id;
+    }
+
+    return source.roundIds.includes(round.id);
+  });
+
+  if (!nextEligibleRound) {
+    return null;
+  }
+
+  const ruleset = getRoundParticipationRuleset(eventRounds, nextEligibleRound);
+  const source = ruleset?.participationSource;
+
+  if (!source || source.type === 'registrations') {
+    return null;
+  }
+
+  return {
+    sourceType: source.type,
+    sourceRoundIds: source.type === 'round' ? [source.roundId] : source.roundIds,
+    targetRoundId: nextEligibleRound.id,
+    resultCondition: source.resultCondition,
+    reservedPlaces: ruleset?.reservedPlaces ?? null,
+  };
+};
diff --git a/src/pages/Competition/Admin/index.tsx b/src/pages/Competition/Admin/index.tsx
new file mode 100644
index 0000000..32bcb24
--- /dev/null
+++ b/src/pages/Competition/Admin/index.tsx
@@ -0,0 +1,55 @@
+import { useEffect } from 'react';
+import { Link } from 'react-router-dom';
+import { Container, NoteBox } from '@/components';
+import { useCompetitionLayoutTabs } from '@/layouts/CompetitionLayout/CompetitionLayout.tabs';
+import { useWCIF } from '@/providers/WCIFProvider';
+
+const adminDescriptions: Record<string, string> = {
+  scramblers: 'View scrambler assignments by event and round.',
+  remote: 'Control Live Activities updates for the competition.',
+  'sum-of-ranks': 'Review competitor rankings across completed rounds.',
+  stats: 'View competition registration and event counts.',
+};
+
+const adminItemId = (href: string) => href.split('/').pop() ?? href;
+
+export default function CompetitionAdmin() {
+  const { competitionId, wcif, setTitle } = useWCIF();
+  const { adminTabs } = useCompetitionLayoutTabs({ competitionId, wcif });
+
+  useEffect(() => {
+    setTitle('Admin');
+  }, [setTitle]);
+
+  return (
+    <Container className="space-y-4 p-2 pt-4">
+      <h1 className="type-heading">Admin</h1>
+      {adminTabs.length === 0 ? (
+        <NoteBox text="No admin tools are available for your account at this competition." />
+      ) : (
+        <div className="space-y-2">
+          {adminTabs.map((tab) => {
+            const itemId = adminItemId(tab.href);
+
+            return (
+              <Link
+                key={tab.href}
+                to={tab.href}
+                className="block rounded-md border border-tertiary-weak bg-panel px-4 py-3 shadow-sm hover-bg-tertiary">
+                <div className="flex items-center justify-between gap-4">
+                  <div className="min-w-0 space-y-1">
+                    <div className="type-label text-default">{tab.text}</div>
+                    {adminDescriptions[itemId] && (
+                      <div className="type-body-sm text-subtle">{adminDescriptions[itemId]}</div>
+                    )}
+                  </div>
+                  <i className="fa fa-chevron-right shrink-0 text-muted" aria-hidden="true" />
+                </div>
+              </Link>
+            );
+          })}
+        </div>
+      )}
+    </Container>
+  );
+}
diff --git a/src/pages/Competition/ByGroup/Events.tsx b/src/pages/Competition/ByGroup/Events.tsx
index 292ef50..5f804bd 100644
--- a/src/pages/Competition/ByGroup/Events.tsx
+++ b/src/pages/Competition/ByGroup/Events.tsx
@@ -1,15 +1,14 @@
-import { useNavigate, useParams } from 'react-router-dom';
+import { Link, useParams } from 'react-router-dom';
 import { CompetitionEventsContainer } from '@/containers/CompetitionEvents';
 
 const Events = () => {
-  const navigate = useNavigate();
   const { competitionId } = useParams<{ competitionId: string }>();
 
   if (!competitionId) {
     return null;
   }
 
-  return <CompetitionEventsContainer competitionId={competitionId} onNavigate={navigate} />;
+  return <CompetitionEventsContainer competitionId={competitionId} LinkComponent={Link} />;
 };
 
 export default Events;
diff --git a/src/pages/Competition/Remote/RemoteActivityList.stories.tsx b/src/pages/Competition/Remote/RemoteActivityList.stories.tsx
new file mode 100644
index 0000000..f06812e
--- /dev/null
+++ b/src/pages/Competition/Remote/RemoteActivityList.stories.tsx
@@ -0,0 +1,98 @@
+import type { Meta, StoryObj } from '@storybook/react';
+import { RemoteActivityGroup, RemoteScheduledActivity } from '@/lib/notifyCompRemoteActivities';
+import { storybookCompetitionFixture } from '@/storybook/competitionFixtures';
+import { RemoteGroupList } from './RemoteActivityList';
+
+const venue = storybookCompetitionFixture.schedule.venues[0];
+const mainRoom = venue.rooms[0];
+const sideRoom = venue.rooms[1];
+
+const scheduledActivity = (
+  room: typeof mainRoom,
+  parentIndex: number,
+  childIndex: number,
+): RemoteScheduledActivity => {
+  const parent = room.activities[parentIndex];
+  const child = parent.childActivities[childIndex] || parent;
+
+  return {
+    ...child,
+    parent,
+    room: {
+      ...room,
+      venue: {
+        timezone: venue.timezone,
+      },
+    },
+  } as RemoteScheduledActivity;
+};
+
+const group = (
+  id: string,
+  status: RemoteActivityGroup['status'],
+  activities: RemoteScheduledActivity[],
+): RemoteActivityGroup => ({
+  id,
+  name: activities[0]?.name || id,
+  scheduledActivities: activities,
+  liveActivities: activities.map((activity) => ({
+    activityId: activity.id,
+    startTime:
+      status === 'current' || status === 'mixed' || status === 'done' ? activity.startTime : null,
+    endTime: status === 'done' ? activity.endTime : null,
+  })),
+  status,
+});
+
+const currentGroup = group('333-r1-g1', 'current', [
+  scheduledActivity(mainRoom, 0, 0),
+  scheduledActivity(sideRoom, 0, 0),
+]);
+const nextGroup = group('333-r1-g2', 'next', [
+  scheduledActivity(mainRoom, 0, 1),
+  scheduledActivity(sideRoom, 0, 1),
+]);
+const doneGroup = group('222-r1-g1', 'done', [scheduledActivity(mainRoom, 3, 0)]);
+
+const meta = {
+  title: 'Pages/Competition/Remote/Activity List',
+  component: RemoteGroupList,
+  decorators: [
+    (Story) => (
+      <div className="w-full max-w-2xl bg-panel p-4 text-default">
+        <Story />
+      </div>
+    ),
+  ],
+  args: {
+    disabled: false,
+    onSelectGroup: () => {},
+  },
+  parameters: {
+    layout: 'padded',
+  },
+  tags: ['autodocs'],
+} satisfies Meta<typeof RemoteGroupList>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const MixedStates: Story = {
+  args: {
+    groups: [currentGroup, nextGroup, doneGroup],
+  },
+};
+
+export const NoUpcomingActivities: Story = {
+  args: {
+    groups: [doneGroup],
+  },
+};
+
+export const Saving: Story = {
+  args: {
+    disabled: true,
+    groups: [currentGroup, nextGroup, doneGroup],
+  },
+};
diff --git a/src/pages/Competition/Remote/RemoteActivityList.tsx b/src/pages/Competition/Remote/RemoteActivityList.tsx
new file mode 100644
index 0000000..7a0590d
--- /dev/null
+++ b/src/pages/Competition/Remote/RemoteActivityList.tsx
@@ -0,0 +1,263 @@
+import classNames from 'classnames';
+import { formatDuration, intervalToDuration } from 'date-fns';
+import { NoteBox } from '@/components';
+import { RoomPill } from '@/components/Pill';
+import { useNow } from '@/hooks/useNow';
+import { activityCodeToName } from '@/lib/activityCodes';
+import {
+  RemoteActivityGroup,
+  RemoteScheduledActivity,
+  RemoteActivityState,
+  splitRemoteActivityGroups,
+  splitRemoteActivityStates,
+} from '@/lib/notifyCompRemoteActivities';
+import { formatTime, formatTimeRange } from '@/lib/time';
+
+const REMOTE_TIME_ROUNDING_MINUTES = 1;
+
+const formatStartedDuration = (startTime: string, now: Date) => {
+  const { hours, minutes } = intervalToDuration({
+    start: new Date(startTime),
+    end: now,
+  });
+
+  return formatDuration({ hours, minutes }) || 'now';
+};
+
+const formatRemoteElapsedDuration = (startTime?: string | null, endTime?: string | null) => {
+  if (!startTime || !endTime) {
+    return null;
+  }
+
+  const { hours, minutes, seconds } = intervalToDuration({
+    start: new Date(startTime),
+    end: new Date(endTime),
+  });
+
+  return formatDuration({ hours, minutes, seconds }) || '0 seconds';
+};
+
+const stateDescription = (state: RemoteActivityState, now: Date) => {
+  const timeZone = groupTimeZone(state.scheduledActivity);
+
+  if (state.liveActivity?.startTime && !state.liveActivity.endTime) {
+    return `Started ${formatStartedDuration(state.liveActivity.startTime, now)} ago`;
+  }
+
+  if (state.liveActivity?.endTime) {
+    const elapsed = formatRemoteElapsedDuration(
+      state.liveActivity.startTime,
+      state.liveActivity.endTime,
+    );
+
+    return `Ended at ${formatTime(
+      state.liveActivity.endTime,
+      REMOTE_TIME_ROUNDING_MINUTES,
+      timeZone,
+    )}${elapsed ? ` - Duration ${elapsed}` : ''}`;
+  }
+
+  return `Should start at ${formatTime(
+    state.scheduledActivity.startTime,
+    REMOTE_TIME_ROUNDING_MINUTES,
+    timeZone,
+  )}`;
+};
+
+const groupActivityName = (activity: RemoteScheduledActivity) =>
+  activity.activityCode.startsWith('other')
+    ? activity.name
+    : activityCodeToName(activity.activityCode);
+
+const groupRooms = (group: RemoteActivityGroup) =>
+  Array.from(
+    new Map(
+      group.scheduledActivities.map((activity) => [activity.room.id, activity.room]),
+    ).values(),
+  );
+
+const groupTimeZone = (activity: RemoteScheduledActivity) =>
+  (activity.room as RemoteScheduledActivity['room'] & { venue?: { timezone?: string } }).venue
+    ?.timezone;
+
+const groupElapsedDuration = (group: RemoteActivityGroup) => {
+  const startedActivities = group.liveActivities.filter(
+    (activity) => activity.startTime && activity.endTime,
+  );
+
+  if (startedActivities.length === 0) {
+    return null;
+  }
+
+  const startTime = startedActivities
+    .map((activity) => activity.startTime)
+    .filter(Boolean)
+    .sort()[0];
+  const endTime = startedActivities
+    .map((activity) => activity.endTime)
+    .filter(Boolean)
+    .sort()
+    .at(-1);
+
+  return formatRemoteElapsedDuration(startTime, endTime);
+};
+
+interface RemoteActivityListProps {
+  disabled?: boolean;
+  onSelectActivity: (state: RemoteActivityState) => void;
+  states: RemoteActivityState[];
+}
+
+export function RemoteActivityList({
+  disabled,
+  onSelectActivity,
+  states,
+}: RemoteActivityListProps) {
+  const now = useNow();
+  const groupedStates = splitRemoteActivityStates(states);
+
+  const sections: Array<{
+    emptyText?: string;
+    items: RemoteActivityState[];
+    title: string;
+  }> = [
+    {
+      items: groupedStates.current,
+      title: 'Current',
+    },
+    {
+      emptyText: 'No upcoming activities remain for this room.',
+      items: groupedStates.next,
+      title: 'Next',
+    },
+    {
+      items: groupedStates.done,
+      title: 'Done',
+    },
+  ];
+
+  return (
+    <div className="space-y-4">
+      {sections.map((section) => (
+        <section key={section.title} className="space-y-2">
+          <h3 className="type-heading">{section.title}</h3>
+          {section.items.length === 0 && section.emptyText && (
+            <NoteBox prefix="" text={section.emptyText} />
+          )}
+          <div className="divide-y divide-tertiary-weak">
+            {section.items.map((state) => (
+              <button
+                key={state.scheduledActivity.id}
+                type="button"
+                disabled={disabled || state.status === 'done'}
+                className="block w-full py-4 text-left hover-transition hover:bg-gray-100 disabled:cursor-default disabled:opacity-70 dark:hover:bg-gray-700"
+                onClick={() => onSelectActivity(state)}>
+                <div className="space-y-1">
+                  <div className="type-label">{state.scheduledActivity.name}</div>
+                  <div className="type-meta">
+                    {state.scheduledActivity.room.name} - {stateDescription(state, now)}
+                  </div>
+                </div>
+              </button>
+            ))}
+          </div>
+        </section>
+      ))}
+    </div>
+  );
+}
+
+interface RemoteGroupListProps {
+  disabled?: boolean;
+  groups: RemoteActivityGroup[];
+  onSelectGroup: (group: RemoteActivityGroup) => void;
+}
+
+export function RemoteGroupList({ disabled, groups, onSelectGroup }: RemoteGroupListProps) {
+  const groupedStates = splitRemoteActivityGroups(groups);
+  const sections: Array<{
+    emptyText?: string;
+    items: RemoteActivityGroup[];
+    title: string;
+  }> = [
+    {
+      items: groupedStates.current,
+      title: 'Current',
+    },
+    {
+      emptyText: 'No upcoming activities remain.',
+      items: groupedStates.next,
+      title: 'Next',
+    },
+    {
+      items: groupedStates.done,
+      title: 'Done',
+    },
+  ];
+
+  return (
+    <div className="space-y-4">
+      {sections.map((section) => (
+        <section key={section.title} className="space-y-2">
+          <h3 className="type-heading">{section.title}</h3>
+          {section.items.length === 0 && section.emptyText && (
+            <NoteBox prefix="" text={section.emptyText} />
+          )}
+          <div className="divide-y divide-tertiary-weak">
+            {section.items.map((group) => {
+              const activityIds = group.scheduledActivities.map((activity) => activity.id);
+              const firstActivity = group.scheduledActivities[0];
+              const rooms = groupRooms(group);
+              const elapsed = group.status === 'done' ? groupElapsedDuration(group) : null;
+
+              return (
+                <button
+                  key={`${group.id}-${activityIds.join('-')}`}
+                  type="button"
+                  disabled={disabled}
+                  className={classNames(
+                    'flex w-full flex-col p-2 text-left type-body even:table-bg-row-alt hover:table-bg-row-hover disabled:cursor-default disabled:opacity-60',
+                    {
+                      'opacity-50': group.status === 'done',
+                    },
+                  )}
+                  onClick={() => onSelectGroup(group)}>
+                  <span className="type-body">
+                    {firstActivity ? groupActivityName(firstActivity) : group.name}
+                  </span>
+                  <span className="flex items-start justify-between gap-4 type-meta">
+                    <span className="flex min-w-0 flex-wrap gap-2">
+                      {rooms.map((room) => (
+                        <RoomPill
+                          key={room.id}
+                          className="px-1"
+                          style={{
+                            backgroundColor: `${room.color}70`,
+                          }}>
+                          {room.name}
+                        </RoomPill>
+                      ))}
+                    </span>
+                    {firstActivity && (
+                      <span className="ml-auto flex shrink-0 flex-col whitespace-nowrap text-right">
+                        <span>
+                          {formatTimeRange(
+                            firstActivity.startTime,
+                            firstActivity.endTime,
+                            REMOTE_TIME_ROUNDING_MINUTES,
+                            groupTimeZone(firstActivity),
+                          )}
+                        </span>
+                        {elapsed && <span>Duration {elapsed}</span>}
+                      </span>
+                    )}
+                  </span>
+                </button>
+              );
+            })}
+          </div>
+        </section>
+      ))}
+    </div>
+  );
+}
diff --git a/src/pages/Competition/Remote/RemoteAutoAdvanceToggle.tsx b/src/pages/Competition/Remote/RemoteAutoAdvanceToggle.tsx
new file mode 100644
index 0000000..5b04f32
--- /dev/null
+++ b/src/pages/Competition/Remote/RemoteAutoAdvanceToggle.tsx
@@ -0,0 +1,36 @@
+import classNames from 'classnames';
+
+interface RemoteAutoAdvanceToggleProps {
+  checked: boolean;
+  disabled?: boolean;
+  onToggle: () => void;
+}
+
+export function RemoteAutoAdvanceToggle({
+  checked,
+  disabled,
+  onToggle,
+}: RemoteAutoAdvanceToggleProps) {
+  return (
+    <button
+      type="button"
+      role="switch"
+      aria-checked={checked}
+      aria-label="Auto-advance"
+      disabled={disabled}
+      className={classNames(
+        'relative inline-flex h-7 w-12 rounded-full border p-0.5 shadow-sm hover-transition focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-blue-500 disabled:cursor-not-allowed disabled:opacity-50',
+        checked
+          ? 'border-primary bg-primary hover:bg-primary-strong'
+          : 'border-tertiary bg-tertiary hover:bg-tertiary-strong',
+      )}
+      onClick={onToggle}>
+      <span
+        className={classNames(
+          'h-6 w-6 rounded-full border border-tertiary-weak bg-panel shadow-sm transition-transform',
+          checked ? 'translate-x-5' : 'translate-x-0',
+        )}
+      />
+    </button>
+  );
+}
diff --git a/src/pages/Competition/Remote/index.tsx b/src/pages/Competition/Remote/index.tsx
new file mode 100644
index 0000000..10c27cb
--- /dev/null
+++ b/src/pages/Competition/Remote/index.tsx
@@ -0,0 +1,304 @@
+import classNames from 'classnames';
+import { useEffect } from 'react';
+import { Link, useParams } from 'react-router-dom';
+import { BarLoader } from 'react-spinners';
+import {
+  Button,
+  Container,
+  NoteBox,
+  NotifyCompConnectionStatus,
+  RemoteActivitySummaryList,
+} from '@/components';
+import { useCompetitionRemoteControl } from '@/hooks/useCompetitionRemoteControl';
+import { useNotifyCompWebSocketStatus } from '@/hooks/useNotifyCompWebSocketStatus';
+import { isCompetitionDayOrAfter } from '@/lib/competitionDates';
+import { RemoteActivityGroup } from '@/lib/notifyCompRemoteActivities';
+import { canUseNotifyCompRemoteControls } from '@/lib/notifyCompWebSocketStatus';
+import { useAuth } from '@/providers/AuthProvider';
+import { useConfirm } from '@/providers/ConfirmProvider';
+import { useNotifyCompRemoteAuth } from '@/providers/NotifyCompRemoteAuthProvider';
+import { useWCIF } from '@/providers/WCIFProvider';
+import { RemoteGroupList } from './RemoteActivityList';
+import { RemoteAutoAdvanceToggle } from './RemoteAutoAdvanceToggle';
+
+export default function CompetitionRemote() {
+  const { competitionId } = useParams<{ competitionId: string }>();
+  const { wcif, setTitle } = useWCIF();
+  const { user } = useAuth();
+  const confirm = useConfirm();
+  const remoteAuth = useNotifyCompRemoteAuth();
+  const notifyCompWebSocketStatus = useNotifyCompWebSocketStatus();
+
+  useEffect(() => {
+    setTitle('Remote');
+  }, [setTitle]);
+
+  const remote = useCompetitionRemoteControl({
+    competitionId: competitionId || '',
+  });
+
+  if (!competitionId || !wcif) {
+    return null;
+  }
+
+  const hasStartedRemoteActivities = remote.activities.some((activity) => activity.startTime);
+  const hasUnfinishedRemoteActivities = remote.activities.some(
+    (activity) => activity.startTime && !activity.endTime,
+  );
+  const hasDoneRemoteActivityGroups = remote.activityGroups.some(
+    (group) => group.status === 'done',
+  );
+  const hasCurrentRemoteActivityGroups = remote.activityGroups.some(
+    (group) => group.status === 'current' || group.status === 'mixed',
+  );
+  const isCompetitionInProgressOrPast = isCompetitionDayOrAfter(wcif);
+  const canResetAllActivities =
+    Boolean(remote.competition) && hasDoneRemoteActivityGroups && !hasCurrentRemoteActivityGroups;
+  const canFinishAllActivities =
+    Boolean(remote.competition) &&
+    !canResetAllActivities &&
+    isCompetitionInProgressOrPast &&
+    (hasUnfinishedRemoteActivities || hasCurrentRemoteActivityGroups);
+  const canFinishCompetition = canFinishAllActivities && !remote.nextGroup;
+  const hasFinishedAllStartedActivities =
+    canResetAllActivities && isCompetitionInProgressOrPast && hasStartedRemoteActivities;
+  const hasImportedEmptySchedule =
+    Boolean(remote.competition) && remote.scheduledActivities.length === 0;
+  const accessDenied = (Boolean(user) || remote.isAuthenticated) && !remote.canManageRemote;
+  const remoteControlsDisabled =
+    remote.isSaving || !canUseNotifyCompRemoteControls(notifyCompWebSocketStatus.status);
+
+  const importCompetition = async () => {
+    const confirmed = await confirm({
+      confirmLabel: 'Import schedule',
+      confirmVariant: 'green',
+      message:
+        'Import the published schedule into Live Activities Remote? This sends the schedule to NotifyComp, the backend service for Live Activities. It will not start anything.',
+    });
+
+    if (confirmed) {
+      await remote.importCompetition();
+    }
+  };
+
+  const selectGroup = async (group: RemoteActivityGroup) => {
+    const action =
+      group.status === 'done'
+        ? 'reset'
+        : group.status === 'current' || group.status === 'mixed'
+          ? 'stop'
+          : 'start';
+    const actionLabel = {
+      reset: 'Reset',
+      start: 'Start',
+      stop: 'Stop',
+    }[action];
+    const confirmed = await confirm({
+      confirmLabel: actionLabel,
+      confirmVariant: action === 'start' ? 'green' : 'gray',
+      message: (
+        <div className="space-y-4">
+          <p>
+            This will {action} activity: <strong>{group.name}</strong>
+          </p>
+          <RemoteActivitySummaryList activities={group.scheduledActivities} />
+          {action === 'reset' && (
+            <p>The start and stop times will reset as if the activity never happened.</p>
+          )}
+        </div>
+      ),
+    });
+
+    if (!confirmed) {
+      return;
+    }
+
+    if (action === 'start') {
+      await remote.startGroup(group);
+      return;
+    }
+
+    if (action === 'reset') {
+      await remote.resetGroup(group);
+      return;
+    }
+
+    await remote.stopGroup(group);
+  };
+
+  return (
+    <Container className="px-4 py-8">
+      <div className="space-y-6">
+        <div className="max-w-3xl space-y-2">
+          <p className="type-body-sm text-subtle">
+            Remote controls Live Activities for this competition. NotifyComp handles the backend
+            updates so staff can start, stop, and advance activities from Competition Groups.
+          </p>
+          <Link to="/live-activities" className="link-inline type-body-sm">
+            Learn how Live Activities work
+          </Link>
+        </div>
+
+        {remoteAuth.error && <NoteBox prefix="Remote sign in" text={remoteAuth.error} />}
+
+        {accessDenied ? (
+          <NoteBox
+            prefix="Remote access"
+            text="Only listed delegates and organizers for this competition can access Remote."
+          />
+        ) : !remote.isAuthenticated ? (
+          <div className="space-y-4">
+            <p className="max-w-3xl type-body-sm text-subtle">
+              Sign in to Live Activities Remote with your WCA account to connect these controls to
+              this competition. This sign-in is separate from Competition Groups because the live
+              updates are backed by NotifyComp.
+            </p>
+            <Button
+              type="button"
+              disabled={remoteAuth.authenticating}
+              onClick={() => {
+                void remoteAuth.signIn(competitionId);
+              }}>
+              {remoteAuth.authenticating ? 'Signing in...' : 'Sign in to Live Activities Remote'}
+            </Button>
+          </div>
+        ) : (
+          <>
+            {remote.isLoading && <BarLoader width="100%" />}
+            {remote.error && <NoteBox prefix="Remote error" text={remote.error} />}
+            {remote.competition && <NotifyCompConnectionStatus />}
+
+            {!remote.isLoading && !remote.competition ? (
+              <div className="space-y-4">
+                <NoteBox
+                  prefix="Not imported"
+                  text="Import the published schedule before using Remote. Importing creates the Live Activities schedule but does not start or change any activity status."
+                />
+                <Button
+                  type="button"
+                  disabled={remoteControlsDisabled}
+                  onClick={() => {
+                    void importCompetition();
+                  }}>
+                  {remote.isSaving ? 'Importing...' : 'Import schedule'}
+                </Button>
+              </div>
+            ) : hasImportedEmptySchedule ? (
+              <NoteBox
+                prefix="No activities"
+                text="This competition is imported, but the published schedule does not include any room activities to control."
+              />
+            ) : (
+              <div className="space-y-4">
+                <div className="flex flex-col gap-4 md:flex-row md:items-end md:justify-between">
+                  <h2 className="type-heading">All rooms</h2>
+                  <div className="flex items-start gap-2">
+                    <div className="space-y-1 text-right">
+                      <div className="type-meta text-muted">Auto-advance</div>
+                      <div className="max-w-sm type-meta text-subtle">
+                        Automatically moves Live Activities to the next scheduled group when the
+                        current group ends.
+                      </div>
+                    </div>
+                    <div className="pt-0.5">
+                      <RemoteAutoAdvanceToggle
+                        checked={Boolean(remote.autoAdvance)}
+                        disabled={remoteControlsDisabled}
+                        onToggle={() => {
+                          void (async () => {
+                            const autoAdvance = !remote.autoAdvance;
+                            const confirmed = await confirm({
+                              confirmLabel: autoAdvance ? 'Enable' : 'Disable',
+                              message: autoAdvance
+                                ? 'Enable auto-advance for this competition? Live Activities Remote will move to the next scheduled group when the current group ends.'
+                                : 'Disable auto-advance for this competition? Staff will need to advance Live Activities manually.',
+                            });
+
+                            if (confirmed) {
+                              await remote.updateAutoAdvance(autoAdvance);
+                            }
+                          })();
+                        }}
+                      />
+                    </div>
+                  </div>
+                </div>
+
+                <div
+                  className={classNames('space-y-4', {
+                    'opacity-60': remote.isSaving,
+                  })}>
+                  <RemoteGroupList
+                    disabled={remoteControlsDisabled}
+                    groups={remote.activityGroups}
+                    onSelectGroup={(group) => {
+                      void selectGroup(group);
+                    }}
+                  />
+                </div>
+
+                {(canResetAllActivities || canFinishAllActivities) && (
+                  <div className="border-t border-tertiary-weak pt-4 text-right">
+                    {canFinishAllActivities ? (
+                      <Button
+                        type="button"
+                        variant="gray"
+                        disabled={remoteControlsDisabled}
+                        onClick={() => {
+                          void (async () => {
+                            const confirmed = await confirm({
+                              confirmLabel: canFinishCompetition
+                                ? 'Finish competition'
+                                : 'Finish all activities',
+                              confirmVariant: 'gray',
+                              message: canFinishCompetition
+                                ? 'Finish this competition? This will set an end time for the final active Live Activity.'
+                                : 'Finish all active Live Activities for this competition? This will set an end time for every activity that has started and is still running.',
+                            });
+
+                            if (confirmed) {
+                              await remote.finishAllActivities();
+                            }
+                          })();
+                        }}>
+                        {canFinishCompetition ? 'Finish competition' : 'Finish all activities'}
+                      </Button>
+                    ) : (
+                      <Button
+                        type="button"
+                        variant="gray"
+                        disabled={remoteControlsDisabled}
+                        onClick={() => {
+                          void (async () => {
+                            const confirmed = await confirm({
+                              confirmLabel: 'Reset all activities',
+                              confirmVariant: 'gray',
+                              message:
+                                'Reset all Live Activities for this competition? This will clear every remote start and stop time.',
+                            });
+
+                            if (confirmed) {
+                              await remote.resetAllActivities();
+                            }
+                          })();
+                        }}>
+                        Reset all activities
+                      </Button>
+                    )}
+                  </div>
+                )}
+
+                {hasFinishedAllStartedActivities && (
+                  <NoteBox
+                    prefix="All finished"
+                    text="Every started Live Activity has an end time. There are no active activities to finish."
+                  />
+                )}
+              </div>
+            )}
+          </>
+        )}
+      </div>
+    </Container>
+  );
+}
diff --git a/src/pages/Competition/Results/index.stories.tsx b/src/pages/Competition/Results/index.stories.tsx
new file mode 100644
index 0000000..125f73f
--- /dev/null
+++ b/src/pages/Competition/Results/index.stories.tsx
@@ -0,0 +1,28 @@
+import type { Meta, StoryObj } from '@storybook/react';
+import {
+  makeCompetitionContainerDecorator,
+  makeRouteDecorator,
+} from '@/storybook/competitionStorybook';
+import CompetitionResultsPage from './index';
+
+const meta = {
+  title: 'Pages/Competition/Results',
+  component: CompetitionResultsPage,
+  decorators: [
+    makeCompetitionContainerDecorator(),
+    makeRouteDecorator({
+      initialPath: '/competitions/SeattleSummerOpen2026/results/333-r1',
+      routePath: '/competitions/:competitionId/results/:roundId?',
+    }),
+  ],
+  parameters: {
+    layout: 'fullscreen',
+  },
+  tags: ['autodocs'],
+} satisfies Meta<typeof CompetitionResultsPage>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};
diff --git a/src/pages/Competition/Results/index.tsx b/src/pages/Competition/Results/index.tsx
new file mode 100644
index 0000000..76faac6
--- /dev/null
+++ b/src/pages/Competition/Results/index.tsx
@@ -0,0 +1,21 @@
+import { Link, useParams } from 'react-router-dom';
+import { CompetitionResultsContainer } from '@/containers/CompetitionResults';
+
+export default function CompetitionResults() {
+  const { competitionId, roundId } = useParams<{
+    competitionId: string;
+    roundId?: string;
+  }>();
+
+  if (!competitionId) {
+    return null;
+  }
+
+  return (
+    <CompetitionResultsContainer
+      competitionId={competitionId}
+      selectedRoundId={roundId}
+      LinkComponent={Link}
+    />
+  );
+}
diff --git a/src/pages/Competition/Schedule/EventActivity.tsx b/src/pages/Competition/Schedule/EventActivity.tsx
index 77e3066..7c86034 100644
--- a/src/pages/Competition/Schedule/EventActivity.tsx
+++ b/src/pages/Competition/Schedule/EventActivity.tsx
@@ -291,7 +291,7 @@ export function EventActivity({
             <LinkComponent
               to={prevUrl || ''}
               className={classNames(
-                'w-full border border-tertiary-weak rounded-md p-2 px-2 flex cursor-pointer transition-colors my-1 justify-end',
+                'w-full border border-tertiary-weak rounded-md p-2 px-2 flex cursor-pointer hover-transition my-1 justify-end',
                 {
                   'pointer-events-none opacity-25': !prev,
                   'hover:bg-gray-100 dark:hover:bg-gray-700 group cursor-pointer': prev,
@@ -303,7 +303,7 @@ export function EventActivity({
             <LinkComponent
               to={nextUrl || ''}
               className={classNames(
-                'w-full border border-tertiary-weak rounded-md p-2 px-2 flex cursor-pointer group hover:bg-gray-100 dark:hover:bg-gray-700 transition-colors my-1',
+                'w-full border border-tertiary-weak rounded-md p-2 px-2 flex cursor-pointer group hover:bg-gray-100 dark:hover:bg-gray-700 hover-transition my-1',
                 {
                   'pointer-events-none opacity-25': !next,
                   'hover:bg-gray-100 dark:hover:bg-gray-700 group': next,
diff --git a/src/pages/Competition/Schedule/PeopleList.tsx b/src/pages/Competition/Schedule/PeopleList.tsx
index d939e81..5900f94 100644
--- a/src/pages/Competition/Schedule/PeopleList.tsx
+++ b/src/pages/Competition/Schedule/PeopleList.tsx
@@ -95,7 +95,7 @@ export const PeopleList = ({
                           <LinkComponent
                             key={person.registrantId}
                             className={classNames(
-                              'table-row cursor-pointer transition-colors',
+                              'table-row cursor-pointer hover-transition',
                               'type-body',
                               index % 2 === 0 ? colorClasses.tableRow : colorClasses.tableRowAlt,
                               `hover:${colorClasses.tableRowHover}`,
@@ -113,7 +113,7 @@ export const PeopleList = ({
                       <LinkComponent
                         key={person.registrantId}
                         className={classNames(
-                          'p-2 py-2.5 block cursor-pointer transition-colors',
+                          'p-2 py-2.5 block cursor-pointer hover-transition',
                           'type-body',
                           index % 2 === 0 ? colorClasses.tableRow : colorClasses.tableRowAlt,
                           `hover:${colorClasses.tableRowHover}`,
diff --git a/src/pages/Competition/SumOfRanks/index.tsx b/src/pages/Competition/SumOfRanks/index.tsx
new file mode 100644
index 0000000..b265478
--- /dev/null
+++ b/src/pages/Competition/SumOfRanks/index.tsx
@@ -0,0 +1,12 @@
+import { Link, useParams } from 'react-router-dom';
+import { CompetitionSumOfRanksContainer } from '@/containers/CompetitionSumOfRanks';
+
+export default function CompetitionSumOfRanks() {
+  const { competitionId } = useParams<{ competitionId: string }>();
+
+  if (!competitionId) {
+    return null;
+  }
+
+  return <CompetitionSumOfRanksContainer competitionId={competitionId} LinkComponent={Link} />;
+}
diff --git a/src/pages/LiveActivities/About.tsx b/src/pages/LiveActivities/About.tsx
new file mode 100644
index 0000000..4f47469
--- /dev/null
+++ b/src/pages/LiveActivities/About.tsx
@@ -0,0 +1,105 @@
+import { useEffect } from 'react';
+import { Container } from '@/components';
+
+const steps = [
+  {
+    title: 'Sign in to Remote',
+    text: 'Live updates use a separate session to make sure only listed delegates and organizers can control them. Even if you are already signed into the site, you may need to sign in once more with your WCA account.',
+  },
+  {
+    title: 'Import the competition',
+    text: 'A listed delegate or organizer opens Remote and imports the published competition schedule.',
+  },
+  {
+    title: 'Start the active group',
+    text: 'Remote shows one row per activity code with room chips, so multi-room groups can be started together.',
+  },
+  {
+    title: 'Keep the room display current',
+    text: 'Start, stop, reset, and auto-advance controls update what competitors and staff see as currently running.',
+  },
+];
+
+export default function LiveActivitiesAbout() {
+  useEffect(() => {
+    document.title = 'Live Activities - Competition Groups';
+  }, []);
+
+  return (
+    <Container className="px-4 py-8">
+      <div className="space-y-8">
+        <section className="space-y-4">
+          <div className="space-y-2">
+            <h1 className="type-title">Live Activities</h1>
+            <p className="max-w-3xl type-body text-subtle">
+              Live Activities let delegates and organizers show what is happening right now at a
+              competition. The Remote tab controls the live state from the schedule you already
+              publish, with NotifyComp quietly handling the backend updates that keep displays in
+              sync.
+            </p>
+          </div>
+        </section>
+
+        <section className="space-y-4">
+          <h2 className="type-heading">How it works</h2>
+          <div className="divide-y divide-tertiary-weak">
+            {steps.map((step, index) => (
+              <div key={step.title} className="flex gap-4 py-4">
+                <span className="flex h-8 w-8 shrink-0 items-center justify-center rounded-full bg-tertiary type-label">
+                  {index + 1}
+                </span>
+                <div className="space-y-1">
+                  <h3 className="type-label">{step.title}</h3>
+                  <p className="type-body-sm text-subtle">{step.text}</p>
+                </div>
+              </div>
+            ))}
+          </div>
+        </section>
+
+        <section className="space-y-4">
+          <h2 className="type-heading">What it looks like</h2>
+          <div className="space-y-2 border-y border-tertiary-weak py-4">
+            <div className="flex items-center justify-between gap-4">
+              <div>
+                <i className="fa fa-tower-broadcast mr-1 text-green-500 type-heading" />
+                <span className="type-heading">Live Activities </span>
+                <span className="type-meta align-super">Powered by NotifyComp</span>
+              </div>
+              <span className="type-meta text-muted">Live view</span>
+            </div>
+            <div className="divide-y divide-tertiary-weak">
+              <div className="flex flex-col p-2 type-body even:table-bg-row-alt">
+                <span className="type-body">Clock, Round 1, Group 1</span>
+                <span className="flex justify-between type-meta">
+                  <span className="rounded bg-blue-200 px-1 text-gray-900">Main stage</span>
+                  <span>Started 4 min ago</span>
+                </span>
+              </div>
+              <div className="flex flex-col p-2 type-body even:table-bg-row-alt">
+                <span className="type-body">3x3x3 Cube, Round 1, Group 2</span>
+                <span className="flex justify-between type-meta">
+                  <span className="rounded bg-green-200 px-1 text-gray-900">Side stage</span>
+                  <span>Up next</span>
+                </span>
+              </div>
+            </div>
+          </div>
+          <p className="type-body-sm text-subtle">
+            Competitors can quickly see what is happening now and what is coming next, without
+            needing to interpret the full schedule.
+          </p>
+        </section>
+
+        <section className="space-y-4">
+          <h2 className="type-heading">Who can use it</h2>
+          <p className="type-body-sm text-subtle">
+            Remote controls are available only to listed delegates and organizers for the
+            competition. Sign in once with your WCA account, then use the Remote tab for any
+            competition where you are listed.
+          </p>
+        </section>
+      </div>
+    </Container>
+  );
+}
diff --git a/src/pages/Settings/index.tsx b/src/pages/Settings/index.tsx
index 54e917c..87fef82 100644
--- a/src/pages/Settings/index.tsx
+++ b/src/pages/Settings/index.tsx
@@ -1,8 +1,19 @@
-import { Container } from '@/components';
+import { Button, Container } from '@/components';
+import { useMyCompetitionsQuery } from '@/containers/MyCompetitions/MyCompetitions.query';
+import { useAssignmentNotifications } from '@/hooks/useAssignmentNotifications';
+import { useAuth } from '@/providers/AuthProvider';
+import { useNotifyCompRemoteAuth } from '@/providers/NotifyCompRemoteAuthProvider';
 import { Theme, useUserSettings } from '@/providers/UserSettingsProvider';
 
 export default function Settings() {
   const { theme, setTheme } = useUserSettings();
+  const { user, signIn } = useAuth();
+  const notifyCompRemoteAuth = useNotifyCompRemoteAuth();
+  const { competitions, isLoading } = useMyCompetitionsQuery(user?.id);
+  const notifications = useAssignmentNotifications({
+    competitions,
+    user,
+  });
 
   const themeOptions: { value: Theme; label: string; description: string }[] = [
     { value: 'light', label: 'Light', description: 'Always use light theme' },
@@ -12,30 +23,112 @@ export default function Settings() {
 
   return (
     <Container className="px-4 py-8">
-      <h1 className="mb-6 type-display">Settings</h1>
-
-      <div className="p-6 bg-panel rounded-lg shadow-md shadow-tertiary-dark">
-        <h2 className="mb-4 type-heading">Appearance</h2>
-
-        <div className="space-y-3">
-          <label className="block mb-2 type-label">Theme</label>
-          {themeOptions.map((option) => (
-            <div key={option.value} className="flex items-start">
-              <input
-                type="radio"
-                id={`theme-${option.value}`}
-                name="theme"
-                value={option.value}
-                checked={theme === option.value}
-                onChange={() => setTheme(option.value)}
-                className="radio mt-1"
-              />
-              <label htmlFor={`theme-${option.value}`} className="flex-1 ml-3 cursor-pointer">
-                <span className="block type-label">{option.label}</span>
-                <span className="block type-meta">{option.description}</span>
-              </label>
+      <div className="space-y-6">
+        <h1 className="type-display">Settings</h1>
+
+        <div className="space-y-4 p-6 bg-panel rounded-lg shadow-md shadow-tertiary-dark">
+          <h2 className="type-heading">Appearance</h2>
+
+          <div className="space-y-3">
+            <label className="block type-label">Theme</label>
+            {themeOptions.map((option) => (
+              <div key={option.value} className="flex items-start gap-2">
+                <input
+                  type="radio"
+                  id={`theme-${option.value}`}
+                  name="theme"
+                  value={option.value}
+                  checked={theme === option.value}
+                  onChange={() => setTheme(option.value)}
+                  className="radio"
+                />
+                <label htmlFor={`theme-${option.value}`} className="flex-1 cursor-pointer">
+                  <span className="block type-label">{option.label}</span>
+                  <span className="block type-meta">{option.description}</span>
+                </label>
+              </div>
+            ))}
+          </div>
+        </div>
+
+        <div className="space-y-4 p-6 bg-panel rounded-lg shadow-md shadow-tertiary-dark">
+          <div className="space-y-2">
+            <h2 className="type-heading">Assignment notifications</h2>
+            <p className="type-body-sm text-subtle">
+              Get push notifications when your assignments change for upcoming and ongoing
+              competitions.
+            </p>
+            <p className="type-meta">
+              Watching {notifications.watchCount} competition
+              {notifications.watchCount === 1 ? '' : 's'}.
+            </p>
+          </div>
+
+          {!user && (
+            <Button type="button" onClick={signIn}>
+              Sign in with WCA
+            </Button>
+          )}
+
+          {user && notifications.status === 'unsupported' && (
+            <p className="type-meta">This browser does not support push notifications.</p>
+          )}
+
+          {user && notifications.status === 'reauthorize' && (
+            <div className="space-y-2">
+              <p className="type-meta">Refresh your WCA authorization to enable notifications.</p>
+              <Button type="button" onClick={signIn}>
+                Continue with WCA
+              </Button>
             </div>
-          ))}
+          )}
+
+          {user && notifications.canEnable && (
+            <Button
+              type="button"
+              disabled={notifications.isSaving || isLoading}
+              onClick={() => {
+                void notifications.enable();
+              }}>
+              {notifications.isSaving ? 'Enabling...' : 'Enable assignment notifications'}
+            </Button>
+          )}
+
+          {user && notifications.canDisable && (
+            <Button
+              type="button"
+              variant="gray"
+              disabled={notifications.isSaving}
+              onClick={() => {
+                void notifications.disable();
+              }}>
+              {notifications.isSaving ? 'Disabling...' : 'Disable assignment notifications'}
+            </Button>
+          )}
+
+          {user && notifications.status === 'denied' && (
+            <p className="type-meta">Notifications are blocked in your browser settings.</p>
+          )}
+
+          {notifications.error && <p className="type-meta text-red-500">{notifications.error}</p>}
+        </div>
+
+        <div className="space-y-4 p-6 bg-panel rounded-lg shadow-md shadow-tertiary-dark">
+          <div className="space-y-2">
+            <h2 className="type-heading">Live Activities Remote</h2>
+            <p className="type-body-sm text-subtle">
+              Manage the separate session used by Live Activities remote controls.
+            </p>
+            <p className="type-meta">
+              {notifyCompRemoteAuth.isAuthenticated ? 'Signed in' : 'Not signed in'}
+            </p>
+          </div>
+
+          {notifyCompRemoteAuth.isAuthenticated && (
+            <Button type="button" variant="gray" onClick={notifyCompRemoteAuth.signOut}>
+              Sign out of Live Activities Remote
+            </Button>
+          )}
         </div>
       </div>
     </Container>
diff --git a/src/pages/User/components/CompetitionsTab.tsx b/src/pages/User/components/CompetitionsTab.tsx
new file mode 100644
index 0000000..c3187ab
--- /dev/null
+++ b/src/pages/User/components/CompetitionsTab.tsx
@@ -0,0 +1,134 @@
+import { Link } from 'react-router-dom';
+import { WcaPersonCompetition } from '@/lib/api';
+import { getPersonResultsPath } from '../userProfileData';
+
+interface CompetitionsTabProps {
+  competitions: ApiCompetition[];
+  assignmentStatus: Record<string, boolean> | undefined;
+  isCheckingAssignments: boolean;
+  pastCompetitions: WcaPersonCompetition[] | undefined;
+  isLoadingPastCompetitions: boolean;
+  wcaId?: string;
+}
+
+const formatCompetitionDates = (competition: Pick<ApiCompetition, 'start_date' | 'end_date'>) => {
+  const start = new Date(`${competition.start_date}T00:00:00`);
+  const end = new Date(`${competition.end_date}T00:00:00`);
+
+  if (competition.start_date === competition.end_date) {
+    return start.toLocaleDateString(undefined, {
+      month: 'short',
+      day: 'numeric',
+      year: 'numeric',
+    });
+  }
+
+  return `${start.toLocaleDateString(undefined, {
+    month: 'short',
+    day: 'numeric',
+  })} - ${end.toLocaleDateString(undefined, {
+    month: 'short',
+    day: 'numeric',
+    year: 'numeric',
+  })}`;
+};
+
+export function CompetitionsTab({
+  competitions,
+  assignmentStatus,
+  isCheckingAssignments,
+  pastCompetitions,
+  isLoadingPastCompetitions,
+  wcaId,
+}: CompetitionsTabProps) {
+  const visibleCompetitionIds = new Set(competitions.map((competition) => competition.id));
+  const sortedPastCompetitions = [...(pastCompetitions || [])]
+    .filter((competition) => !visibleCompetitionIds.has(competition.id))
+    .sort((a, b) => new Date(b.start_date).getTime() - new Date(a.start_date).getTime());
+
+  return (
+    <div className="space-y-4">
+      <section className="space-y-2">
+        <h2 className="type-label text-default">Upcoming competitions</h2>
+        {competitions.length === 0 ? (
+          <p className="type-body-sm text-muted">No upcoming competitions.</p>
+        ) : (
+          competitions.map((competition) => {
+            const hasAssignments = assignmentStatus?.[competition.id];
+            const statusText =
+              hasAssignments == null && isCheckingAssignments
+                ? 'Checking assignments'
+                : hasAssignments
+                  ? 'Assignments generated'
+                  : 'No assignments yet';
+
+            return (
+              <Link
+                key={competition.id}
+                to={`/competitions/${competition.id}`}
+                className="block rounded-md border border-tertiary-weak bg-panel px-3 py-2 shadow-sm hover-bg-tertiary">
+                <div className="flex items-start justify-between gap-3">
+                  <div className="min-w-0 space-y-1">
+                    <div className="type-label text-default">{competition.name}</div>
+                    <div className="type-body-sm text-subtle">
+                      {competition.city}, {competition.country_iso2} -{' '}
+                      {formatCompetitionDates(competition)}
+                    </div>
+                  </div>
+                  <span
+                    className={
+                      hasAssignments
+                        ? 'shrink-0 text-right type-body-sm text-green-600'
+                        : 'shrink-0 text-right type-body-sm text-muted'
+                    }>
+                    {statusText}
+                  </span>
+                </div>
+              </Link>
+            );
+          })
+        )}
+      </section>
+
+      <section className="space-y-2">
+        <h2 className="type-label text-default">Past competitions</h2>
+        {isLoadingPastCompetitions ? (
+          <p className="type-body-sm text-muted">Loading past competitions...</p>
+        ) : sortedPastCompetitions.length === 0 ? (
+          <p className="type-body-sm text-muted">No past competitions.</p>
+        ) : (
+          sortedPastCompetitions.map((competition) => {
+            const to = getPersonResultsPath(competition.id, wcaId);
+            const content = (
+              <div className="min-w-0 space-y-1">
+                <div className="type-label text-default">{competition.name}</div>
+                <div className="type-body-sm text-subtle">
+                  {formatCompetitionDates(competition)}
+                </div>
+              </div>
+            );
+
+            if (!to) {
+              return (
+                <div
+                  key={competition.id}
+                  className="rounded-md border border-tertiary-weak bg-panel px-3 py-2 shadow-sm">
+                  {content}
+                </div>
+              );
+            }
+
+            return (
+              <Link
+                key={competition.id}
+                to={to}
+                className="block rounded-md border border-tertiary-weak bg-panel px-3 py-2 shadow-sm hover-bg-tertiary">
+                {content}
+              </Link>
+            );
+          })
+        )}
+      </section>
+    </div>
+  );
+}
diff --git a/src/pages/User/components/ProfileHeader.tsx b/src/pages/User/components/ProfileHeader.tsx
new file mode 100644
index 0000000..9b37675
--- /dev/null
+++ b/src/pages/User/components/ProfileHeader.tsx
@@ -0,0 +1,38 @@
+import { hasFlag } from 'country-flag-icons';
+import getUnicodeFlagIcon from 'country-flag-icons/unicode';
+
+const fallbackAvatarUrl =
+  'https://assets.worldcubeassociation.org/assets/326cd49/assets/missing_avatar_thumb-d77f478a307a91a9d4a083ad197012a391d5410f6dd26cb0b0e3118a5de71438.png';
+
+interface ProfileHeaderProps {
+  countryIso2?: string;
+  user: User;
+}
+
+export function ProfileHeader({ countryIso2, user }: ProfileHeaderProps) {
+  const avatarUrl = user.avatar?.thumb_url || user.avatar?.url || fallbackAvatarUrl;
+
+  return (
+    <div className="flex px-1 space-x-1">
+      <a
+        href={`https://worldcubeassociation.org/persons/${user.wca_id}`}
+        target="_blank"
+        rel="noreferrer">
+        <img src={avatarUrl} alt={user.name} className="object-contain w-24 h-24" />
+      </a>
+      <div className="flex flex-col w-full">
+        <div className="flex items-center flex-shrink w-full space-x-1">
+          <h3 className="type-heading sm:type-title">{user.name}</h3>
+        </div>
+        <div className="flex space-x-1 align-center">
+          {countryIso2 && hasFlag(countryIso2) && (
+            <div className="flex flex-shrink type-body sm:type-heading">
+              {getUnicodeFlagIcon(countryIso2)}
+            </div>
+          )}
+          {user.wca_id && <span className="my-1 type-body-sm">{user.wca_id}</span>}
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/src/pages/User/components/ProfileTabs.tsx b/src/pages/User/components/ProfileTabs.tsx
new file mode 100644
index 0000000..823bfee
--- /dev/null
+++ b/src/pages/User/components/ProfileTabs.tsx
@@ -0,0 +1,42 @@
+import classNames from 'classnames';
+import { Link } from 'react-router-dom';
+import { UserPageTab } from '../userProfileData';
+
+interface ProfileTabsProps {
+  activeTab: UserPageTab;
+}
+
+const tabs: { id: UserPageTab; label: string }[] = [
+  { id: 'competitions', label: 'Competitions' },
+  { id: 'results', label: 'Results' },
+  { id: 'records', label: 'Records' },
+];
+
+const tabPath = (tab: UserPageTab) => `/me/${tab}`;
+
+export function ProfileTabs({ activeTab }: ProfileTabsProps) {
+  return (
+    <nav className="overflow-hidden rounded-md border border-tertiary-weak bg-panel shadow-sm">
+      <div className="grid grid-flow-col auto-cols-fr">
+        {tabs.map((tab) => {
+          const isActive = tab.id === activeTab;
+
+          return (
+            <Link
+              key={tab.id}
+              to={tabPath(tab.id)}
+              className={classNames(
+                'flex min-h-12 items-center justify-center gap-2 border-r border-tertiary-weak px-2 py-2 text-center type-body-sm hover-transition hover:bg-gray-100 last:border-r-0 dark:hover:bg-gray-700 sm:type-body',
+                {
+                  'bg-active text-primary': isActive,
+                  'text-muted': !isActive,
+                },
+              )}>
+              <span className="truncate">{tab.label}</span>
+            </Link>
+          );
+        })}
+      </div>
+    </nav>
+  );
+}
diff --git a/src/pages/User/components/RecordsTab.tsx b/src/pages/User/components/RecordsTab.tsx
new file mode 100644
index 0000000..a466295
--- /dev/null
+++ b/src/pages/User/components/RecordsTab.tsx
@@ -0,0 +1,146 @@
+import { events } from '@/lib/events';
+import {
+  formatUserResult,
+  getUserEventName,
+  WcaPersonalRecords,
+  WcaPersonalRecord,
+} from '../userProfileData';
+
+interface RecordsTabProps {
+  records: WcaPersonalRecords | undefined;
+  isLoading: boolean;
+  error: unknown;
+}
+
+type RankingType = 'single' | 'average';
+
+const eventOrder = new Map<string, number>(events.map((event, index) => [event.id, index]));
+
+const rankValue = (rank: number | undefined) => (rank ? rank.toLocaleString() : '-');
+
+const resultValue = (
+  eventId: string,
+  rankingType: RankingType,
+  record: WcaPersonalRecord | undefined,
+) => formatUserResult(eventId, rankingType, record?.best);
+
+export function RecordsTab({ records, isLoading, error }: RecordsTabProps) {
+  if (isLoading) {
+    return <p className="type-body-sm text-muted">Loading records...</p>;
+  }
+
+  if (error) {
+    return <p className="type-body-sm text-red-600">Unable to load records.</p>;
+  }
+
+  const entries = Object.entries(records || {}).sort(([a], [b]) => {
+    const eventOrderDifference =
+      (eventOrder.get(a) ?? Number.MAX_SAFE_INTEGER) -
+      (eventOrder.get(b) ?? Number.MAX_SAFE_INTEGER);
+
+    return eventOrderDifference || getUserEventName(a).localeCompare(getUserEventName(b));
+  });
+
+  if (entries.length === 0) {
+    return <p className="type-body-sm text-muted">No records available.</p>;
+  }
+
+  return (
+    <div>
+      <div className="hidden overflow-hidden rounded-md border border-tertiary-weak bg-panel shadow-sm md:block">
+        <table className="w-full table-auto whitespace-nowrap type-body-sm">
+          <thead>
+            <tr className="border-b border-tertiary-weak text-left">
+              <th className="px-3 py-2 font-semibold">Event</th>
+              <th className="px-3 py-2 text-right font-semibold">Single</th>
+              <th className="px-3 py-2 text-right font-semibold text-muted">NR</th>
+              <th className="px-3 py-2 text-right font-semibold text-muted">CR</th>
+              <th className="px-3 py-2 text-right font-semibold text-muted">WR</th>
+              <th className="px-3 py-2 text-right font-semibold">Average</th>
+              <th className="px-3 py-2 text-right font-semibold text-muted">WR</th>
+              <th className="px-3 py-2 text-right font-semibold text-muted">CR</th>
+              <th className="px-3 py-2 text-right font-semibold text-muted">NR</th>
+            </tr>
+          </thead>
+          <tbody>
+            {entries.map(([eventId, record]) => (
+              <tr
+                key={eventId}
+                className="border-b border-tertiary-weak odd:bg-tertiary last:border-b-0">
+                <td className="px-3 py-2 font-medium">
+                  <span className={`cubing-icon event-${eventId} mr-2`} aria-hidden="true" />
+                  {getUserEventName(eventId)}
+                </td>
+                <td className="px-3 py-2 text-right font-semibold">
+                  {resultValue(eventId, 'single', record.single)}
+                </td>
+                <td className="px-3 py-2 text-right text-muted">
+                  {rankValue(record.single?.country_rank)}
+                </td>
+                <td className="px-3 py-2 text-right text-muted">
+                  {rankValue(record.single?.continent_rank)}
+                </td>
+                <td className="px-3 py-2 text-right text-muted">
+                  {rankValue(record.single?.world_rank)}
+                </td>
+                <td className="px-3 py-2 text-right font-semibold">
+                  {resultValue(eventId, 'average', record.average)}
+                </td>
+                <td className="px-3 py-2 text-right text-muted">
+                  {rankValue(record.average?.world_rank)}
+                </td>
+                <td className="px-3 py-2 text-right text-muted">
+                  {rankValue(record.average?.continent_rank)}
+                </td>
+                <td className="px-3 py-2 text-right text-muted">
+                  {rankValue(record.average?.country_rank)}
+                </td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      </div>
+
+      <div className="space-y-2 md:hidden">
+        {entries.map(([eventId, record]) => (
+          <div
+            key={eventId}
+            className="rounded-md border border-tertiary-weak bg-panel px-3 py-2 shadow-sm">
+            <div className="space-y-2">
+              <div className="type-label text-default">
+                <span className={`cubing-icon event-${eventId} mr-2`} aria-hidden="true" />
+                {getUserEventName(eventId)}
+              </div>
+
+              <div className="grid grid-cols-[auto_1fr] gap-x-3 gap-y-2 type-body-sm">
+                <div className="font-semibold text-muted">Single</div>
+                <div className="min-w-0">
+                  <div className="font-semibold text-default">
+                    {resultValue(eventId, 'single', record.single)}
+                  </div>
+                  <div className="text-muted">
+                    NR {rankValue(record.single?.country_rank)} / CR{' '}
+                    {rankValue(record.single?.continent_rank)} / WR{' '}
+                    {rankValue(record.single?.world_rank)}
+                  </div>
+                </div>
+
+                <div className="font-semibold text-muted">Average</div>
+                <div className="min-w-0">
+                  <div className="font-semibold text-default">
+                    {resultValue(eventId, 'average', record.average)}
+                  </div>
+                  <div className="text-muted">
+                    NR {rankValue(record.average?.country_rank)} / CR{' '}
+                    {rankValue(record.average?.continent_rank)} / WR{' '}
+                    {rankValue(record.average?.world_rank)}
+                  </div>
+                </div>
+              </div>
+            </div>
+          </div>
+        ))}
+      </div>
+    </div>
+  );
+}
diff --git a/src/pages/User/components/ResultsTab.tsx b/src/pages/User/components/ResultsTab.tsx
new file mode 100644
index 0000000..b627890
--- /dev/null
+++ b/src/pages/User/components/ResultsTab.tsx
@@ -0,0 +1,163 @@
+import classNames from 'classnames';
+import { useEffect, useMemo, useState } from 'react';
+import { Link } from 'react-router-dom';
+import { WcaCompetitionResult } from '@/lib/api';
+import {
+  compareUserResultsByNewest,
+  formatUserResult,
+  getEventResultSummaries,
+  getHistoricalPrFlags,
+  getPersonResultsPath,
+  getRoundTypeName,
+  getUserEventName,
+} from '../userProfileData';
+
+interface ResultsTabProps {
+  results: WcaCompetitionResult[] | undefined;
+  isLoading: boolean;
+  error: unknown;
+  wcaId?: string;
+}
+
+function EventIconPicker({
+  eventIds,
+  selectedEventId,
+  onSelect,
+}: {
+  eventIds: string[];
+  selectedEventId: string;
+  onSelect: (eventId: string) => void;
+}) {
+  return (
+    <div className="flex flex-wrap items-center justify-center gap-2">
+      {eventIds.map((eventId) => {
+        const isSelected = eventId === selectedEventId;
+
+        return (
+          <button
+            key={eventId}
+            type="button"
+            className={classNames(
+              'flex h-10 w-10 items-center justify-center rounded-md text-3xl hover-bg-tertiary',
+              {
+                'bg-tertiary-strong text-default': isSelected,
+                'text-muted opacity-50': !isSelected,
+              },
+            )}
+            title={getUserEventName(eventId)}
+            onClick={() => onSelect(eventId)}>
+            <span className={`cubing-icon event-${eventId}`} aria-hidden="true" />
+            <span className="sr-only">{getUserEventName(eventId)}</span>
+          </button>
+        );
+      })}
+    </div>
+  );
+}
+
+export function ResultsTab({ results, isLoading, error, wcaId }: ResultsTabProps) {
+  const eventSummaries = useMemo(() => getEventResultSummaries(results || []), [results]);
+  const eventIds = useMemo(
+    () => eventSummaries.map((summary) => summary.eventId),
+    [eventSummaries],
+  );
+  const [selectedEventId, setSelectedEventId] = useState<string>('');
+
+  useEffect(() => {
+    if (eventIds.length === 0) {
+      return;
+    }
+
+    if (!selectedEventId || !eventIds.includes(selectedEventId)) {
+      setSelectedEventId(eventIds[0]);
+    }
+  }, [eventIds, selectedEventId]);
+
+  if (isLoading) {
+    return <p className="type-body-sm text-muted">Loading results...</p>;
+  }
+
+  if (error) {
+    return <p className="type-body-sm text-red-600">Unable to load results.</p>;
+  }
+
+  if (!results || results.length === 0) {
+    return <p className="type-body-sm text-muted">No results available.</p>;
+  }
+
+  const selectedEventResults = [...results]
+    .filter((result) => result.event_id === selectedEventId)
+    .sort(compareUserResultsByNewest);
+  const historicalPrFlags = getHistoricalPrFlags(selectedEventResults);
+  const selectedEventName = selectedEventId ? getUserEventName(selectedEventId) : '';
+
+  return (
+    <div className="space-y-3">
+      <EventIconPicker
+        eventIds={eventIds}
+        selectedEventId={selectedEventId}
+        onSelect={setSelectedEventId}
+      />
+
+      {selectedEventId && (
+        <div className="overflow-x-auto rounded-md border border-tertiary-weak bg-panel shadow-sm">
+          <table className="w-full table-auto whitespace-nowrap type-body-sm">
+            <thead>
+              <tr className="border-b border-tertiary-weak text-left">
+                <th className="px-3 py-2 font-semibold">Competition</th>
+                <th className="px-3 py-2 font-semibold">Round</th>
+                <th className="px-3 py-2 text-right font-semibold">Place</th>
+                <th className="px-3 py-2 text-right font-semibold">Single</th>
+                <th className="px-3 py-2 text-right font-semibold">Average</th>
+              </tr>
+            </thead>
+            <tbody>
+              <tr className="border-b border-tertiary-weak bg-tertiary">
+                <td className="px-3 py-2 font-semibold" colSpan={5}>
+                  <span className={`cubing-icon event-${selectedEventId} mr-2`} />
+                  {selectedEventName}
+                </td>
+              </tr>
+              {selectedEventResults.map((result) => {
+                const to = getPersonResultsPath(result.competition_id, wcaId);
+                const prFlags = historicalPrFlags[result.id];
+
+                return (
+                  <tr
+                    key={result.id}
+                    className="border-b border-tertiary-weak odd:bg-tertiary last:border-b-0">
+                    <td className="px-3 py-2">
+                      {to ? (
+                        <Link className="link-inline" to={to}>
+                          {result.competition_id}
+                        </Link>
+                      ) : (
+                        result.competition_id
+                      )}
+                    </td>
+                    <td className="px-3 py-2">{getRoundTypeName(result.round_type_id)}</td>
+                    <td className="px-3 py-2 text-right">{result.pos}</td>
+                    <td
+                      className={classNames('px-3 py-2 text-right font-semibold', {
+                        'text-primary': prFlags?.single,
+                      })}
+                      title={prFlags?.single ? 'Personal record single' : undefined}>
+                      {formatUserResult(result.event_id, 'single', result.best)}
+                    </td>
+                    <td
+                      className={classNames('px-3 py-2 text-right', {
+                        'font-semibold text-primary': prFlags?.average,
+                      })}
+                      title={prFlags?.average ? 'Personal record average' : undefined}>
+                      {formatUserResult(result.event_id, 'average', result.average)}
+                    </td>
+                  </tr>
+                );
+              })}
+            </tbody>
+          </table>
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/src/pages/User/index.stories.tsx b/src/pages/User/index.stories.tsx
new file mode 100644
index 0000000..fcc06b0
--- /dev/null
+++ b/src/pages/User/index.stories.tsx
@@ -0,0 +1,150 @@
+import type { Meta, StoryObj } from '@storybook/react';
+import { QueryClient } from '@tanstack/react-query';
+import { WcaCompetitionResult, WcaPersonCompetition } from '@/lib/api';
+import {
+  makeAppContainerDecorator,
+  storybookAppUser,
+  storybookUserCompetitions,
+} from '@/storybook/appStorybook';
+import UserPage from './index';
+import { WcaPersonResponse } from './userProfileData';
+
+const profile: WcaPersonResponse = {
+  person: {
+    country_iso2: 'US',
+  },
+  personal_records: {
+    '333': {
+      single: {
+        best: 486,
+        world_rank: 236,
+        continent_rank: 62,
+        country_rank: 53,
+      },
+      average: {
+        best: 675,
+        world_rank: 360,
+        continent_rank: 99,
+        country_rank: 83,
+      },
+    },
+    '222': {
+      single: {
+        best: 91,
+        world_rank: 693,
+        continent_rank: 194,
+        country_rank: 151,
+      },
+    },
+  },
+};
+
+const results: WcaCompetitionResult[] = [
+  {
+    id: 1,
+    pos: 5,
+    best: 958,
+    average: 1108,
+    name: storybookAppUser.name,
+    country_iso2: 'US',
+    competition_id: 'LakewoodSpring2026',
+    event_id: '333',
+    round_type_id: '1',
+    format_id: 'a',
+    wca_id: storybookAppUser.wca_id,
+    attempts: [],
+  },
+  {
+    id: 2,
+    pos: 3,
+    best: 91,
+    average: 218,
+    name: storybookAppUser.name,
+    country_iso2: 'US',
+    competition_id: 'LakewoodSpring2026',
+    event_id: '222',
+    round_type_id: 'f',
+    format_id: 'a',
+    wca_id: storybookAppUser.wca_id,
+    attempts: [],
+  },
+];
+
+const pastCompetitions: WcaPersonCompetition[] = [
+  {
+    id: 'LakewoodSpring2026',
+    name: 'Lakewood Spring 2026',
+    short_name: 'Lakewood Spring 2026',
+    city: 'Lakewood, Washington',
+    country_iso2: 'US',
+    start_date: '2026-03-14',
+    end_date: '2026-03-15',
+    announced_at: '2025-12-10T00:00:00Z',
+    cancelled_at: '',
+    latitude_degrees: 47.1718,
+    longitude_degrees: -122.5185,
+    venue_address: '5000 Steilacoom Blvd SW',
+    venue_details: '',
+    website: 'https://www.worldcubeassociation.org/competitions/LakewoodSpring2026',
+  },
+  {
+    id: 'TacomaWinter2025',
+    name: 'Tacoma Winter 2025',
+    short_name: 'Tacoma Winter 2025',
+    city: 'Tacoma, Washington',
+    country_iso2: 'US',
+    start_date: '2025-12-06',
+    end_date: '2025-12-06',
+    announced_at: '2025-08-01T00:00:00Z',
+    cancelled_at: '',
+    latitude_degrees: 47.2529,
+    longitude_degrees: -122.4443,
+    venue_address: '1500 Commerce St',
+    venue_details: '',
+    website: 'https://www.worldcubeassociation.org/competitions/TacomaWinter2025',
+  },
+];
+
+const meta = {
+  title: 'Pages/User/Profile',
+  component: UserPage,
+  decorators: [
+    makeAppContainerDecorator({
+      currentUser: storybookAppUser,
+      userCompetitions: storybookUserCompetitions,
+      configureQueryClient: (queryClient: QueryClient) => {
+        queryClient.setQueryData(['user-profile', storybookAppUser.wca_id], profile);
+        queryClient.setQueryData(['user-results', storybookAppUser.wca_id], results);
+        queryClient.setQueryData(
+          ['user-past-competitions', storybookAppUser.wca_id],
+          pastCompetitions,
+        );
+        queryClient.setQueryData(
+          [
+            'user-assignment-status',
+            storybookAppUser.id,
+            [
+              ...storybookUserCompetitions.upcoming_competitions,
+              ...storybookUserCompetitions.ongoing_competitions,
+            ]
+              .map((competition) => competition.id)
+              .join(','),
+          ],
+          {
+            PortlandAutumn2026: true,
+            SeattleSummerOpen2026: false,
+          },
+        );
+      },
+    }),
+  ],
+  parameters: {
+    layout: 'fullscreen',
+  },
+} satisfies Meta<typeof UserPage>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};
diff --git a/src/pages/User/index.tsx b/src/pages/User/index.tsx
new file mode 100644
index 0000000..5d79d59
--- /dev/null
+++ b/src/pages/User/index.tsx
@@ -0,0 +1,167 @@
+import { QueryClient, useQuery, useQueryClient } from '@tanstack/react-query';
+import { Navigate, useParams } from 'react-router-dom';
+import { Container } from '@/components';
+import { useMyCompetitionsQuery } from '@/containers/MyCompetitions/MyCompetitions.query';
+import { fetchPersonCompetitions, fetchWcif, WcaCompetitionResult, wcaApiFetch } from '@/lib/api';
+import { FIVE_MINUTES } from '@/lib/constants';
+import { useAuth } from '@/providers/AuthProvider';
+import { CompetitionsTab } from './components/CompetitionsTab';
+import { ProfileHeader } from './components/ProfileHeader';
+import { ProfileTabs } from './components/ProfileTabs';
+import { RecordsTab } from './components/RecordsTab';
+import { ResultsTab } from './components/ResultsTab';
+import { getPersonalRecords, UserPageTab, WcaPersonResponse } from './userProfileData';
+
+const isUserPageTab = (tab: string | undefined): tab is UserPageTab =>
+  tab === 'competitions' || tab === 'results' || tab === 'records';
+
+const ONE_HOUR = 60 * 60 * 1000;
+const ONE_DAY = 24 * ONE_HOUR;
+
+const getAssignmentStatus = async (
+  competitions: ApiCompetition[],
+  userId: number,
+  queryClient: QueryClient,
+) => {
+  const statuses = await Promise.all(
+    competitions.map(async (competition) => {
+      try {
+        const wcif = await queryClient.fetchQuery({
+          queryKey: ['wcif', competition.id],
+          queryFn: () => fetchWcif(competition.id),
+          staleTime: FIVE_MINUTES,
+          gcTime: ONE_DAY,
+        });
+        const person = wcif.persons.find((p) => p.wcaUserId === userId);
+
+        return {
+          competitionId: competition.id,
+          hasAssignments: (person?.assignments?.length || 0) > 0,
+        };
+      } catch {
+        return {
+          competitionId: competition.id,
+          hasAssignments: false,
+        };
+      }
+    }),
+  );
+
+  return statuses.reduce<Record<string, boolean>>((acc, status) => {
+    acc[status.competitionId] = status.hasAssignments;
+    return acc;
+  }, {});
+};
+
+export default function UserPage() {
+  const { tab: tabParam, resultsMode: resultsModeParam } = useParams<{
+    tab?: string;
+    resultsMode?: string;
+  }>();
+  const { user } = useAuth();
+  const queryClient = useQueryClient();
+  const tab = tabParam || 'competitions';
+  const isCompetitionsTab = tab === 'competitions';
+  const isResultsTab = tab === 'results';
+  const isRecordsTab = tab === 'records';
+  const { competitions, isLoading: isLoadingCompetitions } = useMyCompetitionsQuery(user?.id, {
+    enabled: isCompetitionsTab,
+  });
+  const competitionIds = competitions.map((competition) => competition.id).join(',');
+
+  const assignmentStatusQuery = useQuery({
+    queryKey: ['user-assignment-status', user?.id, competitionIds],
+    enabled: Boolean(isCompetitionsTab && user?.id && competitions.length > 0),
+    queryFn: () => getAssignmentStatus(competitions, user!.id, queryClient),
+    staleTime: FIVE_MINUTES,
+  });
+
+  const resultsQuery = useQuery({
+    queryKey: ['user-results', user?.wca_id],
+    enabled: Boolean(isResultsTab && user?.wca_id),
+    queryFn: () => wcaApiFetch<WcaCompetitionResult[]>(`/persons/${user!.wca_id}/results`),
+    staleTime: ONE_HOUR,
+    gcTime: ONE_DAY,
+  });
+
+  const pastCompetitionsQuery = useQuery({
+    queryKey: ['user-past-competitions', user?.wca_id],
+    enabled: Boolean(isCompetitionsTab && user?.wca_id),
+    queryFn: () => fetchPersonCompetitions(user!.wca_id),
+    staleTime: ONE_DAY,
+    gcTime: ONE_DAY,
+  });
+
+  const recordsQuery = useQuery({
+    queryKey: ['user-profile', user?.wca_id],
+    enabled: Boolean(user?.wca_id),
+    queryFn: () => wcaApiFetch<WcaPersonResponse>(`/persons/${user!.wca_id}`),
+    staleTime: isRecordsTab ? ONE_HOUR : ONE_DAY,
+    gcTime: ONE_DAY,
+  });
+
+  if (!isUserPageTab(tab)) {
+    return <Navigate to="/me/competitions" replace />;
+  }
+
+  if (tab !== 'results' && resultsModeParam) {
+    return <Navigate to={`/me/${tab}`} replace />;
+  }
+
+  if (tab === 'results' && resultsModeParam) {
+    return <Navigate to="/me/results" replace />;
+  }
+
+  if (!user) {
+    return (
+      <div className="flex min-h-0 w-full flex-1 justify-center overflow-y-auto">
+        <Container className="px-4 py-8">
+          <p className="type-body">Please log in to view your profile.</p>
+        </Container>
+      </div>
+    );
+  }
+
+  return (
+    <div className="flex min-h-0 w-full flex-1 justify-center overflow-y-auto">
+      <Container className="space-y-4 p-2 pt-4">
+        <ProfileHeader countryIso2={recordsQuery.data?.person.country_iso2} user={user} />
+        <ProfileTabs activeTab={tab} />
+
+        {tab === 'competitions' && (
+          <>
+            {isLoadingCompetitions ? (
+              <p className="type-body-sm text-muted">Loading competitions...</p>
+            ) : (
+              <CompetitionsTab
+                competitions={competitions}
+                assignmentStatus={assignmentStatusQuery.data}
+                isCheckingAssignments={assignmentStatusQuery.isLoading}
+                pastCompetitions={pastCompetitionsQuery.data}
+                isLoadingPastCompetitions={pastCompetitionsQuery.isLoading}
+                wcaId={user.wca_id}
+              />
+            )}
+          </>
+        )}
+
+        {tab === 'results' && (
+          <ResultsTab
+            results={resultsQuery.data}
+            isLoading={resultsQuery.isLoading}
+            error={resultsQuery.error}
+            wcaId={user.wca_id}
+          />
+        )}
+
+        {tab === 'records' && (
+          <RecordsTab
+            records={getPersonalRecords(recordsQuery.data)}
+            isLoading={recordsQuery.isLoading}
+            error={recordsQuery.error}
+          />
+        )}
+      </Container>
+    </div>
+  );
+}
diff --git a/src/pages/User/userProfileData.test.ts b/src/pages/User/userProfileData.test.ts
new file mode 100644
index 0000000..c64e499
--- /dev/null
+++ b/src/pages/User/userProfileData.test.ts
@@ -0,0 +1,185 @@
+import { WcaCompetitionResult } from '@/lib/api';
+import {
+  compareUserResultsByNewest,
+  formatUserResult,
+  getCompetitionResultSummaries,
+  getEventResultSummaries,
+  getHistoricalPrFlags,
+  getPersonalRecords,
+  getRoundTypeName,
+} from './userProfileData';
+
+jest.mock('@/lib/events', () => ({
+  getEventName: (eventId: string) => eventId,
+  isOfficialEventId: (eventId: string) => ['222', '333'].includes(eventId),
+  isRankedBySingle: () => false,
+}));
+
+const result = (overrides: Partial<WcaCompetitionResult>): WcaCompetitionResult => ({
+  id: 1,
+  pos: 1,
+  best: 1000,
+  average: 1200,
+  name: 'Test User',
+  country_iso2: 'US',
+  competition_id: 'TestComp2026',
+  event_id: '333',
+  round_type_id: 'f',
+  format_id: 'a',
+  wca_id: '2010TEST01',
+  attempts: [],
+  ...overrides,
+});
+
+describe('userProfileData', () => {
+  describe('getCompetitionResultSummaries', () => {
+    it('aggregates results by competition', () => {
+      const summaries = getCompetitionResultSummaries([
+        result({ competition_id: 'Alpha2026', event_id: '333', best: 1200, average: 1300 }),
+        result({ competition_id: 'Alpha2026', event_id: '222', best: 300, average: 360 }),
+        result({ competition_id: 'Beta2026', event_id: '333', best: 1000 }),
+      ]);
+
+      expect(summaries).toEqual([
+        expect.objectContaining({
+          competitionId: 'Alpha2026',
+          roundCount: 2,
+          eventCount: 2,
+        }),
+        expect.objectContaining({
+          competitionId: 'Beta2026',
+          roundCount: 1,
+          eventCount: 1,
+        }),
+      ]);
+      expect(summaries[0].bestResult.event_id).toBe('222');
+    });
+  });
+
+  describe('getEventResultSummaries', () => {
+    it('aggregates results by event', () => {
+      const summaries = getEventResultSummaries([
+        result({ competition_id: 'Alpha2026', event_id: '333', best: 1200, average: 1400 }),
+        result({ competition_id: 'Beta2026', event_id: '333', best: 1000, average: 1300 }),
+        result({ competition_id: 'Beta2026', event_id: '222', best: 280, average: 360 }),
+      ]);
+
+      expect(summaries).toEqual([
+        expect.objectContaining({
+          eventId: '222',
+          roundCount: 1,
+          competitionCount: 1,
+          bestSingle: 280,
+          bestAverage: 360,
+        }),
+        expect.objectContaining({
+          eventId: '333',
+          roundCount: 2,
+          competitionCount: 2,
+          bestSingle: 1000,
+          bestAverage: 1300,
+        }),
+      ]);
+    });
+  });
+
+  describe('formatUserResult', () => {
+    it('formats timed results and missing results', () => {
+      expect(formatUserResult('333', 'single', 1234)).toBe('12.34');
+      expect(formatUserResult('333', 'average', 0)).toBe('-');
+    });
+  });
+
+  describe('getRoundTypeName', () => {
+    it('formats WCA round type ids', () => {
+      expect(getRoundTypeName('1')).toBe('First round');
+      expect(getRoundTypeName('f')).toBe('Final');
+    });
+  });
+
+  describe('compareUserResultsByNewest', () => {
+    it('sorts newer competition ids first', () => {
+      const sorted = [
+        result({ competition_id: 'Alpha2025' }),
+        result({ competition_id: 'Beta2026' }),
+      ].sort(compareUserResultsByNewest);
+
+      expect(sorted.map((item) => item.competition_id)).toEqual(['Beta2026', 'Alpha2025']);
+    });
+  });
+
+  describe('getHistoricalPrFlags', () => {
+    it('flags singles and averages when they become new personal records', () => {
+      const flags = getHistoricalPrFlags([
+        result({ id: 4, competition_id: 'Delta2026', round_type_id: '1', best: 1100, average: 0 }),
+        result({
+          id: 2,
+          competition_id: 'Beta2025',
+          round_type_id: '1',
+          best: 1200,
+          average: 1400,
+        }),
+        result({
+          id: 3,
+          competition_id: 'Charlie2025',
+          round_type_id: '1',
+          best: 1300,
+          average: 1300,
+        }),
+        result({
+          id: 1,
+          competition_id: 'Alpha2025',
+          round_type_id: '1',
+          best: 1500,
+          average: 1600,
+        }),
+      ]);
+
+      expect(flags).toEqual({
+        1: { single: true, average: true },
+        2: { single: true, average: true },
+        3: { single: false, average: true },
+        4: { single: true, average: false },
+      });
+    });
+  });
+
+  describe('getPersonalRecords', () => {
+    it('returns top-level records from the WCA person response', () => {
+      expect(
+        getPersonalRecords({
+          person: {},
+          personal_records: {
+            '333': {
+              single: {
+                best: 1000,
+                world_rank: 1,
+                continent_rank: 1,
+                country_rank: 1,
+              },
+            },
+          },
+        }),
+      ).toHaveProperty('333');
+    });
+
+    it('falls back to nested records for seeded data', () => {
+      expect(
+        getPersonalRecords({
+          person: {
+            personal_records: {
+              '222': {
+                single: {
+                  best: 200,
+                  world_rank: 2,
+                  continent_rank: 2,
+                  country_rank: 2,
+                },
+              },
+            },
+          },
+        }),
+      ).toHaveProperty('222');
+    });
+  });
+});
diff --git a/src/pages/User/userProfileData.ts b/src/pages/User/userProfileData.ts
new file mode 100644
index 0000000..bdc9019
--- /dev/null
+++ b/src/pages/User/userProfileData.ts
@@ -0,0 +1,255 @@
+import { EventId, RankingType, AttemptResult } from '@wca/helpers';
+import { WcaCompetitionResult } from '@/lib/api';
+import { getEventName, isOfficialEventId, isRankedBySingle } from '@/lib/events';
+import { renderCentiseconds, renderResultByEventId } from '@/lib/results';
+
+export type UserPageTab = 'competitions' | 'results' | 'records';
+
+export interface WcaPersonalRecord {
+  id?: number;
+  person_id?: string;
+  event_id?: string;
+  best: number;
+  world_rank: number;
+  continent_rank: number;
+  country_rank: number;
+}
+
+export type WcaPersonalRecords = Record<
+  string,
+  {
+    single?: WcaPersonalRecord;
+    average?: WcaPersonalRecord;
+  }
+>;
+
+export interface WcaPersonResponse {
+  person: {
+    country_iso2?: string;
+    personal_records?: WcaPersonalRecords;
+  };
+  personal_records?: WcaPersonalRecords;
+}
+
+export const getPersonalRecords = (profile: WcaPersonResponse | undefined) =>
+  profile?.personal_records || profile?.person.personal_records || {};
+
+export const getPersonResultsPath = (competitionId: string, wcaId: string | undefined) =>
+  wcaId ? `/competitions/${competitionId}/persons/wca/${wcaId}/results` : undefined;
+
+export interface CompetitionResultSummary {
+  competitionId: string;
+  roundCount: number;
+  eventCount: number;
+  bestResult: WcaCompetitionResult;
+}
+
+export interface EventResultSummary {
+  eventId: string;
+  eventName: string;
+  roundCount: number;
+  competitionCount: number;
+  bestSingle: number;
+  bestAverage: number;
+}
+
+export interface HistoricalPrFlags {
+  single: boolean;
+  average: boolean;
+}
+
+const roundTypeLabels: Record<string, string> = {
+  '0': 'Qualification round',
+  '1': 'First round',
+  '2': 'Second round',
+  '3': 'Third round',
+  b: 'B Final',
+  c: 'Combined round',
+  d: 'Combined first round',
+  e: 'Combined second round',
+  f: 'Final',
+};
+
+const resultValue = (result: WcaCompetitionResult) =>
+  result.average > 0 && !isRankedBySingle(result.event_id as EventId)
+    ? result.average
+    : result.best;
+
+const compareResults = (a: WcaCompetitionResult, b: WcaCompetitionResult) => {
+  if (a.event_id === '333mbf' && b.event_id === '333mbf') {
+    return b.best - a.best;
+  }
+
+  return resultValue(a) - resultValue(b);
+};
+
+const compareAttemptResults = (eventId: string, a: number, b: number) => {
+  if (eventId === '333mbf') {
+    return b - a;
+  }
+
+  return a - b;
+};
+
+export const formatUserResult = (
+  eventId: string,
+  rankingType: RankingType,
+  value: number | undefined,
+) => {
+  if (!value || value <= 0) {
+    return '-';
+  }
+
+  if (isOfficialEventId(eventId)) {
+    return renderResultByEventId(eventId, rankingType, value as AttemptResult);
+  }
+
+  return eventId === '333fm' && rankingType === 'average'
+    ? (value / 100).toFixed(2)
+    : renderCentiseconds(value);
+};
+
+export const getUserEventName = (eventId: string) =>
+  isOfficialEventId(eventId) ? getEventName(eventId) : eventId.toUpperCase();
+
+export const getRoundTypeName = (roundTypeId: string) =>
+  roundTypeLabels[roundTypeId] ?? roundTypeId.toUpperCase();
+
+export const compareUserResultsByNewest = (a: WcaCompetitionResult, b: WcaCompetitionResult) =>
+  b.competition_id.localeCompare(a.competition_id) ||
+  a.round_type_id.localeCompare(b.round_type_id);
+
+const compareUserResultsByOldest = (a: WcaCompetitionResult, b: WcaCompetitionResult) =>
+  a.competition_id.localeCompare(b.competition_id) ||
+  a.round_type_id.localeCompare(b.round_type_id);
+
+export const getHistoricalPrFlags = (
+  results: WcaCompetitionResult[],
+): Record<number, HistoricalPrFlags> => {
+  let bestSingle = 0;
+  let bestAverage = 0;
+
+  return [...results]
+    .sort(compareUserResultsByOldest)
+    .reduce<Record<number, HistoricalPrFlags>>((acc, result) => {
+      const isSinglePr =
+        result.best > 0 &&
+        (!bestSingle || compareAttemptResults(result.event_id, result.best, bestSingle) < 0);
+      const isAveragePr =
+        result.average > 0 &&
+        (!bestAverage || compareAttemptResults(result.event_id, result.average, bestAverage) < 0);
+
+      if (isSinglePr) {
+        bestSingle = result.best;
+      }
+
+      if (isAveragePr) {
+        bestAverage = result.average;
+      }
+
+      acc[result.id] = {
+        single: isSinglePr,
+        average: isAveragePr,
+      };
+
+      return acc;
+    }, {});
+};
+
+export const getCompetitionResultSummaries = (
+  results: WcaCompetitionResult[],
+): CompetitionResultSummary[] => {
+  const summariesByCompetition = new Map<
+    string,
+    {
+      roundCount: number;
+      eventIds: Set<string>;
+      bestResult: WcaCompetitionResult;
+    }
+  >();
+
+  results.forEach((result) => {
+    const existing = summariesByCompetition.get(result.competition_id);
+
+    if (!existing) {
+      summariesByCompetition.set(result.competition_id, {
+        roundCount: 1,
+        eventIds: new Set([result.event_id]),
+        bestResult: result,
+      });
+      return;
+    }
+
+    existing.roundCount += 1;
+    existing.eventIds.add(result.event_id);
+
+    if (compareResults(result, existing.bestResult) < 0) {
+      existing.bestResult = result;
+    }
+  });
+
+  return Array.from(summariesByCompetition.entries())
+    .map(([competitionId, summary]) => ({
+      competitionId,
+      roundCount: summary.roundCount,
+      eventCount: summary.eventIds.size,
+      bestResult: summary.bestResult,
+    }))
+    .sort((a, b) => a.competitionId.localeCompare(b.competitionId));
+};
+
+export const getEventResultSummaries = (results: WcaCompetitionResult[]): EventResultSummary[] => {
+  const summariesByEvent = new Map<
+    string,
+    {
+      roundCount: number;
+      competitionIds: Set<string>;
+      bestSingle: number;
+      bestAverage: number;
+    }
+  >();
+
+  results.forEach((result) => {
+    const existing = summariesByEvent.get(result.event_id);
+
+    if (!existing) {
+      summariesByEvent.set(result.event_id, {
+        roundCount: 1,
+        competitionIds: new Set([result.competition_id]),
+        bestSingle: result.best,
+        bestAverage: result.average,
+      });
+      return;
+    }
+
+    existing.roundCount += 1;
+    existing.competitionIds.add(result.competition_id);
+
+    if (
+      result.best > 0 &&
+      (!existing.bestSingle ||
+        compareAttemptResults(result.event_id, result.best, existing.bestSingle) < 0)
+    ) {
+      existing.bestSingle = result.best;
+    }
+
+    if (
+      result.average > 0 &&
+      (!existing.bestAverage ||
+        compareAttemptResults(result.event_id, result.average, existing.bestAverage) < 0)
+    ) {
+      existing.bestAverage = result.average;
+    }
+  });
+
+  return Array.from(summariesByEvent.entries())
+    .map(([eventId, summary]) => ({
+      eventId,
+      eventName: getUserEventName(eventId),
+      roundCount: summary.roundCount,
+      competitionCount: summary.competitionIds.size,
+      bestSingle: summary.bestSingle,
+      bestAverage: summary.bestAverage,
+    }))
+    .sort((a, b) => a.eventName.localeCompare(b.eventName));
+};
diff --git a/src/providers/AuthProvider/AuthProvider.tsx b/src/providers/AuthProvider/AuthProvider.tsx
index 6b86372..e46ac1c 100644
--- a/src/providers/AuthProvider/AuthProvider.tsx
+++ b/src/providers/AuthProvider/AuthProvider.tsx
@@ -49,21 +49,22 @@ export function AuthProvider({ children }: PropsWithChildren) {
     localStorage.removeItem(localStorageKey('user'));
     localStorage.removeItem(localStorageKey('my.upcoming_competitions'));
     localStorage.removeItem(localStorageKey('my.ongoing_competitions'));
+    queryClient.removeQueries({ queryKey: ['userCompetitions'] });
+    queryClient.removeQueries({ queryKey: ['user-results'] });
+    queryClient.removeQueries({ queryKey: ['user-past-competitions'] });
+    queryClient.removeQueries({ queryKey: ['user-profile'] });
+    queryClient.removeQueries({ queryKey: ['user-assignment-status'] });
   };
 
   const signInAs = useCallback(
     (userId: number) => {
-      queryClient
-        .getQueryCache()
-        .find({
-          queryKey: ['userCompetitions'],
-        })
-        ?.reset();
+      queryClient.removeQueries({ queryKey: ['userCompetitions'] });
 
       fetchUserWithCompetitions(userId.toString()).then(
         ({ user, ongoing_competitions, upcoming_competitions }) => {
           setUser(user);
-          queryClient.setQueryData(['userCompetitions'], {
+          queryClient.setQueryData(['userCompetitions', user.id], {
+            user,
             ongoing_competitions,
             upcoming_competitions,
           });
@@ -85,8 +86,14 @@ export function AuthProvider({ children }: PropsWithChildren) {
 
     fetchMe(accessToken)
       .then(({ me, ongoing_competitions, upcoming_competitions }) => {
+        setLocalStorage('accessToken', accessToken);
+        setLocalStorage(
+          'expirationTime',
+          String(Date.now() + Number(hashParams.get('expires_in') ?? 0) * 1000),
+        );
         setUserAndSave(me);
-        queryClient.setQueryData(['userCompetitions'], {
+        queryClient.setQueryData(['userCompetitions', me.id], {
+          user: me,
           ongoing_competitions,
           upcoming_competitions,
         });
diff --git a/src/providers/ConfirmProvider/ConfirmContext.tsx b/src/providers/ConfirmProvider/ConfirmContext.tsx
new file mode 100644
index 0000000..ce05c69
--- /dev/null
+++ b/src/providers/ConfirmProvider/ConfirmContext.tsx
@@ -0,0 +1,16 @@
+import { createContext, ReactNode, useContext } from 'react';
+import { ButtonVariant } from '@/components/Button';
+
+export interface ConfirmOptions {
+  cancelLabel?: string;
+  confirmLabel?: string;
+  confirmVariant?: ButtonVariant;
+  message: ReactNode;
+  title?: string;
+}
+
+export type ConfirmFn = (options: ConfirmOptions | string) => Promise<boolean>;
+
+export const ConfirmContext = createContext<ConfirmFn>(async () => false);
+
+export const useConfirm = () => useContext(ConfirmContext);
diff --git a/src/providers/ConfirmProvider/ConfirmDialog.tsx b/src/providers/ConfirmProvider/ConfirmDialog.tsx
new file mode 100644
index 0000000..d826de4
--- /dev/null
+++ b/src/providers/ConfirmProvider/ConfirmDialog.tsx
@@ -0,0 +1,55 @@
+import { ReactNode, useEffect } from 'react';
+import { Button } from '@/components/Button';
+import { ButtonVariant } from '@/components/Button';
+
+export interface ConfirmDialogOptions {
+  cancelLabel: string;
+  confirmLabel: string;
+  confirmVariant: ButtonVariant;
+  message: ReactNode;
+  title: string;
+}
+
+interface ConfirmDialogProps {
+  onCancel: () => void;
+  onConfirm: () => void;
+  options: ConfirmDialogOptions;
+}
+
+export function ConfirmDialog({ onCancel, onConfirm, options }: ConfirmDialogProps) {
+  useEffect(() => {
+    const handleKeydown = (event: KeyboardEvent) => {
+      if (event.key === 'Escape') {
+        onCancel();
+      }
+    };
+
+    document.addEventListener('keydown', handleKeydown);
+
+    return () => {
+      document.removeEventListener('keydown', handleKeydown);
+    };
+  }, [onCancel]);
+
+  return (
+    <div
+      aria-modal="true"
+      className="fixed inset-0 z-50 flex items-center justify-center bg-black/50 p-4"
+      role="dialog">
+      <div className="w-full max-w-xl space-y-6 rounded-md bg-panel p-6 shadow-xl">
+        <h2 className="type-heading">{options.title}</h2>
+
+        <div className="type-body">{options.message}</div>
+
+        <div className="flex justify-end gap-4">
+          <Button type="button" variant="light" onClick={onCancel}>
+            {options.cancelLabel}
+          </Button>
+          <Button type="button" variant={options.confirmVariant} onClick={onConfirm}>
+            {options.confirmLabel}
+          </Button>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/src/providers/ConfirmProvider/ConfirmProvider.test.tsx b/src/providers/ConfirmProvider/ConfirmProvider.test.tsx
new file mode 100644
index 0000000..09688e6
--- /dev/null
+++ b/src/providers/ConfirmProvider/ConfirmProvider.test.tsx
@@ -0,0 +1,65 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import { useState } from 'react';
+import { useConfirm } from './ConfirmContext';
+import { ConfirmProvider } from './ConfirmProvider';
+
+function ConfirmConsumer() {
+  const confirm = useConfirm();
+  const [result, setResult] = useState<string>('pending');
+
+  return (
+    <>
+      <button
+        type="button"
+        onClick={() => {
+          void (async () => {
+            setResult((await confirm('Continue?')) ? 'confirmed' : 'cancelled');
+          })();
+        }}>
+        Open confirm
+      </button>
+      <span>{result}</span>
+    </>
+  );
+}
+
+describe('ConfirmProvider', () => {
+  it('resolves true when the user confirms', async () => {
+    render(
+      <ConfirmProvider>
+        <ConfirmConsumer />
+      </ConfirmProvider>,
+    );
+
+    fireEvent.click(screen.getByRole('button', { name: 'Open confirm' }));
+    fireEvent.click(screen.getByRole('button', { name: 'Confirm' }));
+
+    expect(await screen.findByText('confirmed')).toBeInTheDocument();
+  });
+
+  it('resolves false when the user cancels', async () => {
+    render(
+      <ConfirmProvider>
+        <ConfirmConsumer />
+      </ConfirmProvider>,
+    );
+
+    fireEvent.click(screen.getByRole('button', { name: 'Open confirm' }));
+    fireEvent.click(screen.getByRole('button', { name: 'Cancel' }));
+
+    expect(await screen.findByText('cancelled')).toBeInTheDocument();
+  });
+
+  it('resolves false when the user presses Escape', async () => {
+    render(
+      <ConfirmProvider>
+        <ConfirmConsumer />
+      </ConfirmProvider>,
+    );
+
+    fireEvent.click(screen.getByRole('button', { name: 'Open confirm' }));
+    fireEvent.keyDown(document, { key: 'Escape' });
+
+    expect(await screen.findByText('cancelled')).toBeInTheDocument();
+  });
+});
diff --git a/src/providers/ConfirmProvider/ConfirmProvider.tsx b/src/providers/ConfirmProvider/ConfirmProvider.tsx
new file mode 100644
index 0000000..f5067bc
--- /dev/null
+++ b/src/providers/ConfirmProvider/ConfirmProvider.tsx
@@ -0,0 +1,66 @@
+import { PropsWithChildren, useCallback, useRef, useState } from 'react';
+import { ConfirmContext, ConfirmOptions } from './ConfirmContext';
+import { ConfirmDialog, ConfirmDialogOptions } from './ConfirmDialog';
+
+interface PendingConfirm extends ConfirmDialogOptions {
+  resolve: (confirmed: boolean) => void;
+}
+
+const normalizeOptions = (options: ConfirmOptions | string): ConfirmOptions =>
+  typeof options === 'string' ? { message: options } : options;
+
+export function ConfirmProvider({ children }: PropsWithChildren) {
+  const [pendingConfirm, setPendingConfirm] = useState<PendingConfirm | null>(null);
+  const pendingConfirmRef = useRef<PendingConfirm | null>(null);
+  const confirmQueueRef = useRef<PendingConfirm[]>([]);
+
+  const confirm = useCallback((rawOptions: ConfirmOptions | string) => {
+    const options = normalizeOptions(rawOptions);
+
+    return new Promise<boolean>((resolve) => {
+      const nextConfirm = {
+        cancelLabel: options.cancelLabel || 'Cancel',
+        confirmLabel: options.confirmLabel || 'Confirm',
+        confirmVariant: options.confirmVariant || 'blue',
+        message: options.message,
+        resolve,
+        title: options.title || 'Are you sure?',
+      };
+
+      if (pendingConfirmRef.current) {
+        confirmQueueRef.current.push(nextConfirm);
+        return;
+      }
+
+      pendingConfirmRef.current = nextConfirm;
+      setPendingConfirm(nextConfirm);
+    });
+  }, []);
+
+  const close = (confirmed: boolean) => {
+    const currentConfirm = pendingConfirmRef.current;
+    if (!currentConfirm) {
+      return;
+    }
+
+    currentConfirm.resolve(confirmed);
+
+    const nextConfirm = confirmQueueRef.current.shift() || null;
+    pendingConfirmRef.current = nextConfirm;
+    setPendingConfirm(nextConfirm);
+  };
+
+  return (
+    <ConfirmContext.Provider value={confirm}>
+      {children}
+
+      {pendingConfirm && (
+        <ConfirmDialog
+          options={pendingConfirm}
+          onCancel={() => close(false)}
+          onConfirm={() => close(true)}
+        />
+      )}
+    </ConfirmContext.Provider>
+  );
+}
diff --git a/src/providers/ConfirmProvider/index.ts b/src/providers/ConfirmProvider/index.ts
new file mode 100644
index 0000000..a743384
--- /dev/null
+++ b/src/providers/ConfirmProvider/index.ts
@@ -0,0 +1,2 @@
+export * from './ConfirmContext';
+export * from './ConfirmProvider';
diff --git a/src/providers/NotifyCompRemoteAuthProvider/NotifyCompRemoteAuthContext.tsx b/src/providers/NotifyCompRemoteAuthProvider/NotifyCompRemoteAuthContext.tsx
new file mode 100644
index 0000000..0040c23
--- /dev/null
+++ b/src/providers/NotifyCompRemoteAuthProvider/NotifyCompRemoteAuthContext.tsx
@@ -0,0 +1,26 @@
+import { createContext, useContext } from 'react';
+
+export interface NotifyCompRemoteAuthContextValue {
+  authenticating: boolean;
+  error: string | null;
+  /**
+   * Remote sign-in is app-wide; the competition-specific access check lives in
+   * useCompetitionRemoteControl.
+   */
+  isAuthenticatedForCompetition: (competitionId: string) => boolean;
+  isAuthenticated: boolean;
+  signIn: (competitionId: string) => Promise<void>;
+  signOut: () => void;
+  userName?: string;
+}
+
+export const NotifyCompRemoteAuthContext = createContext<NotifyCompRemoteAuthContextValue>({
+  authenticating: false,
+  error: null,
+  isAuthenticatedForCompetition: () => false,
+  isAuthenticated: false,
+  signIn: async () => {},
+  signOut: () => {},
+});
+
+export const useNotifyCompRemoteAuth = () => useContext(NotifyCompRemoteAuthContext);
diff --git a/src/providers/NotifyCompRemoteAuthProvider/NotifyCompRemoteAuthProvider.tsx b/src/providers/NotifyCompRemoteAuthProvider/NotifyCompRemoteAuthProvider.tsx
new file mode 100644
index 0000000..b58f6a4
--- /dev/null
+++ b/src/providers/NotifyCompRemoteAuthProvider/NotifyCompRemoteAuthProvider.tsx
@@ -0,0 +1,129 @@
+import { PropsWithChildren, useCallback, useEffect, useMemo, useState } from 'react';
+import { deleteLocalStorage, getLocalStorage, setLocalStorage } from '@/lib/localStorage';
+import {
+  clearNotifyCompRemoteToken,
+  getNotifyCompRemoteClaims,
+  getNotifyCompRemoteToken,
+  hasNotifyCompRemoteToken,
+  setNotifyCompRemoteToken,
+} from '@/lib/notifyCompRemoteAuth';
+import { getStoredWcaAccessToken } from '@/lib/wcaAccessToken';
+import { useAuth } from '../AuthProvider';
+import { NotifyCompRemoteAuthContext } from './NotifyCompRemoteAuthContext';
+
+const NOTIFY_COMP_TOKEN_URL = '/.netlify/functions/notify-comp-token';
+const PENDING_REMOTE_COMPETITION_ID_KEY = 'notifyComp.pendingRemoteCompetitionId';
+const REMOTE_SCOPE = 'notifycomp.remote';
+
+const readErrorMessage = async (response: Response) => {
+  const text = await response.text();
+
+  try {
+    const payload = JSON.parse(text) as { message?: string };
+    return payload.message || text;
+  } catch {
+    return text;
+  }
+};
+
+export function NotifyCompRemoteAuthProvider({ children }: PropsWithChildren) {
+  const [token, setToken] = useState(getNotifyCompRemoteToken);
+  const [authenticating, setAuthenticating] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const { signIn: signInWithWca, user } = useAuth();
+
+  const signIn = useCallback(
+    async (competitionId: string) => {
+      setError(null);
+      const accessToken = getStoredWcaAccessToken();
+
+      if (!accessToken) {
+        setLocalStorage(PENDING_REMOTE_COMPETITION_ID_KEY, competitionId);
+        signInWithWca();
+        return;
+      }
+
+      setAuthenticating(true);
+      deleteLocalStorage(PENDING_REMOTE_COMPETITION_ID_KEY);
+
+      try {
+        const response = await fetch(NOTIFY_COMP_TOKEN_URL, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({
+            accessToken,
+            competitionId,
+            scope: REMOTE_SCOPE,
+          }),
+        });
+
+        if (!response.ok) {
+          throw new Error(await readErrorMessage(response));
+        }
+
+        const payload = (await response.json()) as { token?: string };
+        if (!payload.token) {
+          throw new Error('Remote token response was missing a token.');
+        }
+
+        setNotifyCompRemoteToken(payload.token);
+        setToken(payload.token);
+      } catch (err) {
+        setError(
+          err instanceof Error ? err.message : 'Unable to authorize Live Activities Remote.',
+        );
+        clearNotifyCompRemoteToken();
+        setToken(null);
+      } finally {
+        setAuthenticating(false);
+      }
+    },
+    [signInWithWca],
+  );
+
+  useEffect(() => {
+    const pendingCompetitionId = getLocalStorage(PENDING_REMOTE_COMPETITION_ID_KEY);
+    if (!pendingCompetitionId || authenticating || !user) {
+      return;
+    }
+
+    if (hasNotifyCompRemoteToken()) {
+      deleteLocalStorage(PENDING_REMOTE_COMPETITION_ID_KEY);
+      return;
+    }
+
+    if (!getStoredWcaAccessToken()) {
+      return;
+    }
+
+    void signIn(pendingCompetitionId);
+  }, [authenticating, signIn, user]);
+
+  const signOut = useCallback(() => {
+    clearNotifyCompRemoteToken();
+    setToken(null);
+  }, []);
+
+  const claims = token ? getNotifyCompRemoteClaims() : null;
+
+  const value = useMemo(
+    () => ({
+      authenticating,
+      error,
+      isAuthenticatedForCompetition: hasNotifyCompRemoteToken,
+      isAuthenticated: Boolean(token),
+      signIn,
+      signOut,
+      userName: claims?.name,
+    }),
+    [authenticating, claims?.name, error, signIn, signOut, token],
+  );
+
+  return (
+    <NotifyCompRemoteAuthContext.Provider value={value}>
+      {children}
+    </NotifyCompRemoteAuthContext.Provider>
+  );
+}
diff --git a/src/providers/NotifyCompRemoteAuthProvider/index.ts b/src/providers/NotifyCompRemoteAuthProvider/index.ts
new file mode 100644
index 0000000..69028a6
--- /dev/null
+++ b/src/providers/NotifyCompRemoteAuthProvider/index.ts
@@ -0,0 +1,2 @@
+export * from './NotifyCompRemoteAuthContext';
+export * from './NotifyCompRemoteAuthProvider';
diff --git a/src/storybook/appStorybook.tsx b/src/storybook/appStorybook.tsx
index 4ce1928..9f3bf4f 100644
--- a/src/storybook/appStorybook.tsx
+++ b/src/storybook/appStorybook.tsx
@@ -21,6 +21,7 @@ const competitionsQueryDocument = gql`
 `;
 
 interface AppStorybookOptions {
+  configureQueryClient?: (queryClient: QueryClient) => void;
   currentUser?: User | null;
   online?: boolean;
   pinnedCompetitions?: ApiCompetition[];
@@ -43,6 +44,7 @@ interface AppStorybookOptions {
 type AppStorybookParameters = AppStorybookOptions;
 
 const buildStorybookQueryClient = ({
+  configureQueryClient,
   competitionDetails,
   currentUser,
   userCompetitions,
@@ -57,7 +59,7 @@ const buildStorybookQueryClient = ({
   });
 
   if (currentUser && userCompetitions) {
-    queryClient.setQueryData(['userCompetitions'], {
+    queryClient.setQueryData(['userCompetitions', currentUser.id], {
       user: currentUser,
       upcoming_competitions: userCompetitions.upcoming_competitions,
       ongoing_competitions: userCompetitions.ongoing_competitions,
@@ -75,10 +77,13 @@ const buildStorybookQueryClient = ({
     } satisfies InfiniteData<CondensedApiCompetiton[], number>);
   }
 
+  configureQueryClient?.(queryClient);
+
   return queryClient;
 };
 
 function AppStorybookProviders({
+  configureQueryClient,
   currentUser,
   online,
   pinnedCompetitions,
@@ -92,11 +97,18 @@ function AppStorybookProviders({
     () =>
       buildStorybookQueryClient({
         competitionDetails,
+        configureQueryClient,
         currentUser,
         userCompetitions,
         upcomingCompetitionsPages,
       }),
-    [competitionDetails, currentUser, upcomingCompetitionsPages, userCompetitions],
+    [
+      competitionDetails,
+      configureQueryClient,
+      currentUser,
+      upcomingCompetitionsPages,
+      userCompetitions,
+    ],
   );
 
   const competitionMocks = useMemo(
@@ -257,6 +269,7 @@ export const storybookUpcomingCompetitionsPages: CondensedApiCompetiton[][] = [
 
 export const makeAppContainerDecorator = ({
   currentUser = storybookAppUser,
+  configureQueryClient,
   online = true,
   pinnedCompetitions = storybookPinnedCompetitions,
   competitionDetails = storybookPinnedCompetitions,
@@ -270,6 +283,7 @@ export const makeAppContainerDecorator = ({
     return (
       <AppStorybookProviders
         currentUser={parameters.currentUser ?? currentUser}
+        configureQueryClient={parameters.configureQueryClient || configureQueryClient}
         online={parameters.online ?? online}
         pinnedCompetitions={parameters.pinnedCompetitions || pinnedCompetitions}
         competitionDetails={parameters.competitionDetails || competitionDetails}
diff --git a/src/storybook/competitionFixtures.ts b/src/storybook/competitionFixtures.ts
index 178d513..044074e 100644
--- a/src/storybook/competitionFixtures.ts
+++ b/src/storybook/competitionFixtures.ts
@@ -730,3 +730,64 @@ export const makeStorybookCompetitionFixtureWithRound = (
 
   return competition;
 };
+
+export const makeStorybookCompetitionFixtureWithRoundUpdates = (
+  updates: Record<string, (round: Round) => Round>,
+): Competition => {
+  const competition = cloneCompetition(storybookCompetitionFixture);
+
+  competition.events = competition.events.map((event) => ({
+    ...event,
+    rounds: event.rounds.map((round) => updates[round.id]?.(round) ?? round),
+  }));
+
+  return competition;
+};
+
+export const storybookParticipationConditionPercentFixture =
+  makeStorybookCompetitionFixtureWithRoundUpdates({
+    '333-r1': (round) => ({
+      ...round,
+      advancementCondition: null,
+    }),
+    '333-r2': (round) => ({
+      ...round,
+      advancementCondition: null,
+      participationRuleset: {
+        participationSource: {
+          type: 'round',
+          roundId: '333-r1',
+          resultCondition: {
+            type: 'percent',
+            value: 75,
+          },
+        },
+      },
+    }),
+  });
+
+export const storybookParticipationConditionLinkedRoundsFixture =
+  makeStorybookCompetitionFixtureWithRoundUpdates({
+    '333-r1': (round) => ({
+      ...round,
+      advancementCondition: null,
+    }),
+    '333-r2': (round) => ({
+      ...round,
+      advancementCondition: null,
+    }),
+    '333-r3': (round) => ({
+      ...round,
+      advancementCondition: null,
+      participationRuleset: {
+        participationSource: {
+          type: 'linkedRounds',
+          roundIds: ['333-r1', '333-r2'],
+          resultCondition: {
+            type: 'ranking',
+            value: 12,
+          },
+        },
+      },
+    }),
+  });
diff --git a/src/styles/_buttons.scss b/src/styles/_buttons.scss
index 483dc1d..85eb375 100644
--- a/src/styles/_buttons.scss
+++ b/src/styles/_buttons.scss
@@ -3,7 +3,7 @@
 @layer components {
   /* Base button styles */
   .btn {
-    @apply inline-flex gap-2 px-4 py-2 text-sm font-medium transition-colors duration-150 border rounded-md shadow-sm focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-blue-500 disabled:opacity-50 disabled:cursor-not-allowed;
+    @apply inline-flex gap-2 px-4 py-2 text-sm font-medium hover-transition border rounded-md shadow-sm focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-blue-500 disabled:opacity-50 disabled:cursor-not-allowed;
   }
 
   /* Full-width block button */
diff --git a/src/styles/_links.scss b/src/styles/_links.scss
index 29a3b4f..54bebb4 100644
--- a/src/styles/_links.scss
+++ b/src/styles/_links.scss
@@ -14,7 +14,7 @@
     ),
     'card': (
       apply:
-        'block w-full px-2 py-2 transition-colors border rounded-md bg-panel border-tertiary-weak hover:bg-gray-100 dark:hover:bg-gray-700',
+        'block w-full px-2 py-2 hover-transition border rounded-md bg-panel border-tertiary-weak hover:bg-gray-100 dark:hover:bg-gray-700',
     ),
     'external': (
       apply:
diff --git a/src/styles/_tables.scss b/src/styles/_tables.scss
index 5fe014d..c33a559 100644
--- a/src/styles/_tables.scss
+++ b/src/styles/_tables.scss
@@ -141,7 +141,7 @@
   }
 
   .table-row-hover-bg {
-    @apply transition-colors cursor-pointer;
+    @apply hover-transition cursor-pointer;
   }
 
   .table-row-hover-bg:hover {
diff --git a/src/styles/_tokens.scss b/src/styles/_tokens.scss
index f5ff28e..b704b11 100644
--- a/src/styles/_tokens.scss
+++ b/src/styles/_tokens.scss
@@ -129,6 +129,14 @@ $utility-token-map: (
   }
 }
 
+@layer base {
+  :root {
+    --cubic-enter: cubic-bezier(0.16, 1, 0.3, 1);
+    --cubic-move: cubic-bezier(0.4, 0, 0.2, 1);
+    --cubic-exit: cubic-bezier(0.7, 0, 0.84, 0);
+  }
+}
+
 @layer components {
   @each $class-name, $settings in $component-token-map {
     .#{$class-name} {
@@ -143,4 +151,33 @@ $utility-token-map: (
       @include apply-token($settings);
     }
   }
+
+  .hover-transition {
+    transition-duration: 40ms;
+    transition-property: color, background-color, border-color, text-decoration-color, fill, stroke;
+    transition-timing-function: var(--cubic-move);
+  }
+
+  .dropdown-open-transition {
+    animation: dropdown-open 120ms var(--cubic-enter);
+    transform-origin: top center;
+  }
+
+  @keyframes dropdown-open {
+    from {
+      opacity: 0;
+      transform: translateY(-4px) scaleY(0.98);
+    }
+
+    to {
+      opacity: 1;
+      transform: translateY(0) scaleY(1);
+    }
+  }
+
+  @media (prefers-reduced-motion: reduce) {
+    .dropdown-open-transition {
+      animation: none;
+    }
+  }
 }
diff --git a/src/types/wca-helpers.d.ts b/src/types/wca-helpers.d.ts
new file mode 100644
index 0000000..bb76a48
--- /dev/null
+++ b/src/types/wca-helpers.d.ts
@@ -0,0 +1,44 @@
+import '@wca/helpers';
+
+declare module '@wca/helpers' {
+  export type ParticipationResultCondition =
+    | {
+        type: 'ranking' | 'percent';
+        value: number;
+      }
+    | {
+        type: 'resultAchieved';
+        scope: 'single' | 'average';
+        value: number | null;
+      };
+
+  export type ParticipationSource =
+    | {
+        type: 'registrations';
+      }
+    | {
+        type: 'round';
+        roundId: string;
+        resultCondition: ParticipationResultCondition;
+      }
+    | {
+        type: 'linkedRounds';
+        roundIds: string[];
+        resultCondition: ParticipationResultCondition;
+      };
+
+  export interface ReservedPlaces {
+    nationalities: string[];
+    count?: number;
+    reservations?: number;
+  }
+
+  export interface ParticipationRuleset {
+    participationSource: ParticipationSource;
+    reservedPlaces?: ReservedPlaces | null;
+  }
+
+  export interface Round {
+    participationRuleset?: ParticipationRuleset | null;
+  }
+}
diff --git a/src/vite-env.d.ts b/src/vite-env.d.ts
index 0dd8293..e7d6bb4 100644
--- a/src/vite-env.d.ts
+++ b/src/vite-env.d.ts
@@ -3,3 +3,10 @@
 
 declare const __GIT_COMMIT__: string;
 declare const __GIT_TAG__: string;
+
+interface ImportMetaEnv {
+  readonly VITE_NOTIFY_COMP_ORIGIN?: string;
+  readonly VITE_NOTIFYCOMP_API_ORIGIN?: string;
+  readonly VITE_NOTIFYCOMP_WS_ORIGIN?: string;
+  readonly VITE_FEATURE_PERSONAL_USER_PAGE?: string;
+}
diff --git a/vite.config.ts b/vite.config.ts
index a52c327..229055b 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -28,6 +28,9 @@ export default defineConfig({
     ViteYaml(),
     VitePWA({
       registerType: 'prompt',
+      workbox: {
+        importScripts: ['notification-sw.js'],
+      },
     }),
   ],
   build: {