fix(#76): preserve pacing and empty-state truth

Aggregate conflicting freshness by severity so Local cannot mask Stale/Partial,
treat authoritative inactive SSE as valid state, honor Weekend focus headers,
and prove Limited Retry busy accessibility with deferred supplements.

Co-authored-by: Cursor <cursoragent@cursor.com>

.agents/harnesses.sh

@@ -25,7 +25,8 @@ EOF
 
 harness_claude() {                      # Claude Code — print mode, auto-accept edits
   local dir="$1" prompt="$2"
-  ( cd "$dir" && claude -p "$(cat "$prompt")" --permission-mode acceptEdits )
+  local model="${BOXBOX_CLAUDE_MODEL:-opus}"
+  ( cd "$dir" && claude -p "$(cat "$prompt")" --model "$model" --effort high --permission-mode acceptEdits )
 }
 
 harness_codex() {                       # OpenAI Codex CLI — non-interactive exec, full auto
@@ -40,7 +41,8 @@ harness_opencode() {                    # opencode — non-interactive run
 
 harness_cursor() {                      # Cursor CLI agent — composer-2.5, headless full-auto
   local dir="$1" prompt="$2"
-  ( cd "$dir" && cursor-agent -p "$(cat "$prompt")" --model composer-2.5 --force --trust )
+  local model="${BOXBOX_CURSOR_MODEL:-composer-2.5}"
+  ( cd "$dir" && cursor-agent -p "$(cat "$prompt")" --model "$model" --force --trust )
 }
 
 harness_agy() {                         # Antigravity CLI — disabled until headless is verified

docs/product/v0.4.0/README.md

@@ -0,0 +1,32 @@
+# v0.4.0 — Current Weekend & Product Truth
+
+Product research references for the v0.4.0 feature sprint.
+
+## Direction
+
+The sprint replaces route-first navigation with a state-aware Weekend experience:
+
+- Weekend is the adaptive home for what happened, what is live, and what is next.
+- Preview content folds into Weekend before a session.
+- Live remains a stable deep link and becomes Weekend's active-session state.
+- Race Hub remains explicit completed-session analysis rather than a primary landing destination.
+- Championship and Briefing remain dedicated destinations.
+- Explore owns secondary discovery; Admin moves to operator utility.
+
+## Mockups
+
+- `mockups/weekend-between-races.png` — desktop between-races/post-weekend state.
+- `mockups/weekend-live.png` — desktop active-session state; the circuit is static sector context, not live GPS.
+- `mockups/weekend-between-sessions-mobile.png` — 390×844 between-session state.
+
+These are directional references, not pixel-perfect specifications. Implementations must preserve the established box-box visual language, accessibility, data constraints, and responsive behavior while satisfying their issue acceptance criteria.
+
+## Constraints
+
+- No OpenF1 REST dependency during active sessions.
+- Public live GPS is not assumed to be available.
+- Championship round numbers exclude tests and cancelled meetings.
+- Connection health, live-session state, archive availability, and local-analysis readiness are separate concepts.
+- Future sessions must not render empty post-session analysis.
+
+The authoritative product decisions and research packet are recorded in GitHub issue #71 under epic #70.

frontend/src/api.ts

@@ -1,3 +1,4 @@
+import { apiFetch } from './lib/fetch'
 import type {
   ArticleContent,
   CarDataSample,
@@ -15,152 +16,187 @@ import type {
   Session,
   TrackOutline,
   Weekend,
+  WeekendContext,
 } from './types'
 
-export async function fetchRaceHub(sessionKey: number): Promise<RaceHub> {
-  const res = await fetch(`/api/v1/race-hub?session_key=${sessionKey}`)
-  if (!res.ok) {
-    throw new Error(`API ${res.status}: ${res.statusText}`)
-  }
-  return res.json()
+export async function fetchRaceHub(sessionKey: number, signal?: AbortSignal): Promise<RaceHub> {
+  return apiFetch<RaceHub>(`/api/v1/race-hub?session_key=${sessionKey}`, {
+    signal,
+    dedupeKey: `race-hub:${sessionKey}`,
+  })
 }
 
-export async function fetchSeasons(): Promise<number[]> {
-  const res = await fetch('/api/v1/seasons')
-  if (!res.ok) {
-    throw new Error(`API ${res.status}: ${res.statusText}`)
-  }
-  const years = await res.json()
+export async function fetchSeasons(signal?: AbortSignal): Promise<number[]> {
+  const years = await apiFetch<number[]>('/api/v1/seasons', {
+    signal,
+    dedupeKey: 'seasons',
+  })
   return Array.isArray(years) ? years : []
 }
 
-export async function fetchLocalMeetings(year: number): Promise<Meeting[]> {
-  const res = await fetch(`/api/v1/meetings?year=${year}&source=local`)
-  if (!res.ok) {
-    throw new Error(`API ${res.status}: ${res.statusText}`)
-  }
-  const meetings = await res.json()
+export async function fetchLocalMeetings(year: number, signal?: AbortSignal): Promise<Meeting[]> {
+  const meetings = await apiFetch<Meeting[]>(`/api/v1/meetings?year=${year}&source=local`, {
+    signal,
+    dedupeKey: `meetings:local:${year}`,
+  })
   return Array.isArray(meetings) ? meetings : []
 }
 
-export async function fetchSeasonMeetings(year: number): Promise<Meeting[]> {
-  return fetchMeetings(year, 'openf1')
+export async function fetchSeasonMeetings(year: number, signal?: AbortSignal): Promise<Meeting[]> {
+  return fetchMeetings(year, 'openf1', signal)
 }
 
-export async function fetchMeetings(year: number, source = 'auto'): Promise<Meeting[]> {
-  const res = await fetch(`/api/v1/meetings?year=${year}&source=${source}`)
-  if (!res.ok) {
-    throw new Error(`API ${res.status}: ${res.statusText}`)
-  }
-  const meetings = await res.json()
+export async function fetchMeetings(
+  year: number,
+  source = 'auto',
+  signal?: AbortSignal,
+): Promise<Meeting[]> {
+  const meetings = await apiFetch<Meeting[]>(`/api/v1/meetings?year=${year}&source=${source}`, {
+    signal,
+    dedupeKey: `meetings:${source}:${year}`,
+  })
   return Array.isArray(meetings) ? meetings : []
 }
 
-export async function fetchResults(sessionKey: number, source = 'auto'): Promise<EnrichedResult[]> {
-  const res = await fetch(`/api/v1/results?session_key=${sessionKey}&source=${source}`)
-  if (!res.ok) {
-    throw new Error(`API ${res.status}: ${res.statusText}`)
-  }
-  const results = await res.json()
+export async function fetchResults(
+  sessionKey: number,
+  source = 'auto',
+  signal?: AbortSignal,
+): Promise<EnrichedResult[]> {
+  const results = await apiFetch<EnrichedResult[]>(
+    `/api/v1/results?session_key=${sessionKey}&source=${source}`,
+    { signal, dedupeKey: `results:${source}:${sessionKey}` },
+  )
   return Array.isArray(results) ? results : []
 }
 
-export async function fetchStartingGrid(sessionKey: number, source = 'auto'): Promise<EnrichedGrid[]> {
-  const res = await fetch(`/api/v1/grid?session_key=${sessionKey}&source=${source}`)
-  if (!res.ok) {
-    throw new Error(`API ${res.status}: ${res.statusText}`)
-  }
-  const grid = await res.json()
+export async function fetchStartingGrid(
+  sessionKey: number,
+  source = 'auto',
+  signal?: AbortSignal,
+): Promise<EnrichedGrid[]> {
+  const grid = await apiFetch<EnrichedGrid[]>(
+    `/api/v1/grid?session_key=${sessionKey}&source=${source}`,
+    { signal, dedupeKey: `grid:${source}:${sessionKey}` },
+  )
   return Array.isArray(grid) ? grid : []
 }
 
-export async function fetchTrackOutline(circuitKey: number, year: number): Promise<TrackOutline | null> {
-  const res = await fetch(`/api/v1/track-outline?circuit_key=${circuitKey}&year=${year}`)
-  if (!res.ok) return null
-  const data = await res.json()
+export async function fetchTrackOutline(
+  circuitKey: number,
+  year: number,
+  signal?: AbortSignal,
+): Promise<TrackOutline | null> {
+  try {
+    const data = await apiFetch<TrackOutline & { error?: string }>(
+      `/api/v1/track-outline?circuit_key=${circuitKey}&year=${year}`,
+      { signal, dedupeKey: `track-outline:${circuitKey}:${year}` },
+    )
     if (data?.error || !Array.isArray(data?.points) || data.points.length < 2) return null
     return data as TrackOutline
+  } catch {
+    return null
+  }
 }
 
 export async function fetchReplayFrames(
   sessionKey: number,
   intervalMs = 5000,
+  signal?: AbortSignal,
 ): Promise<ReplayFramesResponse> {
   const params = new URLSearchParams({
     session_key: String(sessionKey),
     interval_ms: String(intervalMs),
   })
-  const res = await fetch(`/api/v1/replay/frames?${params}`)
-  if (!res.ok) {
-    throw new Error(`API ${res.status}: ${res.statusText}`)
-  }
-  return res.json()
+  return apiFetch<ReplayFramesResponse>(`/api/v1/replay/frames?${params}`, {
+    signal,
+    dedupeKey: `replay-frames:${sessionKey}:${intervalMs}`,
+  })
 }
 
-export async function fetchSessions(meetingKey: number, source = 'openf1'): Promise<Session[]> {
-  const res = await fetch(`/api/v1/sessions?meeting_key=${meetingKey}&source=${source}`)
-  if (!res.ok) {
-    throw new Error(`API ${res.status}: ${res.statusText}`)
-  }
-  const sessions = await res.json()
+export async function fetchSessions(
+  meetingKey: number,
+  source = 'openf1',
+  signal?: AbortSignal,
+): Promise<Session[]> {
+  const sessions = await apiFetch<Session[]>(
+    `/api/v1/sessions?meeting_key=${meetingKey}&source=${source}`,
+    { signal, dedupeKey: `sessions:${source}:${meetingKey}` },
+  )
   return Array.isArray(sessions) ? sessions : []
 }
 
-export async function fetchWeekend(meetingKey: number): Promise<Weekend> {
-  const res = await fetch(`/api/v1/weekend?meeting_key=${meetingKey}`)
-  if (!res.ok) {
-    throw new Error(`API ${res.status}: ${res.statusText}`)
-  }
-  return res.json()
+export async function fetchWeekend(meetingKey: number, signal?: AbortSignal): Promise<Weekend> {
+  return apiFetch<Weekend>(`/api/v1/weekend?meeting_key=${meetingKey}`, {
+    signal,
+    dedupeKey: `weekend:${meetingKey}`,
+  })
 }
 
-export async function fetchChampionshipHub(year?: number): Promise<ChampionshipHub> {
+// fetchWeekendContext consumes the canonical /api/v1/weekend-context endpoint
+// (backend story #72). The response is the authoritative WeekendContext shape and
+// is used verbatim as the Weekend home's source of truth. Any HTTP error throws
+// so the hook can surface an explicit error state; there is no client-side
+// re-derivation of the contract. Race Hub bare-default landing also reads this
+// for `default_analysis_session` (#75).
+export async function fetchWeekendContext(signal?: AbortSignal): Promise<WeekendContext> {
+  return apiFetch<WeekendContext>('/api/v1/weekend-context', {
+    signal,
+    dedupeKey: 'weekend-context',
+  })
+}
+
+export async function fetchChampionshipHub(
+  year?: number,
+  signal?: AbortSignal,
+): Promise<ChampionshipHub> {
   const params = new URLSearchParams({ source: 'auto' })
   if (year) params.set('year', year.toString())
-  const url = `/api/v1/championship/hub?${params.toString()}`
-  const res = await fetch(url)
-  if (!res.ok) {
-    throw new Error(`API ${res.status}: ${res.statusText}`)
-  }
-  return res.json()
+  return apiFetch<ChampionshipHub>(`/api/v1/championship/hub?${params.toString()}`, {
+    signal,
+    dedupeKey: `championship-hub:${year ?? 'latest'}`,
+  })
 }
 
 export async function fetchDriverSummary(
   driverNumber: number,
   year?: number,
+  signal?: AbortSignal,
 ): Promise<DriverSummary> {
-  const params = new URLSearchParams({ driver_number: String(driverNumber) })
+  const params = new URLSearchParams({ driver_number: String(driverNumber), source: 'auto' })
   if (year) params.set('year', String(year))
-  const res = await fetch(`/api/v1/driver/summary?${params.toString()}`)
-  if (!res.ok) {
-    throw new Error(`API ${res.status}: ${res.statusText}`)
-  }
-  return res.json()
+  return apiFetch<DriverSummary>(`/api/v1/driver/summary?${params.toString()}`, {
+    signal,
+    dedupeKey: `driver-summary:${driverNumber}:${year ?? 'latest'}`,
+  })
 }
 
-export async function fetchLiveState(): Promise<LiveStateResponse> {
-  const res = await fetch('/api/v1/live/state')
-  if (!res.ok) {
-    throw new Error(`API ${res.status}: ${res.statusText}`)
-  }
-  return res.json()
+export async function fetchLiveState(signal?: AbortSignal): Promise<LiveStateResponse> {
+  return apiFetch<LiveStateResponse>('/api/v1/live/state', {
+    signal,
+    dedupeKey: 'live-state',
+  })
 }
 
 export async function fetchLiveTrackOutline(
   session: LiveSessionMeta,
   year = new Date().getFullYear(),
+  signal?: AbortSignal,
 ): Promise<TrackOutline> {
   const params = new URLSearchParams({ year: year.toString() })
   if (session.MeetingName) params.set('meeting_name', session.MeetingName)
   if (session.CircuitName) params.set('circuit_name', session.CircuitName)
-  const res = await fetch(`/api/v1/track-outline?${params.toString()}`)
-  if (!res.ok) {
-    throw new Error(`API ${res.status}: ${res.statusText}`)
-  }
-  return res.json()
+  return apiFetch<TrackOutline>(`/api/v1/track-outline?${params.toString()}`, {
+    signal,
+    dedupeKey: `live-track-outline:${year}:${session.MeetingName ?? ''}:${session.CircuitName ?? ''}`,
+  })
 }
 
-export async function fetchNews(limit?: number, source?: string): Promise<NewsItem[]> {
+export async function fetchNews(
+  limit?: number,
+  source?: string,
+  signal?: AbortSignal,
+): Promise<NewsItem[]> {
   const params = new URLSearchParams()
   if (limit) params.set('limit', limit.toString())
   if (source) params.set('source', source)
@@ -168,19 +204,20 @@ export async function fetchNews(limit?: number, source?: string): Promise<NewsIt
   const query = params.toString()
   const url = query ? `/api/v1/news?${query}` : '/api/v1/news'
 
-  const res = await fetch(url)
-  if (!res.ok) {
-    throw new Error(`API ${res.status}: ${res.statusText}`)
-  }
-  return res.json()
+  return apiFetch<NewsItem[]>(url, {
+    signal,
+    dedupeKey: `news:${limit ?? 'all'}:${source ?? 'all'}`,
+  })
 }
 
-export async function fetchNewsArticle(articleUrl: string): Promise<ArticleContent> {
-  const res = await fetch(`/api/v1/news/article?url=${encodeURIComponent(articleUrl)}`)
-  if (!res.ok) {
-    throw new Error(`API ${res.status}: ${res.statusText}`)
-  }
-  return res.json()
+export async function fetchNewsArticle(
+  articleUrl: string,
+  signal?: AbortSignal,
+): Promise<ArticleContent> {
+  return apiFetch<ArticleContent>(
+    `/api/v1/news/article?url=${encodeURIComponent(articleUrl)}`,
+    { signal },
+  )
 }
 
 export async function markNewsRead(articleUrl: string): Promise<void> {
@@ -194,28 +231,26 @@ export async function markNewsRead(articleUrl: string): Promise<void> {
 export async function fetchTelemetry(
   sessionKey: number,
   driverNumber: number,
+  signal?: AbortSignal,
 ): Promise<CarDataSample[]> {
-  const res = await fetch(
+  const data = await apiFetch<CarDataSample[]>(
     `/api/v1/telemetry?session_key=${sessionKey}&driver_number=${driverNumber}`,
+    { signal, dedupeKey: `telemetry:${sessionKey}:${driverNumber}` },
   )
-  if (!res.ok) {
-    throw new Error(`API ${res.status}: ${res.statusText}`)
-  }
-  const data = await res.json()
   return Array.isArray(data) ? data : []
 }
 
 export async function fetchLapsComparison(
   sessionKey: number,
   drivers?: number[],
+  signal?: AbortSignal,
 ): Promise<LapsComparisonResponse> {
   const params = new URLSearchParams({ session_key: String(sessionKey) })
   if (drivers?.length) {
     params.set('drivers', drivers.join(','))
   }
-  const res = await fetch(`/api/v1/laps/comparison?${params}`)
-  if (!res.ok) {
-    throw new Error(`API ${res.status}: ${res.statusText}`)
-  }
-  return res.json()
+  return apiFetch<LapsComparisonResponse>(`/api/v1/laps/comparison?${params}`, {
+    signal,
+    dedupeKey: `laps-comparison:${sessionKey}:${drivers?.join(',') ?? 'all'}`,
+  })
 }

frontend/src/components/ChapterStrip.tsx

@@ -1,3 +1,5 @@
+import { useEffect, useRef } from 'react'
+import { BookOpen } from 'lucide-react'
 import type { Chapter } from '../types'
 import {
   activeChapterIndex,
@@ -5,6 +7,7 @@ import {
   chapterLapRange,
   chapterStartScrub,
 } from '../lib/chapters'
+import { EmptyStateCard } from './EmptyStateCard'
 import '../styles/chapters.css'
 
 interface Props {
@@ -14,6 +17,8 @@ interface Props {
   tRange: number
   tourActive: boolean
   tourChapterIndex: number | null
+  /** Explicit selection from a chapter click; wins over scrub-derived active. */
+  selectedChapterIndex?: number | null
   onChapterClick: (index: number, scrub: number) => void
   onTourToggle: () => void
 }
@@ -25,19 +30,38 @@ export function ChapterStrip({
   tRange,
   tourActive,
   tourChapterIndex,
+  selectedChapterIndex = null,
   onChapterClick,
   onTourToggle,
 }: Props) {
+  const scrollRef = useRef<HTMLDivElement>(null)
+  const activeIndex = activeChapterIndex(chapters, scrubTime, tMin, tRange)
+  const highlightedIndex = tourActive
+    ? tourChapterIndex
+    : (selectedChapterIndex ?? activeIndex)
+
+  useEffect(() => {
+    if (highlightedIndex === null || !scrollRef.current) return
+    const card = scrollRef.current.querySelector<HTMLElement>(
+      `[data-testid="chapter-card-${highlightedIndex}"]`,
+    )
+    card?.scrollIntoView?.({ behavior: 'smooth', inline: 'center', block: 'nearest' })
+  }, [highlightedIndex])
+
   if (chapters.length === 0) {
     return (
       <div className="chapter-strip" data-testid="chapter-strip">
-        <p className="chapter-strip-empty">No story chapters for this session.</p>
+        <EmptyStateCard
+          icon={BookOpen}
+          title="No story chapters"
+          hint="This session does not have enough race-control or position data to build narrative chapters."
+          testId="chapter-strip-empty"
+          className="chapter-strip-empty-card"
+        />
       </div>
     )
   }
 
-  const activeIndex = activeChapterIndex(chapters, scrubTime, tMin, tRange)
-
   return (
     <div className="chapter-strip" data-testid="chapter-strip">
       <div className="chapter-strip-header">
@@ -53,12 +77,16 @@ export function ChapterStrip({
           </button>
         </div>
       </div>
-      <div className="chapter-strip-scroll" role="list" aria-label="Race story chapters">
+      <div className="chapter-strip-scroll-wrap">
+        <div
+          ref={scrollRef}
+          className="chapter-strip-scroll"
+          role="list"
+          aria-label="Race story chapters"
+        >
           {chapters.map((chapter, index) => {
             const scrub = chapterStartScrub(chapter, tMin, tRange) ?? index / Math.max(chapters.length - 1, 1)
-          const isActive = tourActive
-            ? tourChapterIndex === index
-            : activeIndex === index
+            const isActive = highlightedIndex === index
             const headline = chapter.headline || chapter.title
 
             return (
@@ -83,5 +111,6 @@ export function ChapterStrip({
           })}
         </div>
       </div>
+    </div>
   )
 }

frontend/src/components/EmptyStateCard.tsx

@@ -0,0 +1,20 @@
+import type { LucideIcon } from 'lucide-react'
+import type { ReactNode } from 'react'
+
+interface Props {
+  icon: LucideIcon
+  title: string
+  hint: ReactNode
+  testId?: string
+  className?: string
+}
+
+export function EmptyStateCard({ icon: Icon, title, hint, testId, className = '' }: Props) {
+  return (
+    <div className={`empty-state ui-card ${className}`.trim()} data-testid={testId}>
+      <Icon size={32} className="empty-state-icon" aria-hidden />
+      <div className="empty-state-title">{title}</div>
+      <div className="empty-state-desc">{hint}</div>
+    </div>
+  )
+}

frontend/src/components/LocalDataNavigator.tsx

@@ -5,6 +5,7 @@ import { fetchLocalMeetings, fetchSeasons, fetchWeekend } from '../api'
 import { formatCoverageHint } from '../lib/coverage'
 import { SourceBadge } from './SourceBadge'
 import { SessionCoverageDots } from './SessionCoverageDots'
+import { RouteState } from './RouteState'
 import type { Meeting, WeekendSession } from '../types'
 
 function formatMeetingDates(meeting: Meeting): string {
@@ -29,18 +30,18 @@ export function LocalDataNavigator({ onSelectSession }: Props) {
 
   const seasonsQuery = useQuery({
     queryKey: ['seasons'],
-    queryFn: fetchSeasons,
+    queryFn: ({ signal }) => fetchSeasons(signal),
   })
 
   const meetingsQuery = useQuery({
     queryKey: ['meetings', selectedYear],
-    queryFn: () => fetchLocalMeetings(selectedYear!),
+    queryFn: ({ signal }) => fetchLocalMeetings(selectedYear!, signal),
     enabled: selectedYear != null,
   })
 
   const weekendQuery = useQuery({
     queryKey: ['weekend', selectedMeetingKey],
-    queryFn: () => fetchWeekend(selectedMeetingKey!),
+    queryFn: ({ signal }) => fetchWeekend(selectedMeetingKey!, signal),
     enabled: selectedMeetingKey != null,
   })
 
@@ -68,14 +69,22 @@ export function LocalDataNavigator({ onSelectSession }: Props) {
   }
 
   if (seasonsQuery.isLoading) {
-    return <div className="nav-panel loading-state">loading local seasons…</div>
+    return <RouteState kind="loading" title="loading local seasons…" className="nav-panel" />
   }
 
   if (seasonsQuery.isError) {
     return (
-      <div className="nav-panel error-box">
-        {seasonsQuery.error instanceof Error ? seasonsQuery.error.message : 'Failed to load seasons'}
-      </div>
+      <RouteState
+        kind="error"
+        className="nav-panel"
+        title="Local seasons unavailable"
+        error={seasonsQuery.error}
+        onRetry={() => {
+          if (!seasonsQuery.isFetching) void seasonsQuery.refetch()
+        }}
+        retrying={seasonsQuery.isFetching}
+        testId="weekend-error"
+      />
     )
   }
 
@@ -124,9 +133,16 @@ export function LocalDataNavigator({ onSelectSession }: Props) {
       )}
 
       {meetingsQuery.isError && (
-        <div className="error-box" style={{ marginTop: 'var(--s4)' }}>
-          {meetingsQuery.error instanceof Error ? meetingsQuery.error.message : 'Failed to load meetings'}
-        </div>
+        <RouteState
+          kind="error"
+          title="Meetings unavailable"
+          error={meetingsQuery.error}
+          onRetry={() => {
+            if (!meetingsQuery.isFetching) void meetingsQuery.refetch()
+          }}
+          retrying={meetingsQuery.isFetching}
+          testId="weekend-meetings-error"
+        />
       )}
 
       {!meetingsQuery.isLoading && !meetingsQuery.isError && meetings.length === 0 && (
@@ -194,9 +210,16 @@ export function LocalDataNavigator({ onSelectSession }: Props) {
       )}
 
       {selectedMeetingKey != null && weekendQuery.isError && (
-        <div className="error-box" style={{ marginTop: 'var(--s4)' }}>
-          {weekendQuery.error instanceof Error ? weekendQuery.error.message : 'Failed to load weekend'}
-        </div>
+        <RouteState
+          kind="error"
+          title="Weekend unavailable"
+          error={weekendQuery.error}
+          onRetry={() => {
+            if (!weekendQuery.isFetching) void weekendQuery.refetch()
+          }}
+          retrying={weekendQuery.isFetching}
+          testId="weekend-error"
+        />
       )}
 
       {weekend && (

frontend/src/components/Nav.tsx

@@ -1,36 +1,66 @@
 import { Link } from '@tanstack/react-router'
+import { Compass, FileText, Home, Trophy } from 'lucide-react'
 
+const PRIMARY = [
+  { to: '/', label: 'Weekend', icon: Home, exact: true },
+  { to: '/championship', label: 'Championship', icon: Trophy, exact: false },
+  { to: '/briefing', label: 'Briefing', icon: FileText, exact: false },
+  { to: '/explore', label: 'Explore', icon: Compass, exact: false },
+] as const
+
+/**
+ * Nav renders one primary navigation system per breakpoint:
+ *   - Desktop/tablet: the top bar's `aria-label="Primary"` links.
+ *   - Mobile (≤640px): the bottom `aria-label="Primary"` bar; the top bar's links
+ *     are hidden via CSS so the two are never both active at once.
+ *
+ * Admin is an operator utility, deliberately outside every Primary landmark — it
+ * lives in a plain toolbar slot and never appears in the mobile bottom nav.
+ */
 export function Nav() {
   return (
-    <nav className="app-nav">
+    <>
+      <header className="app-nav">
         <Link to="/" className="nav-logo">
           box<em>-</em>box
         </Link>
-      <div className="nav-links">
-        <Link to="/" activeProps={{ className: 'active' }} activeOptions={{ exact: true }}>
-          Command
+        <nav className="nav-links" aria-label="Primary">
+          {PRIMARY.map(({ to, label, exact }) => (
+            <Link
+              key={to}
+              to={to}
+              activeProps={{ className: 'active' }}
+              activeOptions={exact ? { exact: true } : undefined}
+            >
+              {label}
             </Link>
-        <Link to="/live" activeProps={{ className: 'active' }}>
-          Live
-        </Link>
-        <Link to="/race-hub" search={{}} activeProps={{ className: 'active' }}>
-          Race Hub
-        </Link>
-        <Link to="/preview" activeProps={{ className: 'active' }}>
-          Preview
-        </Link>
-        <Link to="/championship" activeProps={{ className: 'active' }}>
-          Championship
-        </Link>
-        <Link to="/briefing" activeProps={{ className: 'active' }}>
-          Briefing
-        </Link>
-      </div>
-      <div className="nav-utility">
-        <Link to="/admin" className="nav-utility-link" activeProps={{ className: 'nav-utility-link active' }}>
+          ))}
+        </nav>
+        <div className="nav-utility" role="toolbar" aria-label="Operator utilities">
+          <Link
+            to="/admin"
+            className="nav-utility-link"
+            activeProps={{ className: 'nav-utility-link active' }}
+          >
             Admin
           </Link>
         </div>
+      </header>
+
+      <nav className="app-bottom-nav" aria-label="Primary">
+        {PRIMARY.map(({ to, label, icon: Icon, exact }) => (
+          <Link
+            key={to}
+            to={to}
+            className="bottom-nav-link"
+            activeProps={{ className: 'bottom-nav-link active' }}
+            activeOptions={exact ? { exact: true } : undefined}
+          >
+            <Icon size={18} aria-hidden="true" />
+            <span>{label}</span>
+          </Link>
+        ))}
       </nav>
+    </>
   )
 }

frontend/src/components/OverviewView.tsx

@@ -1,6 +1,5 @@
 import type { RaceHub } from '../types'
 import { compareFinishPosition, formatDuration, formatGap, formatLapTime } from '../utils'
-import { countRaceHubDatasets } from '../lib/coverage'
 import { Thermometer, Map, Droplets, Wind, CloudRain } from 'lucide-react'
 
 interface Props {
@@ -17,7 +16,6 @@ export function OverviewView({ data }: Props) {
   const fastest = pickFastestLap(data)
   const latestWeather = data.weather.length > 0 ? data.weather[data.weather.length - 1] : null
   const rcHighlights = data.race_control.slice(-3).reverse()
-  const coverage = countRaceHubDatasets(data.datasets)
 
   const sessionType = (data.session?.session_type ?? '').toLowerCase()
   const isRace = sessionType.includes('race')
@@ -129,28 +127,6 @@ export function OverviewView({ data }: Props) {
             </ul>
           )}
         </section>
-
-        <section className="rh-panel ui-card">
-          <div className="sec-header">
-            <span className="sec-title">Local Coverage</span>
-            <span className="sec-meta mono">
-              {coverage.available}/{coverage.total}
-            </span>
-          </div>
-          <div className="rh-coverage-meter" aria-hidden="true">
-            <div
-              className="rh-coverage-fill"
-              style={{ width: `${(coverage.available / coverage.total) * 100}%` }}
-            />
-          </div>
-          <div className="rh-empty-line" style={{ marginTop: 'var(--s2)' }}>
-            {coverage.available === coverage.total
-              ? 'Every Race Hub dataset is local for this session.'
-              : `${coverage.total - coverage.available} dataset${
-                  coverage.total - coverage.available === 1 ? '' : 's'
-                } not ingested yet — see Data Status tab.`}
-          </div>
-        </section>
       </div>
     </div>
   )

frontend/src/components/PaddockBriefing.tsx

@@ -34,25 +34,25 @@ export function PaddockBriefing() {
 
   const { data: news, isLoading, isError } = useQuery({
     queryKey: ['news'],
-    queryFn: () => fetchNews(100),
+    queryFn: ({ signal }) => fetchNews(100, undefined, signal),
     staleTime: 60_000,
   })
 
   const seasonsQuery = useQuery({
     queryKey: ['seasons'],
-    queryFn: fetchSeasons,
+    queryFn: ({ signal }) => fetchSeasons(signal),
   })
   const latestSeason = seasonsQuery.data?.[0] ?? null
 
   const meetingsQuery = useQuery({
     queryKey: ['season-meetings', latestSeason],
-    queryFn: () => fetchSeasonMeetings(latestSeason!),
+    queryFn: ({ signal }) => fetchSeasonMeetings(latestSeason!, signal),
     enabled: latestSeason != null,
   })
 
   const hubQuery = useQuery({
     queryKey: ['championship-hub', latestSeason],
-    queryFn: () => fetchChampionshipHub(latestSeason!),
+    queryFn: ({ signal }) => fetchChampionshipHub(latestSeason!, signal),
     enabled: latestSeason != null,
   })
 

frontend/src/components/PreSessionView.tsx

@@ -0,0 +1,141 @@
+import type { Session } from '../types'
+import { RACE_HUB_DATASETS } from '../lib/coverage'
+import { formatCountdown, formatSessionScheduleTime, sessionStartTime } from '../lib/schedule'
+import {
+  sessionStateDescription,
+  type SessionState,
+} from '../lib/sessionState'
+
+const EXPECTED_LABELS: Record<string, string> = {
+  results: 'Final results',
+  starting_grid: 'Starting grid',
+  stints: 'Tyre strategy',
+  pit_stops: 'Pit stops',
+  positions: 'Position changes',
+  laps: 'Lap times',
+  race_control: 'Race control',
+  weather: 'Track conditions',
+}
+
+interface PreSessionProps {
+  session: Session
+  sessionName: string
+  now: Date
+}
+
+/**
+ * Purpose-built view for a session that has not run yet. Instead of rendering
+ * empty Winner / Podium / Pole / Strategy / Compare cards, it explains that the
+ * session is upcoming and previews the analysis that will appear once the data
+ * is ingested.
+ */
+export function PreSessionView({ session, sessionName, now }: PreSessionProps) {
+  const start = sessionStartTime(session)
+  const expected = RACE_HUB_DATASETS.filter((key) => EXPECTED_LABELS[key])
+
+  return (
+    <div className="rh-presession" data-testid="rh-presession">
+      <section className="rh-presession-band">
+        <span className="rh-presession-eyebrow mono">Upcoming session</span>
+        <h2 className="rh-presession-title">{sessionName}</h2>
+        <p className="rh-presession-sub">
+          This session hasn’t run yet, so there’s no result to analyse. Winner,
+          podium, pole, strategy and comparison views will appear here once the
+          session completes and its data is ingested.
+        </p>
+        <div className="rh-presession-countdown mono" data-testid="rh-presession-countdown">
+          {start
+            ? `Starts ${formatSessionScheduleTime(session.date_start)} · in ${formatCountdown(start, now)}`
+            : 'Start time to be confirmed.'}
+        </div>
+      </section>
+
+      <div className="data-section">
+        <div className="sec-header">
+          <span className="sec-title">Expected once complete</span>
+        </div>
+        <div className="rh-expected-grid">
+          {expected.map((key) => (
+            <div key={key} className="rh-expected-card">
+              <span className="rh-expected-dot" aria-hidden="true" />
+              <span>{EXPECTED_LABELS[key]}</span>
+            </div>
+          ))}
+        </div>
+      </div>
+    </div>
+  )
+}
+
+interface PhaseProps {
+  state: Extract<SessionState, 'preparing' | 'unavailable' | 'cancelled'>
+  sessionName: string
+  onOpenDiagnostics?: () => void
+}
+
+/**
+ * Distinct fan-facing surfaces for settling/preparing and unavailable sessions.
+ * Genuine request failures stay on the page-level error recovery path.
+ */
+export function SessionPhaseView({ state, sessionName, onOpenDiagnostics }: PhaseProps) {
+  const title =
+    state === 'preparing'
+      ? 'Analysis preparing'
+      : state === 'cancelled'
+        ? 'Session cancelled'
+        : 'Analysis unavailable'
+
+  const testId =
+    state === 'preparing'
+      ? 'rh-preparing'
+      : state === 'cancelled'
+        ? 'rh-cancelled'
+        : 'rh-unavailable'
+
+  return (
+    <div className="rh-presession" data-testid={testId}>
+      <section className="rh-presession-band">
+        <span className="rh-presession-eyebrow mono">{sessionStateLabelEyebrow(state)}</span>
+        <h2 className="rh-presession-title">{title}</h2>
+        <p className="rh-presession-sub">
+          {sessionName}: {sessionStateDescription(state)}
+        </p>
+        {state === 'preparing' && (
+          <p className="rh-presession-sub">
+            Check back shortly, or open Diagnostics if you need raw dataset coverage.
+          </p>
+        )}
+        {onOpenDiagnostics && (state === 'preparing' || state === 'unavailable') && (
+          <div className="rh-empty-actions" style={{ marginTop: 'var(--s4)' }}>
+            <button type="button" className="rh-empty-action" onClick={onOpenDiagnostics}>
+              Open Diagnostics
+            </button>
+          </div>
+        )}
+      </section>
+    </div>
+  )
+}
+
+function sessionStateLabelEyebrow(state: PhaseProps['state']): string {
+  if (state === 'preparing') return 'Settling'
+  if (state === 'cancelled') return 'Cancelled'
+  return 'Unavailable'
+}
+
+interface PartialBannerProps {
+  onOpenDiagnostics?: () => void
+}
+
+export function PartialAnalysisBanner({ onOpenDiagnostics }: PartialBannerProps) {
+  return (
+    <div className="rh-partial-banner" data-testid="rh-partial-banner" role="status">
+      <span>Partial analysis — some datasets are still missing.</span>
+      {onOpenDiagnostics && (
+        <button type="button" className="rh-partial-banner-link" onClick={onOpenDiagnostics}>
+          Diagnostics
+        </button>
+      )}
+    </div>
+  )
+}

frontend/src/components/RaceStoryCanvas.tsx

@@ -1,13 +1,36 @@
 import { useEffect, useMemo, useRef, useState } from 'react'
 import { useQuery } from '@tanstack/react-query'
+import { LineChart } from 'lucide-react'
 import type { Driver, EnrichedResult, EnrichedGrid, PositionSample, Lap, Meeting, Session, Chapter } from '../types'
 import { fetchReplayFrames, fetchTrackOutline } from '../api'
 import { ReplayTrackMap } from './ReplayTrackMap'
 import { ChapterStrip } from './ChapterStrip'
+import { EmptyStateCard } from './EmptyStateCard'
 import { gridDelta, gridDeltaClass, formatDuration, formatGap } from '../utils'
-import { chapterEndScrub, chapterStartScrub, chapterTourDurations } from '../lib/chapters'
+import {
+  chapterBandFill,
+  chapterEndScrub,
+  chapterStartScrub,
+  chapterTourDurations,
+  deCollideYPositions,
+  decimatedPositionLabels,
+} from '../lib/chapters'
+import { isReplayMapAvailable } from '../lib/replayMap'
+import '../styles/race-story.css'
 
 const CHAPTER_TOUR_MS = 90_000
+const CHART_W = 640
+const CHART_H = 180
+const CHART_PL = 40
+const CHART_PR = 48
+const CHART_PT = 8
+const CHART_PB = 20
+
+interface ChartTiming {
+  tMin: number
+  tMax: number
+  tRange: number
+}
 
 interface Props {
   data: {
@@ -25,6 +48,48 @@ interface Props {
   }
 }
 
+/**
+ * Position samples are recorded for the entire session, including the pre-race
+ * grid period.  Use the winning driver's laps to define the race window so
+ * that the x-axis starts at lights-out rather than at the earliest sample.
+ */
+function raceChartTiming(
+  positions: PositionSample[],
+  laps: Lap[],
+  results: EnrichedResult[],
+): ChartTiming | null {
+  const positionTimes = positions
+    .map((position) => new Date(position.date).getTime())
+    .filter(Number.isFinite)
+  if (positionTimes.length === 0) return null
+
+  const fallbackMin = Math.min(...positionTimes)
+  const fallbackMax = Math.max(...positionTimes)
+  const fallback = {
+    tMin: fallbackMin,
+    tMax: fallbackMax,
+    tRange: Math.max(fallbackMax - fallbackMin, 1),
+  }
+
+  const winner = results.find((result) => result.position === 1)
+  if (!winner) return fallback
+
+  const winnerLaps = laps
+    .filter((lap) => lap.driver_number === winner.driver_number && lap.lap_number > 0)
+    .map((lap) => ({ ...lap, start: new Date(lap.date_start).getTime() }))
+    .filter((lap) => Number.isFinite(lap.start))
+    .sort((a, b) => a.lap_number - b.lap_number)
+  if (winnerLaps.length === 0) return fallback
+
+  const firstLap = winnerLaps[0]
+  const lastLap = winnerLaps[winnerLaps.length - 1]
+  const finalLapDuration = lastLap.lap_duration ?? 0
+  const tMax = lastLap.start + (finalLapDuration > 0 ? finalLapDuration * 1000 : 0)
+  if (tMax <= firstLap.start) return fallback
+
+  return { tMin: firstLap.start, tMax, tRange: tMax - firstLap.start }
+}
+
 export function RaceStoryCanvas({ data }: Props) {
   const {
     results,
@@ -48,32 +113,46 @@ export function RaceStoryCanvas({ data }: Props) {
   const [playbackSpeed, setPlaybackSpeed] = useState(10)
   const [chapterTourActive, setChapterTourActive] = useState(false)
   const [tourChapterIndex, setTourChapterIndex] = useState<number | null>(null)
+  const [selectedChapterIndex, setSelectedChapterIndex] = useState<number | null>(null)
   const svgRef = useRef<SVGSVGElement>(null)
   const tourRef = useRef({ chapterIndex: 0, startedAt: 0, durationMs: 0, startScrub: 0, endScrub: 0 })
 
-  // Position Evolution Chart Logic
-  const allTimes = useMemo(() => [...new Set(positions.map((p) => p.date))].sort(), [positions])
-  const hasChartData = hasPositions && allTimes.length > 0
-  const chartTiming = useMemo(() => {
-    if (!hasChartData) return null
-    const tMin = new Date(allTimes[0]).getTime()
-    const tMax = new Date(allTimes[allTimes.length - 1]).getTime()
-    return { tMin, tMax, tRange: Math.max(tMax - tMin, 1) }
-  }, [allTimes, hasChartData])
+  const chartTiming = useMemo(() => raceChartTiming(positions, laps, results), [laps, positions, results])
+  const hasChartData = hasPositions && chartTiming !== null
   const circuitKey = session?.circuit_key ?? meeting?.circuit_key ?? 0
   const outlineYear = meeting?.year ?? (session?.date_start ? new Date(session.date_start).getFullYear() : 0)
+  const canProbeMap = Boolean(session?.session_key) && circuitKey > 0 && outlineYear > 0
 
   const replayQuery = useQuery({
     queryKey: ['replay-frames', session?.session_key, 5000],
     queryFn: () => fetchReplayFrames(session!.session_key, 5000),
-    enabled: mapOpen && Boolean(session?.session_key),
+    enabled: canProbeMap,
   })
   const outlineQuery = useQuery({
     queryKey: ['track-outline', circuitKey, outlineYear],
     queryFn: () => fetchTrackOutline(circuitKey, outlineYear),
-    enabled: mapOpen && circuitKey > 0 && outlineYear > 0,
+    enabled: canProbeMap,
   })
 
+  const mapProbeSettled = !canProbeMap || (!replayQuery.isLoading && !outlineQuery.isLoading)
+  const mapAvailable = useMemo(
+    () =>
+      canProbeMap &&
+      isReplayMapAvailable(
+        replayQuery.data,
+        outlineQuery.data,
+        replayQuery.isError || outlineQuery.isError,
+      ),
+    [canProbeMap, outlineQuery.data, outlineQuery.isError, replayQuery.data, replayQuery.isError],
+  )
+  const showMapPanel = mapOpen && mapAvailable
+
+  useEffect(() => {
+    if (!mapAvailable && mapOpen) {
+      setMapOpen(false)
+    }
+  }, [mapAvailable, mapOpen])
+
   useEffect(() => {
     if (!isPlaying || !chartTiming) return
 
@@ -104,9 +183,14 @@ export function RaceStoryCanvas({ data }: Props) {
   const jumpToChapter = (index: number, scrub: number) => {
     setIsPlaying(false)
     stopChapterTour()
+    setSelectedChapterIndex(index)
     setScrubTime(scrub)
   }
 
+  const clearChapterSelection = () => {
+    setSelectedChapterIndex(null)
+  }
+
   const toggleChapterTour = () => {
     if (chapterTourActive) {
       stopChapterTour()
@@ -114,6 +198,7 @@ export function RaceStoryCanvas({ data }: Props) {
     }
     if (!chartTiming || chapters.length === 0) return
     setIsPlaying(false)
+    setSelectedChapterIndex(null)
     setChapterTourActive(true)
     setTourChapterIndex(0)
     const startScrub = chapterStartScrub(chapters[0], chartTiming.tMin, chartTiming.tRange) ?? 0
@@ -194,16 +279,19 @@ export function RaceStoryCanvas({ data }: Props) {
 
   if (hasChartData && chartTiming) {
     const { tMin, tRange } = chartTiming
+    const normaliseTime = (time: number) => Math.max(0, Math.min(1, (time - tMin) / tRange))
 
     const byDriver = new Map<number, Array<{ t: number; pos: number }>>()
     for (const p of positions) {
+      const time = new Date(p.date).getTime()
+      if (!Number.isFinite(time)) continue
       if (!byDriver.has(p.driver_number)) byDriver.set(p.driver_number, [])
       byDriver.get(p.driver_number)!.push({
-        t: (new Date(p.date).getTime() - tMin) / tRange,
+        t: normaliseTime(time),
         pos: p.position,
       })
     }
-    const dnfSet = new Set(results.filter(r => r.dnf || r.dns || r.dsq).map(r => r.driver_number))
+    const dnfSet = new Set(results.filter((r) => r.dnf || r.dns || r.dsq).map((r) => r.driver_number))
     for (const [dNum, samples] of byDriver.entries()) {
       samples.sort((a, b) => a.t - b.t)
       if (samples.length > 0 && !dnfSet.has(dNum)) {
@@ -211,16 +299,16 @@ export function RaceStoryCanvas({ data }: Props) {
       }
     }
 
-    const getInterpPos = (samples: {t: number, pos: number}[], t: number) => {
+    const getInterpPos = (samples: { t: number; pos: number }[], t: number) => {
       if (!samples || samples.length === 0) return null
       if (t <= samples[0].t) return samples[0].pos
       if (t >= samples[samples.length - 1].t) return samples[samples.length - 1].pos
       for (let i = 0; i < samples.length - 1; i++) {
-        if (samples[i].t <= t && samples[i+1].t >= t) {
-          const dt = samples[i+1].t - samples[i].t
+        if (samples[i].t <= t && samples[i + 1].t >= t) {
+          const dt = samples[i + 1].t - samples[i].t
           if (dt === 0) return samples[i].pos
           const frac = (t - samples[i].t) / dt
-          return samples[i].pos + (samples[i+1].pos - samples[i].pos) * frac
+          return samples[i].pos + (samples[i + 1].pos - samples[i].pos) * frac
         }
       }
       return null
@@ -244,34 +332,37 @@ export function RaceStoryCanvas({ data }: Props) {
     const maxPos = Math.max(...positions.map((p) => p.position), results.length, 2)
     const colorByDriver = new Map(results.map((r) => [r.driver_number, r.team_colour]))
     const acronymByDriver = new Map(results.map((r) => [r.driver_number, r.name_acronym]))
+    const positionLabels = decimatedPositionLabels(maxPos)
 
-    const W = 640
-    const H = 180
-    const PL = 40
-    const PR = 48
-    const PT = 8
-    const PB = 20
+    const W = CHART_W
+    const H = CHART_H
+    const PL = CHART_PL
+    const PR = CHART_PR
+    const PT = CHART_PT
+    const PB = CHART_PB
     const plotW = W - PL - PR
     const plotH = H - PT - PB
 
     const toX = (t: number) => PL + t * plotW
     const toY = (pos: number) => PT + ((pos - 1) / Math.max(maxPos - 1, 1)) * plotH
 
-    const winner = results.find(r => r.position === 1)
-    const winnerLaps = winner ? laps.filter(l => l.driver_number === winner.driver_number) : []
-    const lapTicks: { lap: number, t: number }[] = []
+    const winner = results.find((r) => r.position === 1)
+    const winnerLaps = winner ? laps.filter((l) => l.driver_number === winner.driver_number) : []
+    const lapTicks: { lap: number; t: number }[] = []
     const lapInterval = winnerLaps.length < 30 ? 5 : 10
 
-    for (const lap of winnerLaps) {
+    for (let i = 0; i < winnerLaps.length; i++) {
+      const lap = winnerLaps[i]
       if (lap.lap_number > 0 && lap.lap_number % lapInterval === 0) {
-        const t = (new Date(lap.date_start).getTime() - tMin) / tRange
-        if (t >= 0 && t <= 1) {
-          lapTicks.push({ lap: lap.lap_number, t })
-        }
+        const lapStart = new Date(lap.date_start).getTime()
+        const nextLapStart = winnerLaps[i + 1] ? new Date(winnerLaps[i + 1].date_start).getTime() : NaN
+        const lapEnd = lap.lap_duration && lap.lap_duration > 0
+          ? lapStart + lap.lap_duration * 1000
+          : nextLapStart
+        if (Number.isFinite(lapEnd)) lapTicks.push({ lap: lap.lap_number, t: normaliseTime(lapEnd) })
       }
     }
 
-    // Safety Car / VSC periods
     const scPeriods: { start: number; end: number | null; type: 'SC' | 'VSC' }[] = []
     let activeSC: { start: number; type: 'SC' | 'VSC' } | null = null
     const rc = [...race_control].sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime())
@@ -296,25 +387,73 @@ export function RaceStoryCanvas({ data }: Props) {
       scPeriods.push({ start: activeSC.start, end: null, type: activeSC.type })
     }
 
+    const chapterBands = chapters
+      .map((chapter, index) => {
+        const startT = chapterStartScrub(chapter, tMin, tRange)
+        const endT = chapterEndScrub(chapter, tMin, tRange)
+        if (startT === null) return null
+        const end = endT ?? startT
+        return {
+          key: `${chapter.kind}-${index}`,
+          start: Math.min(startT, end),
+          end: Math.max(startT, end),
+          fill: chapterBandFill(chapter.kind),
+        }
+      })
+      .filter((band): band is NonNullable<typeof band> => band !== null)
+
+    const labelCandidates = Array.from(byDriver.entries())
+      .map(([dNum, samples]) => {
+        const last = samples[samples.length - 1]
+        if (!last) return null
+        return { key: dNum, y: toY(last.pos) }
+      })
+      .filter((item): item is { key: number; y: number } => item !== null)
+    const labelYByDriver = deCollideYPositions(labelCandidates, 12)
+
     const handlePointerMove = (e: React.PointerEvent<SVGRectElement>) => {
       setIsPlaying(false)
       stopChapterTour()
+      clearChapterSelection()
       if (!svgRef.current) return
       const rect = svgRef.current.getBoundingClientRect()
-      const x = e.clientX - rect.left
+      if (rect.width <= 0) return
+      // Pointer coordinates are CSS pixels; convert them to the SVG viewBox
+      // before comparing with the fixed chart margins and plot width.
+      const x = ((e.clientX - rect.left) / rect.width) * W
       const t = Math.max(0, Math.min(1, (x - PL) / plotW))
       setScrubTime(t)
     }
 
     chartContent = (
-      <div className="rs-chart-container scroll-x" data-testid="position-chart">
+      <div
+        className={`rs-chart-container scroll-x${showMapPanel ? '' : ' rs-chart-container--full'}`}
+        data-testid="position-chart"
+      >
         <svg
           ref={svgRef}
+          className="rs-position-chart-svg"
           viewBox={`0 0 ${W} ${H}`}
-          style={{ width: '100%', minWidth: 280, maxWidth: W, display: 'block' }}
           role="img"
           aria-label="Position evolution chart"
         >
+          {chapterBands.map((band) => {
+            const x1 = toX(Math.max(0, band.start))
+            const x2 = toX(Math.min(1, band.end))
+            if (x2 <= PL || x1 >= W - PR) return null
+            return (
+              <rect
+                key={band.key}
+                x={x1}
+                y={PT}
+                width={Math.max(0, x2 - x1)}
+                height={plotH}
+                fill={band.fill}
+                data-testid="chapter-band"
+              />
+            )
+          })}
+
           {scPeriods.map((sc, i) => {
             const startT = (sc.start - tMin) / tRange
             const endT = sc.end ? (sc.end - tMin) / tRange : 1
@@ -333,33 +472,41 @@ export function RaceStoryCanvas({ data }: Props) {
             )
           })}
 
-          {Array.from({ length: maxPos }, (_, i) => i + 1).map((pos) => (
+          {positionLabels.map((pos) => (
             <g key={pos}>
               <line
                 x1={PL}
                 x2={W - PR}
                 y1={toY(pos)}
                 y2={toY(pos)}
-                stroke="var(--border)"
-                strokeWidth={0.5}
+                className="rs-chart-grid-line"
               />
               <text
                 x={PL - 4}
                 y={toY(pos) + 4}
                 textAnchor="end"
-                fill="var(--text-3)"
-                fontSize={8}
-                fontFamily="var(--f-mono)"
+                className="rs-chart-axis-label"
               >
                 P{pos}
               </text>
             </g>
           ))}
 
-          {lapTicks.map(tick => (
+          {lapTicks.map((tick) => (
             <g key={`lap-${tick.lap}`}>
-              <line x1={toX(tick.t)} x2={toX(tick.t)} y1={H - PB} y2={H - PB + 4} stroke="var(--border)" strokeWidth={1} />
-              <text x={toX(tick.t)} y={H - PB + 14} textAnchor="middle" fill="var(--text-3)" fontSize={9} fontFamily="var(--f-mono)">
+              <line
+                x1={toX(tick.t)}
+                x2={toX(tick.t)}
+                y1={H - PB}
+                y2={H - PB + 4}
+                className="rs-chart-lap-tick"
+              />
+              <text
+                x={toX(tick.t)}
+                y={H - PB + 14}
+                textAnchor="middle"
+                className="rs-chart-axis-label"
+              >
                 L{tick.lap}
               </text>
             </g>
@@ -372,8 +519,9 @@ export function RaceStoryCanvas({ data }: Props) {
             const last = samples[samples.length - 1]
             const isHovered = hoverDriver === dNum
             const isFaded = hoverDriver !== null && !isHovered
+            const labelY = last ? (labelYByDriver.get(dNum) ?? toY(last.pos)) : 0
 
-            const driverPits = pit_stops.filter(p => p.driver_number === dNum)
+            const driverPits = pit_stops.filter((p) => p.driver_number === dNum)
 
             return (
               <g
@@ -394,8 +542,9 @@ export function RaceStoryCanvas({ data }: Props) {
                 />
 
                 {driverPits.map((p, i) => {
-                  const t = (new Date(p.date).getTime() - tMin) / tRange
-                  if (t < 0 || t > 1) return null
+                  const time = new Date(p.date).getTime()
+                  if (!Number.isFinite(time) || time < tMin || time > tMin + tRange) return null
+                  const t = normaliseTime(time)
                   const pos = getInterpPos(samples, t)
                   if (pos === null) return null
                   return (
@@ -415,7 +564,7 @@ export function RaceStoryCanvas({ data }: Props) {
                 {last && (
                   <text
                     x={toX(last.t) + 6}
-                    y={toY(last.pos) + 4}
+                    y={labelY + 4}
                     fill={color}
                     fontSize={isHovered ? 11 : 9}
                     fontFamily="var(--f-mono)"
@@ -449,44 +598,57 @@ export function RaceStoryCanvas({ data }: Props) {
             width={plotW}
             height={plotH}
             fill="transparent"
+            data-testid="position-chart-interaction"
             onPointerMove={handlePointerMove}
             onPointerLeave={() => {
-              if (!isPlaying) setScrubTime(null)
+              if (!isPlaying) {
+                clearChapterSelection()
+                setScrubTime(null)
+              }
             }}
             style={{ cursor: 'crosshair', touchAction: 'none' }}
           />
         </svg>
-        <div className="rs-replay-tools" aria-label="Race replay controls">
+        <div className="rs-segmented-control" aria-label="Race replay controls" data-testid="replay-controls">
           <button
             type="button"
-            className={`rs-tool-btn ${isPlaying ? 'active' : ''}`}
+            className={`rs-segment ${isPlaying ? 'active' : ''}`}
             onClick={() => {
               setScrubTime((current) => current ?? 0)
               stopChapterTour()
+              clearChapterSelection()
               setIsPlaying((current) => !current)
             }}
+            aria-pressed={isPlaying}
           >
             {isPlaying ? 'Pause' : 'Play'}
           </button>
-          <div className="rs-speed-group" aria-label="Playback speed">
+          <span className="rs-segment-divider" aria-hidden />
           {[1, 10, 30].map((speed) => (
             <button
               key={speed}
               type="button"
-                className={`rs-speed-btn ${playbackSpeed === speed ? 'active' : ''}`}
+              className={`rs-segment ${playbackSpeed === speed ? 'active' : ''}`}
               onClick={() => setPlaybackSpeed(speed)}
+              aria-pressed={playbackSpeed === speed}
             >
               {speed}x
             </button>
           ))}
-          </div>
+          {mapProbeSettled && mapAvailable && (
+            <>
+              <span className="rs-segment-divider" aria-hidden />
               <button
                 type="button"
-            className={`rs-tool-btn ${mapOpen ? 'active' : ''}`}
+                className={`rs-segment ${mapOpen ? 'active' : ''}`}
                 onClick={() => setMapOpen((current) => !current)}
+                aria-pressed={mapOpen}
+                data-testid="replay-map-toggle"
               >
                 Map
               </button>
+            </>
+          )}
         </div>
       </div>
     )
@@ -502,24 +664,32 @@ export function RaceStoryCanvas({ data }: Props) {
           tRange={chartTiming.tRange}
           tourActive={chapterTourActive}
           tourChapterIndex={tourChapterIndex}
+          selectedChapterIndex={selectedChapterIndex}
           onChapterClick={jumpToChapter}
           onTourToggle={toggleChapterTour}
         />
       )}
-      <div className="rs-replay-shell">
+      <div className={`rs-replay-shell${showMapPanel ? ' rs-replay-shell--split' : ''}`}>
         <div className="rs-replay-main">
           {hasChartData ? (
             chartContent
           ) : (
-            <div className="analysis-notice">
-              <strong>Lap-by-lap positions not available.</strong> This session does not
-              have ingested position samples in <code>/api/v1/race-hub</code>.
-            </div>
+            <EmptyStateCard
+              icon={LineChart}
+              title="Lap-by-lap positions not available"
+              hint={
+                <>
+                  This session does not have ingested position samples in{' '}
+                  <code>/api/v1/race-hub</code>.
+                </>
+              }
+              testId="race-story-no-positions"
+              className="race-story-empty-card"
+            />
           )}
         </div>
-        {mapOpen && (
-          <div className="rs-replay-map-slot">
-            {circuitKey > 0 && outlineYear > 0 ? (
+        {showMapPanel && (
+          <div className="rs-replay-map-slot" data-testid="replay-map-slot">
             <ReplayTrackMap
               outline={outlineQuery.data}
               replay={replayQuery.data}
@@ -529,20 +699,23 @@ export function RaceStoryCanvas({ data }: Props) {
               loading={outlineQuery.isLoading || replayQuery.isLoading}
               error={outlineQuery.isError || replayQuery.isError}
             />
-            ) : (
-              <div className="rs-replay-map-placeholder">track identity unavailable for replay map</div>
-            )}
           </div>
         )}
       </div>
 
       {displayResults.length > 0 && (
-        <div className="rs-field-list">
+        <div
+          className="rs-field-list"
+          role="region"
+          aria-label="Final running order"
+          data-testid="race-story-outcome"
+        >
           {displayResults.map((r, i) => {
             const gridPos = grid.find((g) => g.driver_number === r.driver_number)?.position ?? 0
             const currentPos = scrubTime !== null ? i + 1 : r.position
             const isWinner = i === 0 && r.position === 1
-            const pClass = currentPos === 1 ? 'rs-pos-p1' : currentPos === 2 ? 'rs-pos-p2' : currentPos === 3 ? 'rs-pos-p3' : ''
+            const pClass =
+              currentPos === 1 ? 'rs-pos-p1' : currentPos === 2 ? 'rs-pos-p2' : currentPos === 3 ? 'rs-pos-p3' : ''
 
             let currentPoints: number | string = r.points
             if (scrubTime !== null) {
@@ -559,9 +732,7 @@ export function RaceStoryCanvas({ data }: Props) {
                 onMouseLeave={() => setHoverDriver(null)}
               >
                 <div className="rs-driver-left">
-                  <div className={`rs-pos-col ${pClass}`}>
-                    {currentPos}
-                  </div>
+                  <div className={`rs-pos-col ${pClass}`}>{currentPos}</div>
                   <div className="rs-driver-cell">
                     <div
                       className="rs-driver-color"

frontend/src/components/ReplayTrackMap.tsx

@@ -1,7 +1,9 @@
 import { useMemo, useState } from 'react'
+import { Loader2, MapPin, Satellite } from 'lucide-react'
 import type { Driver, EnrichedResult, ReplayFramesResponse, TrackOutline } from '../types'
 import { buildOutlinePath } from '../lib/trackmap'
 import { interpolateReplayCars, replayCarToSvg } from '../lib/replay'
+import { EmptyStateCard } from './EmptyStateCard'
 import '../styles/replay-map.css'
 
 interface Props {
@@ -60,7 +62,13 @@ export function ReplayTrackMap({
   if (loading) {
     return (
       <section className="replay-map-panel" data-testid="replay-track-map">
-        <div className="replay-map-empty">loading replay GPS...</div>
+        <EmptyStateCard
+          icon={Loader2}
+          title="Loading replay map"
+          hint="Fetching track outline and historical GPS frames."
+          testId="replay-map-loading"
+          className="replay-map-empty-card"
+        />
       </section>
     )
   }
@@ -68,7 +76,13 @@ export function ReplayTrackMap({
   if (error) {
     return (
       <section className="replay-map-panel" data-testid="replay-track-map">
-        <div className="replay-map-empty">replay GPS unavailable for this session</div>
+        <EmptyStateCard
+          icon={Satellite}
+          title="Replay GPS unavailable"
+          hint="This session does not have ingested location samples for the replay map."
+          testId="replay-map-error"
+          className="replay-map-empty-card"
+        />
       </section>
     )
   }
@@ -76,7 +90,13 @@ export function ReplayTrackMap({
   if (!outline || !outlinePath) {
     return (
       <section className="replay-map-panel" data-testid="replay-track-map">
-        <div className="replay-map-empty">track outline unavailable for this session</div>
+        <EmptyStateCard
+          icon={MapPin}
+          title="Track outline unavailable"
+          hint="Circuit GPS outline data is missing for this session."
+          testId="replay-map-no-outline"
+          className="replay-map-empty-card"
+        />
       </section>
     )
   }
@@ -84,7 +104,13 @@ export function ReplayTrackMap({
   if (!replay?.frames?.length || cars.length === 0) {
     return (
       <section className="replay-map-panel" data-testid="replay-track-map">
-        <div className="replay-map-empty">historical GPS unavailable for this session</div>
+        <EmptyStateCard
+          icon={Satellite}
+          title="Historical GPS unavailable"
+          hint="Fewer than two replay frames were returned for this session."
+          testId="replay-map-no-frames"
+          className="replay-map-empty-card"
+        />
       </section>
     )
   }

frontend/src/components/RivalryCompare.tsx

@@ -0,0 +1,271 @@
+import { useMemo, useState } from 'react'
+import type { ChampHubDriver, ChampionshipHub } from '../types'
+import { teamColor } from '../utils'
+import { gapSeries, h2hTally, lastRounds } from '../lib/rivalry'
+import '../styles/rivalry.css'
+
+const PAD_L = 48
+const PAD_T = 16
+const PLOT_W = 882
+const PLOT_H = 316
+const GAP_PLOT_H = 200
+
+function fmtPts(n: number): string {
+  return Number.isInteger(n) ? String(n) : n.toFixed(1)
+}
+
+/** Up to ~7 evenly spaced round labels, always including the last round. */
+function xTicks(n: number, labels: string[], x: (i: number) => number): { x: number; label: string }[] {
+  const step = Math.max(1, Math.ceil(n / 7))
+  const ticks: { x: number; label: string }[] = []
+  for (let i = 0; i < n; i += step) {
+    ticks.push({ x: x(i), label: labels[i] ?? `R${i + 1}` })
+  }
+  const last = labels[n - 1] ?? `R${n}`
+  if (ticks[ticks.length - 1]?.label !== last) {
+    ticks.push({ x: x(n - 1), label: last })
+  }
+  return ticks
+}
+
+function polyline(values: number[], x: (i: number) => number, y: (v: number) => number): string {
+  return values.map((v, i) => `${x(i).toFixed(1)},${y(v).toFixed(1)}`).join(' ')
+}
+
+interface PickerProps {
+  id: 'a' | 'b'
+  label: string
+  drivers: ChampHubDriver[]
+  value: number
+  color: string
+  onChange: (driverNumber: number) => void
+}
+
+function DriverPicker({ id, label, drivers, value, color, onChange }: PickerProps) {
+  return (
+    <label className="rivalry-picker">
+      <span className="rivalry-picker-label">{label}</span>
+      <select
+        className="rivalry-picker-select"
+        style={{ borderLeft: `3px solid ${color}` }}
+        value={value}
+        data-testid={`rivalry-pick-${id}`}
+        onChange={(e) => onChange(Number(e.target.value))}
+      >
+        {drivers.map((d) => (
+          <option key={d.driver_number} value={d.driver_number}>
+            {d.name_acronym} · {d.full_name}
+          </option>
+        ))}
+      </select>
+    </label>
+  )
+}
+
+export function RivalryCompare({ hub }: { hub: ChampionshipHub }) {
+  const { drivers } = hub
+  const [pickA, setPickA] = useState<number | null>(null)
+  const [pickB, setPickB] = useState<number | null>(null)
+
+  // Default to the top two in the standings; fall back there if a picked
+  // driver disappears (e.g. season switch re-fetches the hub).
+  const a = drivers.find((d) => d.driver_number === pickA) ?? drivers[0]
+  const b = drivers.find((d) => d.driver_number === pickB) ?? drivers[1]
+
+  const tally = useMemo(
+    () => (a && b ? h2hTally(a.round_positions ?? [], b.round_positions ?? [], hub.round_labels) : null),
+    [a, b, hub.round_labels],
+  )
+
+  if (drivers.length < 2) {
+    return (
+      <div className="champ-chart-empty" data-testid="champ-view-rivalry">
+        Need at least two drivers in the standings to compare a rivalry.
+      </div>
+    )
+  }
+
+  const colorA = teamColor(a.team_colour)
+  const colorB = teamColor(b.team_colour)
+  const sameTeam = a.team_name === b.team_name
+
+  const cumA = a.cumulative ?? []
+  const cumB = b.cumulative ?? []
+  const rounds = Math.min(cumA.length, cumB.length)
+  const gaps = gapSeries(cumA, cumB)
+  const lastGap = gaps[gaps.length - 1] ?? 0
+  const strip = tally ? lastRounds(tally, 5) : []
+
+  const pickers = (
+    <div className="rivalry-pickers">
+      <DriverPicker id="a" label="Driver A" drivers={drivers} value={a.driver_number} color={colorA} onChange={setPickA} />
+      <span className="rivalry-vs mono">vs</span>
+      <DriverPicker id="b" label="Driver B" drivers={drivers} value={b.driver_number} color={colorB} onChange={setPickB} />
+    </div>
+  )
+
+  if (rounds === 0) {
+    return (
+      <div className="rivalry" data-testid="champ-view-rivalry">
+        {pickers}
+        <div className="champ-chart-empty">
+          No completed rounds yet — the rivalry will appear after the first race.
+        </div>
+      </div>
+    )
+  }
+
+  // Points race scales.
+  const peak = Math.max(...cumA.slice(0, rounds), ...cumB.slice(0, rounds), 1)
+  const maxY = Math.max(50, Math.ceil(peak / 50) * 50)
+  const px = (i: number) => (rounds <= 1 ? PAD_L : PAD_L + (i * PLOT_W) / (rounds - 1))
+  const py = (v: number) => PAD_T + PLOT_H - (v / maxY) * PLOT_H
+  const pyGrid = [0, 0.25, 0.5, 0.75, 1].map((f) => ({ y: py(maxY * f), label: Math.round(maxY * f) }))
+  const pxGrid = xTicks(rounds, hub.round_labels, px)
+
+  // Gap scales: symmetric around zero.
+  const maxAbs = Math.max(10, Math.ceil(Math.max(...gaps.map(Math.abs), 1) / 10) * 10)
+  const gy = (v: number) => PAD_T + GAP_PLOT_H / 2 - (v / maxAbs) * (GAP_PLOT_H / 2)
+  const gyGrid = [maxAbs, 0, -maxAbs].map((v) => ({ y: gy(v), label: v > 0 ? `+${v}` : String(v) }))
+  const gxGrid = xTicks(rounds, hub.round_labels, px)
+
+  const gapLeader = lastGap === 0 ? null : lastGap > 0 ? a : b
+  const gapCaption = gapLeader
+    ? `${gapLeader.name_acronym} leads by ${fmtPts(Math.abs(lastGap))} pts after ${hub.round_labels[rounds - 1] ?? `R${rounds}`}.`
+    : 'Dead level on points.'
+
+  return (
+    <div className="rivalry" data-testid="champ-view-rivalry">
+      {pickers}
+
+      <div className="rivalry-h2h" data-testid="rivalry-h2h">
+        <div className="rivalry-h2h-score">
+          <span className="rivalry-h2h-code mono" style={{ color: colorA }}>
+            {a.name_acronym}
+          </span>
+          <span className="rivalry-h2h-num mono" data-testid="rivalry-h2h-num">
+            {tally ? `${tally.a}–${tally.b}` : '—'}
+          </span>
+          <span className="rivalry-h2h-code mono" style={{ color: colorB }}>
+            {b.name_acronym}
+          </span>
+        </div>
+        <span className="rivalry-h2h-meta">
+          Race head-to-head · {tally?.rounds.length ?? 0} round{(tally?.rounds.length ?? 0) === 1 ? '' : 's'} counted
+          {tally && tally.skipped > 0 ? ` · ${tally.skipped} skipped` : ''}
+        </span>
+        {strip.length > 0 && (
+          <div className="rivalry-strip" data-testid="rivalry-strip">
+            <span className="rivalry-strip-label">Last {strip.length}</span>
+            {strip.map((r) => (
+              <span className="rivalry-chip" key={r.round} title={`${r.label}: ${a.name_acronym} P${r.posA} · ${b.name_acronym} P${r.posB}`}>
+                <span className="rivalry-chip-round mono">{r.label}</span>
+                <span className="rivalry-chip-winner mono" style={{ color: r.winner === 'a' ? colorA : colorB }}>
+                  {r.winner === 'a' ? a.name_acronym : b.name_acronym}
+                </span>
+              </span>
+            ))}
+          </div>
+        )}
+      </div>
+
+      <section className="rivalry-section" data-testid="rivalry-points-race">
+        <div className="champ-chart-head">
+          <span className="champ-chart-title mono">
+            Points race — {a.name_acronym} vs {b.name_acronym}
+          </span>
+          <span className="champ-chart-meta">
+            Rounds 1–{rounds} · {hub.season}
+          </span>
+        </div>
+        <div className="champ-chart">
+          <svg viewBox="0 0 1000 380" className="champ-chart-svg" preserveAspectRatio="none">
+            {pyGrid.map((g) => (
+              <g key={g.label}>
+                <line x1={PAD_L} y1={g.y} x2={930} y2={g.y} stroke="var(--border)" strokeWidth="1" />
+                <text x={40} y={g.y + 4} textAnchor="end" className="champ-chart-axis">
+                  {g.label}
+                </text>
+              </g>
+            ))}
+            {pxGrid.map((g, i) => (
+              <text key={i} x={g.x} y={372} textAnchor="middle" className="champ-chart-axis">
+                {g.label}
+              </text>
+            ))}
+            {[
+              { slot: 'a', d: a, color: colorA, dash: '0', values: cumA.slice(0, rounds) },
+              { slot: 'b', d: b, color: colorB, dash: sameTeam ? '5 4' : '0', values: cumB.slice(0, rounds) },
+            ].map((s) => (
+              <g key={s.slot}>
+                <polyline
+                  points={polyline(s.values, px, py)}
+                  fill="none"
+                  stroke={s.color}
+                  strokeWidth="2.4"
+                  strokeDasharray={s.dash}
+                  strokeLinejoin="round"
+                  strokeLinecap="round"
+                />
+                <circle cx={px(s.values.length - 1)} cy={py(s.values[s.values.length - 1])} r="3" fill={s.color} />
+                <text
+                  x={px(s.values.length - 1) + 8}
+                  y={py(s.values[s.values.length - 1]) + 4}
+                  fill={s.color}
+                  className="champ-chart-label"
+                >
+                  {s.d.name_acronym}
+                </text>
+              </g>
+            ))}
+          </svg>
+        </div>
+      </section>
+
+      <section className="rivalry-section" data-testid="rivalry-gap">
+        <div className="champ-chart-head">
+          <span className="champ-chart-title mono">
+            Gap over season — {a.name_acronym} − {b.name_acronym}
+          </span>
+          <span className="champ-chart-meta">{gapCaption}</span>
+        </div>
+        <div className="champ-chart">
+          <svg viewBox="0 0 1000 250" className="champ-chart-svg" preserveAspectRatio="none">
+            {gyGrid.map((g) => (
+              <g key={g.label}>
+                <line
+                  x1={PAD_L}
+                  y1={g.y}
+                  x2={930}
+                  y2={g.y}
+                  stroke={g.label === '0' ? 'var(--border-2)' : 'var(--border)'}
+                  strokeWidth={g.label === '0' ? 1.5 : 1}
+                />
+                <text x={40} y={g.y + 4} textAnchor="end" className="champ-chart-axis">
+                  {g.label}
+                </text>
+              </g>
+            ))}
+            {gxGrid.map((g, i) => (
+              <text key={i} x={g.x} y={242} textAnchor="middle" className="champ-chart-axis">
+                {g.label}
+              </text>
+            ))}
+            <polyline
+              points={polyline(gaps, px, gy)}
+              fill="none"
+              stroke={colorA}
+              strokeWidth="2.4"
+              strokeLinejoin="round"
+              strokeLinecap="round"
+            />
+            <circle cx={px(gaps.length - 1)} cy={gy(lastGap)} r="3" fill={colorA} />
+          </svg>
+        </div>
+        <p className="rivalry-caption">
+          Above the zero line: {a.name_acronym} ahead. Below: {b.name_acronym} ahead.
+        </p>
+      </section>
+    </div>
+  )
+}

frontend/src/components/RouteState.tsx

@@ -0,0 +1,163 @@
+import type { ReactNode } from 'react'
+import { isTimeoutError, userFacingError } from '../lib/fetch'
+import { noticeMessage, type DataAvailability } from '../lib/availability'
+
+export type { DataAvailability }
+
+export function availabilityLabel(kind: DataAvailability): string {
+  switch (kind) {
+    case 'local':
+      return 'Local'
+    case 'partial':
+      return 'Partial'
+    case 'stale':
+      return 'Stale'
+    case 'archive':
+      return 'Archive'
+    case 'limited':
+      return 'Limited'
+    case 'missing':
+      return 'Missing'
+  }
+}
+
+export function AvailabilityBadge({ kind, label }: { kind: DataAvailability; label?: string }) {
+  return (
+    <span className={`badge badge-${kind === 'archive' ? 'none' : kind}`} data-testid={`availability-${kind}`}>
+      {label ?? availabilityLabel(kind)}
+    </span>
+  )
+}
+
+export type RouteStateKind = 'loading' | 'empty' | 'error' | 'timeout'
+
+interface RouteStateProps {
+  kind: RouteStateKind
+  title?: string
+  message?: ReactNode
+  error?: unknown
+  onRetry?: () => void
+  retrying?: boolean
+  testId?: string
+  /** Optional override for the Retry button's data-testid (defaults to none). */
+  retryTestId?: string
+  className?: string
+  /** Optional availability strip (stale/limited/partial) above the state body. */
+  availability?: DataAvailability
+  children?: ReactNode
+}
+
+const DEFAULT_TITLES: Record<RouteStateKind, string> = {
+  loading: 'Loading…',
+  empty: 'Nothing here yet',
+  error: 'Could not load this view',
+  timeout: 'Request timed out',
+}
+
+const DEFAULT_MESSAGES: Record<RouteStateKind, string> = {
+  loading: 'Fetching the latest local data.',
+  empty: 'No data is available for this view yet.',
+  error: 'Something went wrong. Retry to try again.',
+  timeout: 'This request took too long. Check your connection, then retry.',
+}
+
+/**
+ * Shared primary-route state surface: loading, empty, timeout/error + retry.
+ * Retry is a real <button> (keyboard accessible) and callers should gate
+ * concurrent refetches via React Query / deduped apiFetch.
+ */
+export function RouteState({
+  kind,
+  title,
+  message,
+  error,
+  onRetry,
+  retrying = false,
+  testId,
+  retryTestId,
+  className = '',
+  availability,
+  children,
+}: RouteStateProps) {
+  const resolvedKind: RouteStateKind =
+    kind === 'error' && isTimeoutError(error) ? 'timeout' : kind
+
+  const resolvedMessage =
+    message ??
+    (error != null && (resolvedKind === 'error' || resolvedKind === 'timeout')
+      ? userFacingError(error)
+      : DEFAULT_MESSAGES[resolvedKind])
+
+  const showRetry =
+    (resolvedKind === 'error' || resolvedKind === 'timeout') && typeof onRetry === 'function'
+
+  return (
+    <div
+      className={`route-state route-state-${resolvedKind} ${className}`.trim()}
+      data-testid={testId ?? `route-state-${resolvedKind}`}
+      role={resolvedKind === 'error' || resolvedKind === 'timeout' ? 'alert' : undefined}
+    >
+      {availability && (
+        <div className="route-state-availability">
+          <AvailabilityBadge kind={availability} />
+        </div>
+      )}
+      {resolvedKind === 'loading' ? (
+        <div className="loading-state">{title ?? 'loading…'}</div>
+      ) : (
+        <>
+          <div className="route-state-title">{title ?? DEFAULT_TITLES[resolvedKind]}</div>
+          <div className="route-state-message">{resolvedMessage}</div>
+          {children}
+          {showRetry && (
+            <button
+              type="button"
+              className="route-state-retry"
+              onClick={onRetry}
+              disabled={retrying}
+              aria-busy={retrying || undefined}
+              data-testid={retryTestId}
+            >
+              {retrying ? 'Retrying…' : 'Retry'}
+            </button>
+          )}
+        </>
+      )}
+    </div>
+  )
+}
+
+interface StaleNoticeProps {
+  availability?: DataAvailability
+  message?: string
+  onRetry?: () => void
+  retrying?: boolean
+  testId?: string
+}
+
+/** Inline notice when a successful payload is limited/stale/partial. */
+export function DataNotice({
+  availability = 'stale',
+  message,
+  onRetry,
+  retrying = false,
+  testId = 'data-notice',
+}: StaleNoticeProps) {
+  return (
+    <div className="data-notice" data-testid={testId} role="status">
+      <AvailabilityBadge kind={availability} />
+      <span className="data-notice-text">{message ?? noticeMessage(availability)}</span>
+      {onRetry && (
+        <button
+          type="button"
+          className="route-state-retry data-notice-retry"
+          onClick={onRetry}
+          disabled={retrying}
+          aria-busy={retrying || undefined}
+        >
+          {retrying ? 'Retrying…' : 'Retry'}
+        </button>
+      )}
+    </div>
+  )
+}

frontend/src/components/TabBar.tsx

@@ -8,15 +8,46 @@ export type Tab =
   | 'race_control'
   | 'data_status'
 
-const TABS: { id: Tab; label: string }[] = [
+interface TabDef {
+  id: Tab
+  label: string
+}
+
+interface TabGroup {
+  id: string
+  label: string
+  tabs: TabDef[]
+}
+
+// Fan-facing hierarchy: Story first, then Analysis, then Data/Context. Every
+// existing capability is preserved — only the grouping and ordering change.
+const TAB_GROUPS: TabGroup[] = [
+  {
+    id: 'story',
+    label: 'Story',
+    tabs: [
       { id: 'overview', label: 'Overview' },
       { id: 'race_story', label: 'Race Story' },
+    ],
+  },
+  {
+    id: 'analysis',
+    label: 'Analysis',
+    tabs: [
       { id: 'strategy', label: 'Strategy' },
       { id: 'compare', label: 'Compare' },
       { id: 'lap_data', label: 'Lap Data' },
+    ],
+  },
+  {
+    id: 'context',
+    label: 'Data & Context',
+    tabs: [
       { id: 'conditions', label: 'Conditions' },
       { id: 'race_control', label: 'Race Control' },
-  { id: 'data_status', label: 'Data Status' },
+      { id: 'data_status', label: 'Diagnostics' },
+    ],
+  },
 ]
 
 interface Props {
@@ -26,8 +57,14 @@ interface Props {
 
 export function TabBar({ active, onChange }: Props) {
   return (
-    <div className="tab-bar" role="tablist">
-      {TABS.map((t) => (
+    <div className="tab-bar tab-bar-grouped" role="tablist" data-testid="rh-tabbar">
+      {TAB_GROUPS.map((group) => (
+        <div key={group.id} className="tab-group" data-testid={`rh-tabgroup-${group.id}`}>
+          <span className="tab-group-label mono" aria-hidden="true">
+            {group.label}
+          </span>
+          <div className="tab-group-btns">
+            {group.tabs.map((t) => (
               <button
                 key={t.id}
                 role="tab"
@@ -39,5 +76,8 @@ export function TabBar({ active, onChange }: Props) {
               </button>
             ))}
           </div>
+        </div>
+      ))}
+    </div>
   )
 }

frontend/src/components/WeekendSwitcher.tsx

@@ -2,41 +2,60 @@ import { useEffect, useState } from 'react'
 import { useQuery } from '@tanstack/react-query'
 import { useNavigate } from '@tanstack/react-router'
 import { fetchLocalMeetings, fetchSeasons, fetchWeekend } from '../api'
-import { formatCoverageHint, sessionTypeAbbrev } from '../lib/coverage'
+import { sessionTypeAbbrev } from '../lib/coverage'
+import {
+  resolveSessionState,
+  sessionStateDotClass,
+  sessionStateLabel,
+} from '../lib/sessionState'
 import { countryDecal, formatGpDateRange } from '../lib/gpIdentity'
+import type { WeekendContext } from '../types'
 
 interface Props {
   currentMeetingKey?: number
   currentSessionKey?: number
+  context?: WeekendContext | null
+  now?: Date
   onClose: () => void
 }
 
-export function WeekendSwitcher({ currentMeetingKey, currentSessionKey, onClose }: Props) {
+export function WeekendSwitcher({
+  currentMeetingKey,
+  currentSessionKey,
+  context,
+  now: nowProp,
+  onClose,
+}: Props) {
   const navigate = useNavigate()
-  const seasonsQuery = useQuery({ queryKey: ['seasons'], queryFn: fetchSeasons })
+  const seasonsQuery = useQuery({ queryKey: ['seasons'], queryFn: ({ signal }) => fetchSeasons(signal) })
   const [year, setYear] = useState<number | null>(null)
   const [openMeetingKey, setOpenMeetingKey] = useState<number | null>(
     currentMeetingKey ?? null,
   )
-
-  useEffect(() => {
-    if (year == null && seasonsQuery.data?.length) {
-      setYear(seasonsQuery.data[0])
-    }
-  }, [seasonsQuery.data, year])
-
-  const meetingsQuery = useQuery({
-    queryKey: ['meetings', year],
-    queryFn: () => fetchLocalMeetings(year!),
-    enabled: year != null,
-  })
+  const now = nowProp ?? new Date()
 
   const weekendQuery = useQuery({
     queryKey: ['weekend', openMeetingKey],
-    queryFn: () => fetchWeekend(openMeetingKey!),
+    queryFn: ({ signal }) => fetchWeekend(openMeetingKey!, signal),
     enabled: openMeetingKey != null,
   })
 
+  useEffect(() => {
+    if (year != null) return
+    const currentYear = weekendQuery.data?.meeting?.year
+    if (currentYear) {
+      setYear(currentYear)
+    } else if (seasonsQuery.data?.length) {
+      setYear(seasonsQuery.data[0])
+    }
+  }, [seasonsQuery.data, weekendQuery.data, year])
+
+  const meetingsQuery = useQuery({
+    queryKey: ['meetings', year],
+    queryFn: ({ signal }) => fetchLocalMeetings(year!, signal),
+    enabled: year != null,
+  })
+
   const seasons = seasonsQuery.data ?? []
   const meetings = meetingsQuery.data ?? []
   const weekend = weekendQuery.data
@@ -106,9 +125,16 @@ export function WeekendSwitcher({ currentMeetingKey, currentSessionKey, onClose
                     {weekendQuery.isLoading && (
                       <div className="rh-switcher-empty">loading sessions…</div>
                     )}
-                    {weekend && weekend.meeting_key === m.meeting_key &&
-                      weekend.sessions.map(({ session, source, datasets }) => {
+                    {weekend &&
+                      weekend.meeting_key === m.meeting_key &&
+                      weekend.sessions.map((weekendSession) => {
+                        const { session } = weekendSession
                         const active = session.session_key === currentSessionKey
+                        const state = resolveSessionState({
+                          weekendSession,
+                          context,
+                          now,
+                        })
                         return (
                           <button
                             key={session.session_key}
@@ -122,8 +148,11 @@ export function WeekendSwitcher({ currentMeetingKey, currentSessionKey, onClose
                             </span>
                             <span className="rh-switcher-sess-name">{session.session_name}</span>
                             <span className="rh-switcher-sess-cov mono">
-                              <span className={`cc-cov-dot cc-cov-${source}`} aria-hidden="true" />
-                              {formatCoverageHint(datasets)}
+                              <span
+                                className={`cc-cov-dot ${sessionStateDotClass(state)}`}
+                                aria-hidden="true"
+                              />
+                              {sessionStateLabel(state)}
                             </span>
                           </button>
                         )

frontend/src/components/live/LiveHandoff.tsx

@@ -0,0 +1,263 @@
+import { Archive, ChevronRight, Flag, Radio } from 'lucide-react'
+import type { LiveTimingRow } from '../../lib/live'
+import { driverCode } from '../../lib/live'
+import type { TransportHealth } from '../../lib/liveState'
+import { feedHealthLabel } from '../../lib/liveState'
+import type { ContextSession, WeekendContext } from '../../types'
+import { analysisSessionKey } from '../../lib/weekendContext'
+import { formatSessionScheduleTime } from '../../lib/schedule'
+
+interface Props {
+  /** 'settling' immediately after a session; 'inactive' when nothing is live. */
+  phase: 'settling' | 'inactive'
+  transport: TransportHealth
+  /** Canonical weekend context (issue #72). May be undefined before it loads. */
+  context: WeekendContext | undefined
+  /** Top rows of the final snapshot (settling only), already position-sorted. */
+  rows: LiveTimingRow[]
+  capturedAt?: string | null
+  hasArchive: boolean
+  onViewArchive: () => void
+}
+
+function formatCapturedAt(capturedAt: string | null | undefined): string {
+  if (!capturedAt) return ''
+  const date = new Date(capturedAt)
+  if (Number.isNaN(date.getTime())) return ''
+  return date.toLocaleString()
+}
+
+function sessionKeyOf(session: ContextSession | undefined): number | undefined {
+  const key = session?.session.session_key
+  return key && key > 0 ? key : undefined
+}
+
+/**
+ * Fully ingested analysis (local_analysis === complete). Stricter than
+ * hasLocalAnalysis, which also treats partial as link-worthy — Live polling
+ * and "ready" chrome wait for the complete state.
+ */
+export function analysisIsReady(session: ContextSession | undefined): boolean {
+  return session?.availability?.local_analysis === 'complete'
+}
+
+/**
+ * Analysis target for the Live handoff surface.
+ *
+ * Settling must follow the just-finished session (`previous_completed_session`).
+ * The canonical backend can mark that session archive-complete while leaving
+ * `default_analysis_session` on an older already-ingested practice/qualifying —
+ * preferring default here would link/poll/label the wrong race.
+ *
+ * Inactive keeps the shared default-first preference via analysisSessionKey.
+ */
+export function handoffAnalysisSession(
+  context: WeekendContext | undefined,
+  phase: 'settling' | 'inactive',
+): ContextSession | undefined {
+  if (!context) return undefined
+  if (phase === 'settling') {
+    if (sessionKeyOf(context.previous_completed_session)) {
+      return context.previous_completed_session
+    }
+    return sessionKeyOf(context.default_analysis_session)
+      ? context.default_analysis_session
+      : undefined
+  }
+  const key = analysisSessionKey(context)
+  if (!key) return undefined
+  if (context.default_analysis_session?.session.session_key === key) {
+    return context.default_analysis_session
+  }
+  return context.previous_completed_session
+}
+
+/**
+ * Keep polling weekend-context while the just-finished session (or, absent
+ * that, the default analysis session) is still ingesting. An older ready
+ * default must not stop the settle→ready transition.
+ */
+export function shouldPollHandoffAnalysis(context: WeekendContext | undefined): boolean {
+  if (!context) return true
+  const previous = context.previous_completed_session
+  if (sessionKeyOf(previous) && !analysisIsReady(previous)) return true
+  const fallback = context.default_analysis_session
+  if (sessionKeyOf(fallback) && !analysisIsReady(fallback)) return true
+  return !sessionKeyOf(previous) && !sessionKeyOf(fallback)
+}
+
+export function LiveHandoff({
+  phase,
+  transport,
+  context,
+  rows,
+  capturedAt,
+  hasArchive,
+  onViewArchive,
+}: Props) {
+  const isSettling = phase === 'settling'
+  const testid = isSettling ? 'live-settling' : 'live-inactive'
+  const capturedLabel = formatCapturedAt(capturedAt)
+
+  const focusName = context?.focus_meeting?.meeting_name
+  const activeName = context?.active_session?.meeting?.meeting_name
+  const title = focusName || activeName || 'Live Timing'
+  const topRows = rows.slice(0, 3)
+
+  const analysis = handoffAnalysisSession(context, phase)
+  const analysisKey = sessionKeyOf(analysis)
+  const analysisName = analysis?.session.session_name || 'session'
+  const analysisReady = analysisIsReady(analysis)
+
+  const next = context?.next_session
+  const previous = context?.previous_completed_session
+  // Avoid a duplicate recap card when previous == the analysis target.
+  const showRecap =
+    previous && previous.session.session_key !== analysisKey && previous.session.session_key !== 0
+
+  return (
+    <section className={`live-handoff live-handoff-${phase}`} data-testid={testid}>
+      <header className="live-handoff-head">
+        <span className="live-handoff-eyebrow mono">
+          {isSettling ? (
+            <>
+              <Flag size={13} /> SESSION SETTLING
+            </>
+          ) : (
+            <>
+              <Radio size={13} /> NO LIVE SESSION
+            </>
+          )}
+        </span>
+        <h1 className="live-handoff-title">{title}</h1>
+        {isSettling && capturedLabel && (
+          <p className="live-handoff-captured mono" data-testid="live-handoff-captured">
+            Final feed snapshot captured {capturedLabel}
+          </p>
+        )}
+        {!isSettling && (
+          <p className="live-handoff-sub">
+            The timing feed is quiet between sessions. Here&apos;s where the weekend stands.
+          </p>
+        )}
+        <span className={`live-feed-health live-feed-${transport} live-handoff-feed`}>
+          <span className="live-feed-dot" aria-hidden="true" />
+          {feedHealthLabel(transport)}
+        </span>
+      </header>
+
+      {isSettling && topRows.length > 0 && (
+        <div className="live-handoff-snapshot" data-testid="live-handoff-snapshot">
+          <span className="live-handoff-snapshot-label mono">Provisional order at chequered</span>
+          <ol className="live-handoff-order">
+            {topRows.map((row) => (
+              <li key={row.RacingNumber}>
+                <span className="mono">P{row.Position}</span>
+                <span className="live-handoff-code">{driverCode(row)}</span>
+              </li>
+            ))}
+          </ol>
+        </div>
+      )}
+
+      <div className="live-handoff-actions">
+        {analysisKey ? (
+          <a
+            className="live-handoff-action live-handoff-primary"
+            href={`/race-hub?session_key=${analysisKey}`}
+            data-testid="live-handoff-analysis"
+            data-ready={analysisReady ? 'true' : 'false'}
+          >
+            <span className="live-handoff-action-body">
+              <span className="live-handoff-action-label">
+                {isSettling ? `Open ${analysisName} analysis` : `Open ${analysisName} in Race Hub`}
+              </span>
+              <span className="live-handoff-action-meta mono">
+                {analysisReady
+                  ? 'Full timing, strategy & story ready'
+                  : isSettling
+                    ? 'Settling — analysis will fill in as data ingests'
+                    : 'Analysis will fill in as data ingests'}
+              </span>
+            </span>
+            <ChevronRight size={18} />
+          </a>
+        ) : (
+          <div
+            className="live-handoff-action live-handoff-pending"
+            data-testid="live-handoff-analysis-pending"
+          >
+            <span className="live-handoff-action-body">
+              <span className="live-handoff-action-label">Analysis not ready yet</span>
+              <span className="live-handoff-action-meta mono">
+                The completed session will appear in Race Hub once it is ingested.
+              </span>
+            </span>
+          </div>
+        )}
+
+        {next && (
+          <div className="live-handoff-action live-handoff-next" data-testid="live-handoff-next">
+            <span className="live-handoff-action-body">
+              <span className="live-handoff-action-label">
+                Up next · {next.session.session_name}
+              </span>
+              <span className="live-handoff-action-meta mono">
+                {formatSessionScheduleTime(next.session.date_start)}
+              </span>
+            </span>
+          </div>
+        )}
+
+        {showRecap && (
+          <a
+            className="live-handoff-action"
+            href={`/race-hub?session_key=${previous!.session.session_key}`}
+            data-testid="live-handoff-recap"
+          >
+            <span className="live-handoff-action-body">
+              <span className="live-handoff-action-label">
+                Recap · {previous!.session.session_name}
+              </span>
+              <span className="live-handoff-action-meta mono">
+                Review the last completed session
+              </span>
+            </span>
+            <ChevronRight size={18} />
+          </a>
+        )}
+
+        {hasArchive && (
+          <button
+            type="button"
+            className="live-handoff-action live-handoff-archive-btn"
+            onClick={onViewArchive}
+            data-testid="live-handoff-archive"
+          >
+            <span className="live-handoff-action-body">
+              <span className="live-handoff-action-label">
+                <Archive size={14} /> View full timing (read-only)
+              </span>
+              <span className="live-handoff-action-meta mono">
+                Frozen final snapshot — no live updates
+              </span>
+            </span>
+            <ChevronRight size={18} />
+          </button>
+        )}
+
+        {!analysisKey && !next && !showRecap && !hasArchive && (
+          <div className="live-handoff-fallback" data-testid="live-handoff-fallback">
+            <a href="/" className="live-handoff-action">
+              <span className="live-handoff-action-body">
+                <span className="live-handoff-action-label">Weekend</span>
+                <span className="live-handoff-action-meta mono">Weekend schedule &amp; standings</span>
+              </span>
+              <ChevronRight size={18} />
+            </a>
+          </div>
+        )}
+      </div>
+    </section>
+  )
+}

frontend/src/components/live/SessionBanner.tsx

@@ -1,30 +1,60 @@
 import type { LiveStreamData } from '../../types'
 import type { LiveTimingRow } from '../../lib/live'
 import { extrapolateClock, liveSessionDisplay } from '../../lib/live'
+import type { LivePhase, TransportHealth } from '../../lib/liveState'
+import { feedHealthLabel } from '../../lib/liveState'
 import { WeatherStrip } from './WeatherStrip'
 
 interface Props {
-  isLive: boolean
-  isArchive?: boolean
+  /** Which of the live phases we are rendering: 'live' | 'disconnected' | 'archive'. */
+  phase: LivePhase
   snapshot: LiveStreamData
   rows: LiveTimingRow[]
-  connection: 'connected' | 'connecting' | 'disconnected' | 'error'
+  transport: TransportHealth
   now: number
+  /** ISO capture time — required for archive, shown as the timestamp of record. */
+  capturedAt?: string | null
 }
 
-export function SessionBanner({ isLive, isArchive = false, snapshot, rows, connection, now }: Props) {
+function formatCapturedAt(capturedAt: string | null | undefined): string {
+  if (!capturedAt) return ''
+  const date = new Date(capturedAt)
+  if (Number.isNaN(date.getTime())) return ''
+  return date.toLocaleString()
+}
+
+export function SessionBanner({ phase, snapshot, rows, transport, now, capturedAt }: Props) {
   const session = snapshot.Session
-  const clock = extrapolateClock(snapshot.Clock, snapshot.ClockRefTime, snapshot.ClockExtrapolating, now)
+  const isArchive = phase === 'archive'
+  const isLiveSession = phase === 'live' || phase === 'disconnected'
+  // Archive is a frozen single frame: never extrapolate a running clock for it.
+  const clock = isArchive
+    ? ''
+    : extrapolateClock(snapshot.Clock, snapshot.ClockRefTime, snapshot.ClockExtrapolating, now)
   const display = liveSessionDisplay(session, rows)
   const atRiskLabel =
     display.atRiskStart && display.atRiskEnd ? `P${display.atRiskStart}-P${display.atRiskEnd} at risk` : ''
-  const stateLabel = isLive ? 'live' : isArchive ? 'archive' : 'stale'
+  const capturedLabel = formatCapturedAt(capturedAt)
 
   return (
-    <section className="live-banner">
+    <section className={`live-banner${isArchive ? ' live-banner-archive' : ''}`} data-testid="live-banner">
       <div className="live-banner-row">
         <div className="live-banner-main">
-          <span className={`live-conn live-conn-${connection}`}>{connection}</span>
+          {isArchive ? (
+            <span className="live-session-flag live-session-flag-archive" data-testid="live-archive-flag">
+              ARCHIVE
+            </span>
+          ) : (
+            <span
+              className={`live-session-flag live-session-flag-live${
+                phase === 'disconnected' ? ' is-stale' : ''
+              }`}
+              data-testid="live-session-flag"
+            >
+              <span className="live-session-dot" aria-hidden="true" />
+              LIVE SESSION
+            </span>
+          )}
           <div>
             <h1>{session?.MeetingName || 'Live Timing'}</h1>
             <p>
@@ -33,15 +63,40 @@ export function SessionBanner({ isLive, isArchive = false, snapshot, rows, conne
           </div>
         </div>
         <div className="live-session-board">
+          {/* Feed health is strictly secondary and only present for a live session. */}
+          {isLiveSession && (
+            <span
+              className={`live-feed-health live-feed-${transport}`}
+              data-testid="live-feed-health"
+              title="Transport health — independent of session state"
+            >
+              <span className="live-feed-dot" aria-hidden="true" />
+              {feedHealthLabel(transport)}
+            </span>
+          )}
+          {isArchive ? (
+            <div className="live-archive-stamp" data-testid="live-archive-stamp">
+              <span className="live-archive-readonly mono">READ-ONLY</span>
+              {capturedLabel && <span className="live-archive-captured mono">captured {capturedLabel}</span>}
+            </div>
+          ) : (
+            <>
               {display.phaseLabel && <span className="live-phase-pill mono">{display.phaseLabel}</span>}
               <div className="live-clock mono" data-testid="live-clock">{clock || '--:--:--'}</div>
+            </>
+          )}
           <div className="live-banner-meta">
-            {display.advanceCount && <span>{display.advanceCount} advance</span>}
-            {atRiskLabel && <span>{atRiskLabel}</span>}
+            {!isArchive && display.advanceCount && <span>{display.advanceCount} advance</span>}
+            {!isArchive && atRiskLabel && <span>{atRiskLabel}</span>}
             <span>
               L<strong>{snapshot.CurrentLap || '-'}</strong>/<strong>{snapshot.TotalLaps || '-'}</strong>
             </span>
-            <span className={isLive ? 'live-state live-state-on' : 'live-state'}>{stateLabel}</span>
+            {!isArchive && (
+              <span className={phase === 'live' ? 'live-state live-state-on' : 'live-state'}>
+                {phase === 'live' ? 'live' : 'stale'}
+              </span>
+            )}
+            {isArchive && <span className="live-state live-state-archive">archive</span>}
           </div>
         </div>
       </div>

frontend/src/components/weekend/BetweenRacesView.tsx

@@ -0,0 +1,152 @@
+import { Link } from '@tanstack/react-router'
+import { ChevronRight, Flag as FlagIcon } from 'lucide-react'
+import type {
+  WeekendBriefingItem,
+  WeekendChampionshipImpact,
+  WeekendContext,
+  WeekendViewState,
+} from '../../types'
+import {
+  BriefingStrip,
+  ChampionshipImpactCard,
+  ChampionshipRoundStrip,
+  CountdownDisplay,
+  EventPodium,
+  Flag,
+} from './shared'
+import { analysisSessionKey, meetingIdentity } from '../../lib/weekendContext'
+import { parseScheduleTime } from '../../lib/schedule'
+
+const EYEBROW: Record<string, string> = {
+  between_weekends: 'Between races',
+  post_weekend: 'Post-weekend',
+  season_complete: 'Season complete',
+}
+
+function formatSessionLine(name: string | undefined, start: string | undefined): string {
+  if (!name) return 'Schedule to be confirmed'
+  const date = start ? parseScheduleTime(start) : null
+  if (!date) return name
+  const when = date.toLocaleString('en-GB', {
+    weekday: 'long',
+    hour: '2-digit',
+    minute: '2-digit',
+    hour12: false,
+  })
+  return `${name} · ${when}`
+}
+
+export function BetweenRacesView({
+  context,
+  now,
+  view,
+  championship,
+  briefing,
+}: {
+  context: WeekendContext
+  now: Date
+  view: WeekendViewState
+  championship?: WeekendChampionshipImpact
+  briefing: WeekendBriefingItem[]
+}) {
+  const eyebrow = EYEBROW[view] ?? 'Between races'
+
+  const previous = context.previous_completed_session
+  const previousMeeting = meetingIdentity(previous?.meeting ?? context.previous_meeting)
+  const nextMeeting = meetingIdentity(context.next_meeting)
+  const nextSession = context.next_session?.session
+  const analysisKey = analysisSessionKey(context)
+
+  return (
+    <div className="wk-between" data-testid="weekend-between-races" data-state={view}>
+      <div className="wk-eyebrow mono" data-testid="wk-eyebrow">{eyebrow}</div>
+
+      <div className="wk-top-grid">
+        {previousMeeting && (
+          <section className="wk-event-card wk-event-last" data-testid="wk-last-event">
+            <header className="wk-event-head">
+              <div className="wk-event-id">
+                <Flag code={previousMeeting.country_code} flag={previousMeeting.country_flag} />
+                <h2 className="wk-event-name">{previousMeeting.meeting_name}</h2>
+              </div>
+              <span className="wk-event-tag wk-tag-done mono">
+                <FlagIcon size={13} aria-hidden="true" /> Completed
+              </span>
+            </header>
+            <div className="wk-event-body">
+              <EventPodium sessionKey={analysisKey} />
+              <div className="wk-story-card">
+                <span className="wk-story-label">What decided it?</span>
+                {analysisKey ? (
+                  <Link
+                    to="/race-hub"
+                    search={{ session_key: analysisKey }}
+                    className="wk-cta wk-cta-primary"
+                    data-testid="wk-explore-race-story"
+                  >
+                    Explore Race Story <ChevronRight size={15} aria-hidden="true" />
+                  </Link>
+                ) : (
+                  <p className="wk-story-text" data-testid="wk-no-analysis">
+                    Analysis for this session is not available locally yet.
+                  </p>
+                )}
+              </div>
+            </div>
+          </section>
+        )}
+
+        {nextMeeting ? (
+          <section className="wk-event-card wk-event-next" data-testid="wk-next-event">
+            <header className="wk-event-head">
+              <div className="wk-event-id">
+                <Flag code={nextMeeting.country_code} flag={nextMeeting.country_flag} />
+                <h2 className="wk-event-name">{nextMeeting.meeting_name}</h2>
+              </div>
+              <span className="wk-event-tag wk-tag-next mono">Next event</span>
+            </header>
+            <div className="wk-next-body">
+              <CountdownDisplay target={nextSession?.date_start ?? nextMeeting.date_start} now={now} />
+              <div className="wk-next-session">
+                <span className="wk-next-label mono">Next session</span>
+                <span className="wk-next-value">
+                  {formatSessionLine(nextSession?.session_name, nextSession?.date_start)}
+                </span>
+              </div>
+              <Link to="/preview" className="wk-cta wk-cta-primary wk-cta-wide" data-testid="wk-prepare">
+                Prepare for {nextMeeting.short_name}
+                <ChevronRight size={15} aria-hidden="true" />
+              </Link>
+            </div>
+          </section>
+        ) : (
+          <section className="wk-event-card wk-event-next" data-testid="wk-season-complete-card">
+            <header className="wk-event-head">
+              <h2 className="wk-event-name">That&apos;s a wrap</h2>
+              <span className="wk-event-tag wk-tag-next mono">Off-season</span>
+            </header>
+            <div className="wk-next-body">
+              <p className="wk-season-complete-copy">
+                The {context.season} calendar is complete. Explore the season&apos;s races or revisit the championship
+                battle while the next schedule is confirmed.
+              </p>
+              <Link to="/explore" className="wk-cta wk-cta-primary wk-cta-wide" data-testid="wk-season-complete-explore">
+                Explore the season <ChevronRight size={15} aria-hidden="true" />
+              </Link>
+            </div>
+          </section>
+        )}
+      </div>
+
+      <div className="wk-mid-grid">
+        {championship && <ChampionshipImpactCard impact={championship} />}
+        <ChampionshipRoundStrip
+          round={context.championship_round}
+          total={context.total_championship_rounds}
+        />
+      </div>
+
+      {briefing.length > 0 && <BriefingStrip items={briefing} />}
+    </div>
+  )
+}

frontend/src/components/weekend/BetweenSessionsView.tsx

@@ -0,0 +1,86 @@
+import { Link } from '@tanstack/react-router'
+import { ChevronRight } from 'lucide-react'
+import type { WeekendBriefingItem, WeekendContext, WeekendViewState } from '../../types'
+import { BriefingStrip, CountdownDisplay, EventPodium, SessionRail, railNodes } from './shared'
+import { analysisSessionKey, meetingIdentity } from '../../lib/weekendContext'
+import { parseScheduleTime } from '../../lib/schedule'
+
+function nextSessionWhen(start: string | undefined): string {
+  const date = start ? parseScheduleTime(start) : null
+  if (!date) return 'Time to be confirmed'
+  return date.toLocaleString('en-GB', {
+    weekday: 'short',
+    hour: '2-digit',
+    minute: '2-digit',
+    hour12: false,
+  })
+}
+
+export function BetweenSessionsView({
+  context,
+  now,
+  view,
+  briefing,
+}: {
+  context: WeekendContext
+  now: Date
+  view: WeekendViewState
+  briefing: WeekendBriefingItem[]
+}) {
+  const settling = view === 'session_settling'
+  const focus = meetingIdentity(context.focus_meeting)
+  const previous = context.previous_completed_session
+  const previousName = previous?.session.session_name ?? 'Last session'
+  const next = context.next_session?.session
+  // Settling recap must open the just-finished session, not an older default.
+  const previousKey = previous?.session.session_key
+  const analysisKey =
+    settling && previousKey && previousKey > 0 ? previousKey : analysisSessionKey(context)
+  const nodes = railNodes(previous, context.active_session, context.next_session)
+
+  return (
+    <div className="wk-sessions" data-testid="weekend-between-sessions" data-state={view}>
+      <div className="wk-eyebrow mono" data-testid="wk-eyebrow">
+        {settling ? 'Session settling' : 'Between sessions'}
+      </div>
+
+      <header className="wk-sessions-head">
+        <h1 className="wk-sessions-title">{focus?.meeting_name ?? 'Race weekend'}</h1>
+        {focus?.circuit_short_name && <p className="wk-sessions-circuit mono">{focus.circuit_short_name}</p>}
+      </header>
+
+      <SessionRail nodes={nodes} />
+
+      {previous && (
+        <section className="wk-recap-card" data-testid="wk-last-session">
+          <span className="wk-recap-eyebrow mono">
+            {previousName} · {settling ? 'Settling' : 'Complete'}
+          </span>
+          <h2 className="wk-recap-title">What happened in {previousName}</h2>
+          <EventPodium sessionKey={analysisKey} />
+        </section>
+      )}
+
+      {next && (
+        <section className="wk-upnext-card" data-testid="wk-next-session">
+          <span className="wk-upnext-eyebrow mono">Up next</span>
+          <h2 className="wk-upnext-title">{next.session_name}</h2>
+          <CountdownDisplay target={next.date_start} now={now} compact />
+          <p className="wk-upnext-when mono">{nextSessionWhen(next.date_start)}</p>
+          {analysisKey && (
+            <Link
+              to="/race-hub"
+              search={{ session_key: analysisKey }}
+              className="wk-cta wk-cta-primary wk-cta-wide"
+              data-testid="wk-view-recap"
+            >
+              View {previousName} recap <ChevronRight size={15} aria-hidden="true" />
+            </Link>
+          )}
+        </section>
+      )}
+
+      {briefing.length > 0 && <BriefingStrip items={briefing} />}
+    </div>
+  )
+}

frontend/src/components/weekend/LiveHandoffView.tsx

@@ -0,0 +1,47 @@
+import { Link } from '@tanstack/react-router'
+import { ChevronRight, Radio } from 'lucide-react'
+import type { WeekendContext } from '../../types'
+import { EventPodium, Flag, SessionRail, railNodes } from './shared'
+import { analysisSessionKey, meetingIdentity } from '../../lib/weekendContext'
+
+export function LiveHandoffView({ context }: { context: WeekendContext }) {
+  const focus = meetingIdentity(context.focus_meeting ?? context.active_session?.meeting)
+  const active = context.active_session?.session
+  const previous = context.previous_completed_session
+  const previousName = previous?.session.session_name ?? 'Last session'
+  const analysisKey = analysisSessionKey(context)
+  const nodes = railNodes(previous, context.active_session, context.next_session)
+
+  return (
+    <div className="wk-live" data-testid="weekend-live" data-state="session_live">
+      <div className="wk-eyebrow mono" data-testid="wk-eyebrow">Session live</div>
+
+      <section className="wk-live-card" data-testid="wk-live-card">
+        <div className="wk-live-head">
+          <div className="wk-event-id">
+            <Flag code={focus?.country_code} flag={focus?.country_flag} />
+            <h1 className="wk-sessions-title">{focus?.meeting_name ?? 'Live session'}</h1>
+          </div>
+          <span className="wk-live-pulse" aria-hidden="true" />
+        </div>
+        {focus?.circuit_short_name && <p className="wk-sessions-circuit mono">{focus.circuit_short_name}</p>}
+        <p className="wk-live-lead">
+          {active?.session_name ? `${active.session_name} is on track now.` : 'A session is running now.'}
+        </p>
+        <Link to="/live" className="wk-cta wk-cta-primary wk-cta-wide" data-testid="wk-watch-live">
+          <Radio size={15} aria-hidden="true" /> Watch live timing <ChevronRight size={15} aria-hidden="true" />
+        </Link>
+      </section>
+
+      <SessionRail nodes={nodes} />
+
+      {previous && (
+        <section className="wk-recap-card" data-testid="wk-last-session">
+          <span className="wk-recap-eyebrow mono">{previousName} · Complete</span>
+          <h2 className="wk-recap-title">What happened in {previousName}</h2>
+          <EventPodium sessionKey={analysisKey} />
+        </section>
+      )}
+    </div>
+  )
+}

frontend/src/components/weekend/PreSessionView.tsx

@@ -0,0 +1,75 @@
+import { Link } from '@tanstack/react-router'
+import { ChevronRight } from 'lucide-react'
+import type { WeekendContext } from '../../types'
+import { RacePreviewPage } from '../../pages/RacePreviewPage'
+import { ChampionshipRoundStrip, CountdownDisplay, Flag, SessionRail, railNodes } from './shared'
+import { meetingIdentity } from '../../lib/weekendContext'
+import type { DataAvailability } from '../../lib/availability'
+
+/**
+ * PreSessionView folds the race preview surface into the Weekend home so there is
+ * no separate Preview destination. It reuses the existing preview page content and
+ * frames it with the next-session countdown and compact season navigation. It also
+ * backs the /preview alias, so saved preview links resolve here instead of looping.
+ *
+ * Canonical meeting/session identity is passed into Preview so the nested surface
+ * cannot independently re-resolve a different current weekend.
+ */
+export function PreSessionView({
+  context,
+  now,
+  shellAvailability = null,
+}: {
+  context: WeekendContext
+  now: Date
+  /** Weekend shell notice already shown — Preview dedupes only an equivalent kind. */
+  shellAvailability?: DataAvailability | null
+}) {
+  const meeting = context.next_meeting ?? context.focus_meeting
+  const identity = meetingIdentity(meeting)
+  const next = context.next_session?.session
+  const nextStart = next?.date_start ?? meeting?.date_start
+  const nodes = railNodes(
+    context.previous_completed_session,
+    context.active_session,
+    context.next_session,
+  )
+
+  return (
+    <div className="wk-pre" data-testid="weekend-pre-session" data-state="pre_session">
+      <div className="wk-eyebrow mono" data-testid="wk-eyebrow">Pre-session</div>
+
+      {identity && (
+        <header className="wk-pre-head" data-testid="wk-pre-head">
+          <div className="wk-event-id">
+            <Flag code={identity.country_code} flag={identity.country_flag} />
+            <h1 className="wk-sessions-title">{identity.meeting_name}</h1>
+          </div>
+          <div className="wk-pre-countdown">
+            <span className="wk-next-label mono">{next?.session_name ?? 'Next session'}</span>
+            <CountdownDisplay target={nextStart} now={now} />
+          </div>
+          <Link to="/live" className="wk-cta wk-cta-ghost" data-testid="wk-pre-live">
+            Live timing <ChevronRight size={14} aria-hidden="true" />
+          </Link>
+        </header>
+      )}
+
+      {nodes.length > 0 && <SessionRail nodes={nodes} />}
+
+      <div className="wk-pre-preview" data-testid="wk-pre-preview">
+        <RacePreviewPage
+          embedded
+          meeting={meeting}
+          season={context.season ?? meeting?.year}
+          shellAvailability={shellAvailability}
+        />
+      </div>
+
+      <ChampionshipRoundStrip
+        round={context.championship_round}
+        total={context.total_championship_rounds}
+      />
+    </div>
+  )
+}

frontend/src/components/weekend/StatusViews.tsx

@@ -0,0 +1,65 @@
+import { Link } from '@tanstack/react-router'
+import { userFacingError } from '../../lib/fetch'
+
+export function WeekendLoading() {
+  return (
+    <div className="wk-status wk-status-loading" data-testid="weekend-loading" aria-busy="true">
+      <span className="wk-status-eyebrow mono">box-box · weekend</span>
+      <p className="wk-status-title">Reading the weekend…</p>
+    </div>
+  )
+}
+
+export function WeekendError({
+  error,
+  message,
+  onRetry,
+  retrying = false,
+}: {
+  error?: unknown
+  message?: string
+  onRetry?: () => void
+  retrying?: boolean
+}) {
+  const resolved =
+    message ??
+    (error != null ? userFacingError(error) : 'Something went wrong loading the weekend context.')
+
+  return (
+    <div className="wk-status wk-status-error" data-testid="weekend-error" role="alert">
+      <span className="wk-status-eyebrow mono">box-box · weekend</span>
+      <p className="wk-status-title">Weekend unavailable</p>
+      <p className="wk-status-sub">{resolved}</p>
+      {typeof onRetry === 'function' && (
+        <div className="wk-status-actions">
+          <button
+            type="button"
+            className="wk-cta wk-cta-primary"
+            onClick={onRetry}
+            disabled={retrying}
+            aria-busy={retrying || undefined}
+            data-testid="weekend-retry"
+          >
+            {retrying ? 'Retrying…' : 'Retry'}
+          </button>
+        </div>
+      )}
+    </div>
+  )
+}
+
+export function WeekendLimited({ message, season }: { message?: string; season?: number }) {
+  return (
+    <div className="wk-status wk-status-limited" data-testid="weekend-limited">
+      <span className="wk-status-eyebrow mono">box-box · weekend</span>
+      <p className="wk-status-title">Nothing to show yet</p>
+      <p className="wk-status-sub">
+        {message ?? `No weekend data for the ${season || 'current'} season is available right now.`}
+      </p>
+      <div className="wk-status-actions">
+        <Link to="/live" className="wk-cta wk-cta-ghost">Live timing</Link>
+        <Link to="/explore" className="wk-cta wk-cta-ghost">Explore</Link>
+      </div>
+    </div>
+  )
+}

frontend/src/components/weekend/WeekendFocusBanner.tsx

@@ -0,0 +1,65 @@
+import { Link } from '@tanstack/react-router'
+import { useQuery } from '@tanstack/react-query'
+import { ChevronRight } from 'lucide-react'
+import { fetchWeekend } from '../../api'
+import { meetingIdentity } from '../../lib/weekendContext'
+
+/**
+ * Restores Race Hub → Weekend meeting/session context from the URL search
+ * contract. Deep-linkable and reload-safe — no hidden component memory.
+ */
+export function WeekendFocusBanner({
+  meetingKey,
+  sessionKey,
+}: {
+  meetingKey?: number
+  sessionKey?: number
+}) {
+  const hasFocus = (meetingKey != null && meetingKey > 0) || (sessionKey != null && sessionKey > 0)
+  const weekendQuery = useQuery({
+    queryKey: ['weekend', meetingKey],
+    queryFn: () => fetchWeekend(meetingKey!),
+    enabled: meetingKey != null && meetingKey > 0,
+    staleTime: 60_000,
+  })
+
+  if (!hasFocus) return null
+
+  const weekend = weekendQuery.data
+  const meeting = meetingIdentity(weekend?.meeting)
+  const session = weekend?.sessions.find((s) => s.session.session_key === sessionKey)?.session
+  const meetingLabel = meeting?.meeting_name ?? (meetingKey ? `Meeting ${meetingKey}` : 'Selected weekend')
+  const sessionLabel = session?.session_name ?? (sessionKey ? `Session ${sessionKey}` : null)
+
+  return (
+    <section
+      className="wk-focus"
+      data-testid="wk-focus-context"
+      data-meeting-key={meetingKey ?? undefined}
+      data-session-key={sessionKey ?? undefined}
+      aria-label="Selected weekend context"
+    >
+      <div className="wk-focus-copy">
+        <span className="wk-focus-eyebrow mono">From Race Hub</span>
+        <h2 className="wk-focus-title" data-testid="wk-focus-meeting">
+          {meetingLabel}
+        </h2>
+        {sessionLabel && (
+          <p className="wk-focus-session" data-testid="wk-focus-session">
+            Selected session · {sessionLabel}
+          </p>
+        )}
+      </div>
+      {sessionKey != null && sessionKey > 0 && (
+        <Link
+          to="/race-hub"
+          search={{ session_key: sessionKey }}
+          className="wk-cta wk-cta-primary wk-focus-cta"
+          data-testid="wk-return-analysis"
+        >
+          Continue analysis <ChevronRight size={15} aria-hidden="true" />
+        </Link>
+      )}
+    </section>
+  )
+}

frontend/src/components/weekend/shared.tsx

@@ -0,0 +1,277 @@
+import { useQuery } from '@tanstack/react-query'
+import { Link } from '@tanstack/react-router'
+import { fetchRaceHub } from '../../api'
+import { countryFlag } from '../../lib/gpIdentity'
+import { parseScheduleTime } from '../../lib/schedule'
+import { podiumFromResults } from '../../lib/weekendContext'
+import { teamColor } from '../../utils'
+import type {
+  ContextSession,
+  WeekendChampionshipImpact,
+  WeekendBriefingItem,
+  WeekendPodiumEntry,
+} from '../../types'
+
+export function Flag({ code, flag }: { code?: string; flag?: string }) {
+  const glyph = countryFlag({ country_code: code ?? '', country_flag: flag ?? '' })
+  if (!glyph) return null
+  return <span className="wk-flag" aria-hidden="true">{glyph}</span>
+}
+
+interface CountdownParts {
+  days: number
+  hours: number
+  minutes: number
+  seconds: number
+  reached: boolean
+}
+
+export function countdownParts(target: string | undefined, now: Date): CountdownParts | null {
+  const date = target ? parseScheduleTime(target) : null
+  if (!date) return null
+  const diff = date.getTime() - now.getTime()
+  const clamped = Math.max(0, diff)
+  const totalSeconds = Math.floor(clamped / 1000)
+  return {
+    days: Math.floor(totalSeconds / 86400),
+    hours: Math.floor((totalSeconds % 86400) / 3600),
+    minutes: Math.floor((totalSeconds % 3600) / 60),
+    seconds: totalSeconds % 60,
+    reached: diff <= 0,
+  }
+}
+
+export function CountdownDisplay({
+  target,
+  now,
+  compact,
+}: {
+  target: string | undefined
+  now: Date
+  compact?: boolean
+}) {
+  const parts = countdownParts(target, now)
+  if (!parts) {
+    return (
+      <span className="wk-countdown-tbc mono" data-testid="wk-countdown">
+        Schedule TBC
+      </span>
+    )
+  }
+  if (parts.reached) {
+    return <span className="wk-countdown-live" data-testid="wk-countdown">Starting now</span>
+  }
+  if (compact || parts.days === 0) {
+    const hh = String(parts.days * 24 + parts.hours).padStart(2, '0')
+    return (
+      <span className="wk-countdown-clock mono" data-testid="wk-countdown">
+        {hh}:{String(parts.minutes).padStart(2, '0')}:{String(parts.seconds).padStart(2, '0')}
+      </span>
+    )
+  }
+  return (
+    <span className="wk-countdown" data-testid="wk-countdown">
+      <span className="wk-count-unit"><b>{parts.days}</b>D</span>
+      <span className="wk-count-unit"><b>{String(parts.hours).padStart(2, '0')}</b>H</span>
+      <span className="wk-count-unit"><b>{String(parts.minutes).padStart(2, '0')}</b>M</span>
+    </span>
+  )
+}
+
+/**
+ * EventPodium fetches and renders the podium for a completed analysis session.
+ * When no analysable session key is available (e.g. an archived result with no
+ * local analysis), it renders an explicit empty state rather than fetching.
+ */
+export function EventPodium({ sessionKey }: { sessionKey?: number }) {
+  const enabled = typeof sessionKey === 'number' && sessionKey > 0
+  const query = useQuery({
+    queryKey: ['race-hub', sessionKey, 'podium'],
+    queryFn: () => fetchRaceHub(sessionKey as number),
+    enabled,
+    staleTime: 60_000,
+  })
+
+  const podium: WeekendPodiumEntry[] = podiumFromResults(query.data?.results ?? [])
+
+  if (!enabled) {
+    return (
+      <div className="wk-podium-empty" data-testid="wk-podium-empty">
+        Result not available yet.
+      </div>
+    )
+  }
+
+  if (podium.length === 0) {
+    return (
+      <div className="wk-podium-empty" data-testid="wk-podium-empty">
+        {query.isLoading ? 'Loading result…' : 'Result not available yet.'}
+      </div>
+    )
+  }
+
+  return (
+    <ol className="wk-podium" data-testid="wk-podium">
+      {podium.map((p) => (
+        <li key={p.driver_number} className="wk-podium-row" style={{ ['--wk-team' as string]: teamColor(p.team_colour) }}>
+          <span className="wk-podium-pos mono">{p.position}</span>
+          <span className="wk-podium-code">{p.name_acronym}</span>
+          <span className="wk-podium-gap mono">{p.gap}</span>
+        </li>
+      ))}
+    </ol>
+  )
+}
+
+export function ChampionshipImpactCard({ impact }: { impact: WeekendChampionshipImpact }) {
+  const leader = impact.leaders[0]
+  return (
+    <section className="wk-champ" data-testid="wk-champ-impact">
+      <header className="wk-card-head">
+        <span className="wk-card-title">Championship impact</span>
+        <Link to="/championship" className="wk-card-link">Standings →</Link>
+      </header>
+      <ol className="wk-champ-list">
+        {impact.leaders.map((d) => {
+          const gap = leader && d.position !== 1 ? leader.points - d.points : 0
+          return (
+            <li key={d.driver_number} className="wk-champ-row" style={{ ['--wk-team' as string]: teamColor(d.team_colour) }}>
+              <span className="wk-champ-pos mono">{d.position}</span>
+              <span className="wk-champ-code">{d.name_acronym}</span>
+              <span className="wk-champ-pts mono">{d.points}</span>
+              <span className="wk-champ-gap mono">{d.position === 1 ? '—' : `-${gap}`}</span>
+            </li>
+          )
+        })}
+      </ol>
+      {impact.note && <p className="wk-champ-note">{impact.note}</p>}
+    </section>
+  )
+}
+
+export function BriefingStrip({ items }: { items: WeekendBriefingItem[] }) {
+  if (items.length === 0) return null
+  return (
+    <section className="wk-briefing" data-testid="wk-briefing">
+      <header className="wk-card-head">
+        <span className="wk-card-title">Since the chequered flag</span>
+        <Link to="/briefing" className="wk-card-link">All briefing →</Link>
+      </header>
+      <ul className="wk-briefing-list">
+        {items.map((item) => (
+          <li key={item.url} className="wk-briefing-item">
+            <a href={item.url} target="_blank" rel="noreferrer" className="wk-briefing-link">
+              {item.category && <span className="wk-briefing-cat mono">{item.category}</span>}
+              <span className="wk-briefing-title">{item.title}</span>
+              <span className="wk-briefing-source mono">{item.source}</span>
+            </a>
+          </li>
+        ))}
+      </ul>
+    </section>
+  )
+}
+
+/**
+ * ChampionshipRoundStrip is a compact, progressively-disclosed round indicator.
+ * The canonical contract exposes only the current round and total, so the strip
+ * shows "Round N of M" and links out to Explore for the full calendar rather than
+ * reintroducing the whole calendar on the Weekend home.
+ */
+export function ChampionshipRoundStrip({ round, total }: { round: number; total: number }) {
+  if (round <= 0 || total <= 0) return null
+  const pct = Math.min(100, Math.round((round / total) * 100))
+  return (
+    <section className="wk-season-nav" data-testid="wk-season-nav" aria-label="Season progress">
+      <div className="wk-season-progress">
+        <div className="wk-season-progress-head">
+          <span className="wk-card-title">Season progress</span>
+          <Link to="/explore" className="wk-card-link" data-testid="wk-season-explore">
+            Full calendar →
+          </Link>
+        </div>
+        <div
+          className="wk-season-bar"
+          role="progressbar"
+          aria-valuenow={round}
+          aria-valuemin={1}
+          aria-valuemax={total}
+          aria-label={`Round ${round} of ${total}`}
+        >
+          <span className="wk-season-bar-fill" style={{ width: `${pct}%` }} aria-hidden="true" />
+        </div>
+        <p className="wk-season-progress-label mono">
+          Round {round} of {total}
+        </p>
+      </div>
+    </section>
+  )
+}
+
+interface TimelineNode {
+  key: string
+  session_name: string
+  status: 'done' | 'live' | 'next'
+}
+
+/**
+ * SessionRail renders the previous/active/next sessions the canonical context
+ * exposes as a compact three-node rail. It is intentionally derived only from the
+ * canonical refs — the contract does not enumerate a full weekend session list.
+ */
+export function SessionRail({ nodes }: { nodes: TimelineNode[] }) {
+  if (nodes.length === 0) return null
+  return (
+    <ol className="wk-timeline" data-testid="wk-timeline" role="list">
+      {nodes.map((n) => (
+        <li key={n.key} className={`wk-timeline-node wk-timeline-${n.status}`} role="listitem">
+          <span className="wk-timeline-dot" aria-hidden="true" />
+          <span className="wk-timeline-name">{shortSessionName(n.session_name)}</span>
+          <span className="wk-timeline-state mono">{stateLabel(n.status)}</span>
+        </li>
+      ))}
+    </ol>
+  )
+}
+
+/** Build the compact session rail from the canonical previous/active/next refs. */
+export function railNodes(
+  previous: ContextSession | undefined,
+  active: ContextSession | undefined,
+  next: ContextSession | undefined,
+): TimelineNode[] {
+  const nodes: TimelineNode[] = []
+  if (previous?.session.session_name) {
+    nodes.push({ key: `prev-${previous.session.session_key}`, session_name: previous.session.session_name, status: 'done' })
+  }
+  if (active?.session.session_name) {
+    nodes.push({ key: `live-${active.session.session_key}`, session_name: active.session.session_name, status: 'live' })
+  }
+  if (next?.session.session_name) {
+    nodes.push({ key: `next-${next.session.session_key}`, session_name: next.session.session_name, status: 'next' })
+  }
+  return nodes
+}
+
+function shortSessionName(name: string): string {
+  const map: Record<string, string> = {
+    'Practice 1': 'FP1',
+    'Practice 2': 'FP2',
+    'Practice 3': 'FP3',
+    Qualifying: 'Quali',
+    'Sprint Qualifying': 'SQ',
+    'Sprint Shootout': 'SQ',
+  }
+  return map[name] ?? name
+}
+
+function stateLabel(status: TimelineNode['status']): string {
+  switch (status) {
+    case 'done':
+      return 'Complete'
+    case 'live':
+      return 'Live'
+    default:
+      return 'Next'
+  }
+}

frontend/src/hooks/useWeekendContext.ts

@@ -0,0 +1,140 @@
+import { useEffect, useMemo, useState } from 'react'
+import { useQuery } from '@tanstack/react-query'
+import { fetchChampionshipHub, fetchNews, fetchWeekendContext } from '../api'
+import { weekendContextNotice, type DataAvailability } from '../lib/availability'
+import { championshipImpact, briefingItems } from '../lib/weekendContext'
+import type {
+  WeekendChampionshipImpact,
+  WeekendBriefingItem,
+  WeekendContext,
+} from '../types'
+
+export type WeekendLoadState = 'loading' | 'error' | 'ready'
+
+export interface UseWeekendContextResult {
+  /** Canonical context, present only when loadState === 'ready'. */
+  context: WeekendContext | null
+  loadState: WeekendLoadState
+  error?: Error
+  /** Supplementary championship movers (not part of the #72 contract). */
+  championship?: WeekendChampionshipImpact
+  /** Supplementary briefing items (not part of the #72 contract). */
+  briefing: WeekendBriefingItem[]
+  /** Non-blocking availability notice from reported context freshness/headers. */
+  availabilityNotice: DataAvailability | null
+  /** True when championship or news supplements failed while context succeeded. */
+  supplementsLimited: boolean
+  now: Date
+  /** Refetch canonical context and/or failed supplements as appropriate. */
+  refetch: () => void
+  /** True while a relevant refetch is in flight. */
+  isFetching: boolean
+}
+
+/**
+ * useWeekendContext reads the canonical /api/v1/weekend-context endpoint as the
+ * single source of truth for the Weekend home. When the canonical read succeeds
+ * it layers on two pieces of supplementary data that the contract intentionally
+ * omits — championship movers and the paddock briefing — and nothing else.
+ *
+ * It deliberately does NOT fan out to season / meetings / per-weekend / OpenF1
+ * session / live-state queries: those would defeat the local-first canonical read
+ * model and can hit the rate-limited OpenF1 REST surface during active sessions.
+ * Supplementary queries are gated on a successful canonical read so a failing or
+ * pending endpoint issues no extra requests.
+ */
+export function useWeekendContext(): UseWeekendContextResult {
+  const [now, setNow] = useState(() => Date.now())
+  useEffect(() => {
+    const timer = window.setInterval(() => setNow(Date.now()), 1000)
+    return () => window.clearInterval(timer)
+  }, [])
+  const nowDate = useMemo(() => new Date(now), [now])
+
+  const contextQuery = useQuery({
+    queryKey: ['weekend-context'],
+    queryFn: ({ signal }) => fetchWeekendContext(signal),
+    staleTime: 30_000,
+  })
+
+  const canonical = contextQuery.data ?? null
+  const canonicalReady = canonical != null
+  const season = canonical?.season
+
+  // Supplementary data — only fetched once the canonical context has resolved,
+  // so a pending/failed canonical read never triggers a request fan-out.
+  const championshipQuery = useQuery({
+    queryKey: ['championship-hub', season ?? 'current'],
+    queryFn: ({ signal }) => fetchChampionshipHub(season, signal),
+    enabled: canonicalReady,
+    staleTime: 60_000,
+  })
+
+  const newsQuery = useQuery({
+    queryKey: ['news', 6],
+    queryFn: ({ signal }) => fetchNews(6, undefined, signal),
+    enabled: canonicalReady,
+    staleTime: 60_000,
+  })
+
+  const championship = useMemo(
+    () => championshipImpact(championshipQuery.data),
+    [championshipQuery.data],
+  )
+  const briefing = useMemo(() => briefingItems(newsQuery.data ?? []), [newsQuery.data])
+
+  const availabilityNotice = useMemo(
+    () => (canonical ? weekendContextNotice(canonical) : null),
+    [canonical],
+  )
+
+  // Keep Limited visible while a failed supplement is refetching so Retry can
+  // expose disabled/aria-busy. React Query v5 clears isError during that refetch.
+  const supplementDegraded = (q: {
+    isError: boolean
+    isFetching: boolean
+    isFetched: boolean
+    data: unknown
+  }) => q.isError || (q.isFetching && q.isFetched && q.data == null)
+
+  const supplementsLimited =
+    canonicalReady &&
+    (supplementDegraded(championshipQuery) || supplementDegraded(newsQuery))
+
+  let loadState: WeekendLoadState = 'loading'
+  if (contextQuery.isError) loadState = 'error'
+  else if (canonicalReady) loadState = 'ready'
+
+  const refetch = () => {
+    if (!canonicalReady) {
+      if (!contextQuery.isFetching) void contextQuery.refetch()
+      return
+    }
+    // Freshness notice Retry refreshes the canonical context.
+    if (availabilityNotice && !contextQuery.isFetching) {
+      void contextQuery.refetch()
+    }
+    // Limited Retry must hit the failed supplements — not merely context.
+    // Gate on degraded (error or in-flight post-error refetch), not isError alone.
+    if (championshipQuery.isError && !championshipQuery.isFetching) {
+      void championshipQuery.refetch()
+    }
+    if (newsQuery.isError && !newsQuery.isFetching) {
+      void newsQuery.refetch()
+    }
+  }
+
+  return {
+    context: canonical,
+    loadState,
+    error: contextQuery.error instanceof Error ? contextQuery.error : undefined,
+    championship,
+    briefing,
+    availabilityNotice,
+    supplementsLimited,
+    now: nowDate,
+    refetch,
+    isFetching:
+      contextQuery.isFetching || championshipQuery.isFetching || newsQuery.isFetching,
+  }
+}

frontend/src/lib/availability.ts

@@ -0,0 +1,135 @@
+import { getResponseAvailability, type ResponseAvailability } from './fetch'
+import type { ContextSession, WeekendContext } from '../types'
+
+/** Shared Weekend Context terminology for coverage / availability indicators. */
+export type DataAvailability = 'local' | 'partial' | 'stale' | 'archive' | 'limited' | 'missing'
+
+/** Freshness values that warrant a non-blocking DataNotice. */
+const NOTICE_FRESHNESS = new Set<string>(['stale', 'partial', 'local', 'limited', 'archive'])
+
+/**
+ * Product-impact severity for aggregating conflicting reported freshness.
+ * Higher wins so routine Local cannot mask Limited/Partial/Stale/Archive.
+ */
+const NOTICE_SEVERITY: Record<DataAvailability, number> = {
+  local: 1,
+  archive: 2,
+  stale: 3,
+  partial: 4,
+  limited: 5,
+  missing: 6,
+}
+
+/**
+ * Map a reported freshness string onto shared DataNotice vocabulary.
+ * Returns null for unreported / routine-success values (`fresh`, `live`, …).
+ * Never invents stale from React Query staleTime.
+ */
+export function noticeFromFreshness(
+  freshness: string | undefined | null,
+  opts?: { includeLocal?: boolean },
+): DataAvailability | null {
+  if (!freshness) return null
+  const includeLocal = opts?.includeLocal ?? true
+  if (freshness === 'local' && !includeLocal) return null
+  if (!NOTICE_FRESHNESS.has(freshness)) return null
+  return freshness as DataAvailability
+}
+
+/** Prefer header freshness, then optional typed payload freshness. */
+export function noticeFromResponse(
+  data: unknown,
+  opts?: { includeLocal?: boolean; fallbackFreshness?: string },
+): DataAvailability | null {
+  const meta = getResponseAvailability(data)
+  return (
+    noticeFromFreshness(meta?.freshness, opts) ??
+    noticeFromFreshness(opts?.fallbackFreshness, opts)
+  )
+}
+
+/**
+ * Pick the worst (highest product-impact) reported notice among sources.
+ * Equivalent kinds collapse to one; Local never masks a stronger disclosure.
+ */
+export function aggregateNotices(
+  notices: Array<DataAvailability | null | undefined>,
+): DataAvailability | null {
+  let worst: DataAvailability | null = null
+  for (const notice of notices) {
+    if (!notice) continue
+    if (!worst || NOTICE_SEVERITY[notice] > NOTICE_SEVERITY[worst]) {
+      worst = notice
+    }
+  }
+  return worst
+}
+
+export function noticeMessage(kind: DataAvailability): string {
+  switch (kind) {
+    case 'stale':
+      return 'Showing stale cached data. Retry to refresh.'
+    case 'partial':
+      return 'Coverage is partial for this view.'
+    case 'local':
+      return 'Showing local season data.'
+    case 'limited':
+      return 'Some optional details are unavailable. Core data is still shown.'
+    case 'archive':
+      return 'Showing an archived snapshot.'
+    case 'missing':
+      return 'Some expected data is missing.'
+  }
+}
+
+/**
+ * Session whose state the Weekend shell is presenting — mirrors backend
+ * focusedContextSession so an older terminal session never overrides focus.
+ */
+export function focusedContextSession(context: WeekendContext): ContextSession | undefined {
+  if (context.active_session) return context.active_session
+  if (!context.focus_meeting) return undefined
+  const focusKey = context.focus_meeting.meeting_key
+  for (const ref of [
+    context.next_session,
+    context.previous_completed_session,
+    context.default_analysis_session,
+  ]) {
+    if (ref?.meeting?.meeting_key === focusKey) return ref
+    // Session.meeting_key is always present even when meeting identity is sparse.
+    if (ref && ref.session.meeting_key === focusKey) return ref
+  }
+  return undefined
+}
+
+/**
+ * Weekend shell notice from authoritative response headers when present.
+ * A header that intentionally maps to no notice (e.g. focused local/local with
+ * Local suppressed) must not fall through to older previous-session archive/partial.
+ * When headers are absent, typed focus-session freshness may be used.
+ */
+export function weekendContextNotice(
+  context: WeekendContext,
+  responseMeta?: ResponseAvailability,
+): DataAvailability | null {
+  const headerMeta = responseMeta ?? getResponseAvailability(context)
+  if (headerMeta) {
+    return noticeFromFreshness(headerMeta.freshness, { includeLocal: false })
+  }
+
+  const focus = focusedContextSession(context)
+  return noticeFromFreshness(focus?.availability.freshness, { includeLocal: false })
+}
+
+/**
+ * Embedded Preview should disclose its own freshness unless the Weekend shell
+ * already shows an equivalent notice (same DataAvailability kind).
+ */
+export function shouldShowEmbeddedNotice(
+  notice: DataAvailability | null | undefined,
+  shellNotice: DataAvailability | null | undefined,
+): boolean {
+  if (!notice) return false
+  if (!shellNotice) return true
+  return notice !== shellNotice
+}

frontend/src/lib/chapters.ts

@@ -53,7 +53,10 @@ export function chapterEndScrub(
   return Math.max(0, Math.min(1, (ms - tMin) / tRange))
 }
 
-/** Index of the chapter containing the current scrub position, if any. */
+/** Index of the chapter containing the current scrub position, if any.
+ * Uses the same 0–1 clamped bounds as chapterStartScrub/chapterEndScrub so
+ * chapters whose timestamps fall outside the position-sample window still
+ * activate when the scrubber is parked at the clamped edge. */
 export function activeChapterIndex(
   chapters: Chapter[],
   scrubTime: number | null,
@@ -61,15 +64,13 @@ export function activeChapterIndex(
   tRange: number,
 ): number | null {
   if (scrubTime === null || chapters.length === 0 || tRange <= 0) return null
-  const chartMs = tMin + scrubTime * tRange
   for (let i = 0; i < chapters.length; i++) {
-    const ch = chapters[i]
-    const startMs = ch.start_time ? new Date(ch.start_time).getTime() : NaN
-    const endRaw = ch.end_time ?? ch.start_time
-    const endMs = endRaw ? new Date(endRaw).getTime() : NaN
-    if (!Number.isNaN(startMs) && !Number.isNaN(endMs) && chartMs >= startMs && chartMs <= endMs) {
-      return i
-    }
+    const start = chapterStartScrub(chapters[i], tMin, tRange)
+    const end = chapterEndScrub(chapters[i], tMin, tRange)
+    if (start === null || end === null) continue
+    const lo = Math.min(start, end)
+    const hi = Math.max(start, end)
+    if (scrubTime >= lo && scrubTime <= hi) return i
   }
   return null
 }
@@ -80,3 +81,52 @@ export function chapterTourDurations(chapters: Chapter[], totalMs = 90_000): num
   const perChapter = totalMs / chapters.length
   return chapters.map(() => perChapter)
 }
+
+/** Decimated position axis labels, e.g. P1, P5, P10, P15, P20. */
+export function decimatedPositionLabels(maxPos: number): number[] {
+  if (maxPos <= 1) return [1]
+  const labels = new Set<number>([1])
+  for (let pos = 5; pos < maxPos; pos += 5) {
+    labels.add(pos)
+  }
+  labels.add(maxPos)
+  return [...labels].sort((a, b) => a - b)
+}
+
+/** Subtle background fill for chapter time-bands on the position graph. */
+export function chapterBandFill(kind: string): string {
+  switch (kind) {
+    case 'safety_car':
+      return 'rgba(255, 153, 0, 0.14)'
+    case 'virtual_safety_car':
+      return 'rgba(255, 204, 0, 0.12)'
+    case 'red_flag':
+      return 'rgba(230, 36, 41, 0.12)'
+    case 'pit_phase':
+      return 'rgba(96, 165, 250, 0.08)'
+    case 'decisive_swing':
+      return 'rgba(34, 197, 94, 0.08)'
+    case 'finish':
+      return 'rgba(255, 204, 0, 0.06)'
+    default:
+      return 'rgba(255, 255, 255, 0.03)'
+  }
+}
+
+/** Minimum vertical spacing between colliding labels (SVG units). */
+export function deCollideYPositions(
+  items: ReadonlyArray<{ key: string | number; y: number }>,
+  minGap = 12,
+): Map<string | number, number> {
+  if (items.length === 0) return new Map()
+  const sorted = [...items].sort((a, b) => a.y - b.y)
+  const adjusted = sorted.map((item) => ({ ...item }))
+  for (let i = 1; i < adjusted.length; i++) {
+    const prev = adjusted[i - 1]
+    const curr = adjusted[i]
+    if (curr.y - prev.y < minGap) {
+      curr.y = prev.y + minGap
+    }
+  }
+  return new Map(adjusted.map((item) => [item.key, item.y]))
+}

frontend/src/lib/fetch.ts

@@ -0,0 +1,353 @@
+/** Bounded fetch helpers for primary-route resilience. */
+
+import { replaceEqualDeep } from '@tanstack/react-query'
+
+export const DEFAULT_FETCH_TIMEOUT_MS = 15_000
+
+/** CORS-readable success provenance headers from the Go API. */
+export const DATA_SOURCE_HEADER = 'X-BoxBox-Data-Source'
+export const DATA_FRESHNESS_HEADER = 'X-BoxBox-Data-Freshness'
+
+/** Reported response source values (`openf1|local|mixed`, plus `fia` for live). */
+export type DataSourceHeader = 'openf1' | 'local' | 'mixed' | 'fia' | string
+
+/** Reported freshness (`fresh|stale|local|partial`, plus live/archive/limited). */
+export type DataFreshnessHeader =
+  | 'fresh'
+  | 'stale'
+  | 'local'
+  | 'partial'
+  | 'live'
+  | 'archive'
+  | 'limited'
+  | string
+
+/** Additive success-response availability metadata (never inferred from React Query). */
+export interface ResponseAvailability {
+  source?: DataSourceHeader
+  freshness?: DataFreshnessHeader
+}
+
+const responseAvailability = new WeakMap<object, ResponseAvailability>()
+
+function readHeader(headers: Headers, name: string): string | undefined {
+  const value = headers.get(name)?.trim()
+  return value || undefined
+}
+
+function captureResponseAvailability(data: unknown, headers: Headers): void {
+  if (data === null || (typeof data !== 'object' && typeof data !== 'function')) return
+  const source = readHeader(headers, DATA_SOURCE_HEADER)
+  const freshness = readHeader(headers, DATA_FRESHNESS_HEADER)
+  if (!source && !freshness) return
+  responseAvailability.set(data as object, { source, freshness })
+}
+
+/** Read availability metadata captured from the last successful fetch of this payload. */
+export function getResponseAvailability(data: unknown): ResponseAvailability | undefined {
+  if (data === null || (typeof data !== 'object' && typeof data !== 'function')) return undefined
+  return responseAvailability.get(data as object)
+}
+
+/** Test / manual helper — attach reported availability to a payload object. */
+export function rememberResponseAvailability(
+  data: object,
+  meta: ResponseAvailability,
+): void {
+  responseAvailability.set(data, meta)
+}
+
+/** Drop availability metadata from a payload (e.g. after a header-less refetch). */
+export function clearResponseAvailability(data: object): void {
+  responseAvailability.delete(data)
+}
+
+/**
+ * React Query structural sharing that keeps header availability in sync.
+ *
+ * Default `replaceEqualDeep` reuses the previous object when JSON is equal, which
+ * would leave stale WeakMap metadata attached after a stale→fresh (or fresh→partial)
+ * refetch of an identical body. Always re-bind the latest fetch's metadata onto the
+ * object that lands in the query cache.
+ */
+export function availabilityAwareStructuralSharing<T>(
+  oldData: T | undefined,
+  newData: T,
+): T {
+  const meta = getResponseAvailability(newData)
+  const shared = replaceEqualDeep(oldData, newData) as T
+  if (shared !== null && typeof shared === 'object') {
+    if (meta) {
+      rememberResponseAvailability(shared as object, meta)
+    } else {
+      clearResponseAvailability(shared as object)
+    }
+  }
+  return shared
+}
+
+export type ApiErrorKind = 'http' | 'timeout' | 'abort' | 'network'
+
+export class ApiError extends Error {
+  readonly kind: ApiErrorKind
+  readonly status?: number
+  readonly stale: boolean
+  readonly userMessage: string
+
+  constructor(
+    kind: ApiErrorKind,
+    message: string,
+    opts?: { status?: number; stale?: boolean; userMessage?: string },
+  ) {
+    super(message)
+    this.name = 'ApiError'
+    this.kind = kind
+    this.status = opts?.status
+    this.stale = opts?.stale ?? false
+    this.userMessage = opts?.userMessage ?? defaultUserMessage(kind, opts?.stale)
+  }
+}
+
+function defaultUserMessage(kind: ApiErrorKind, stale?: boolean): string {
+  if (stale) {
+    return 'Showing cached data because a fresh update did not arrive. Retry to refresh.'
+  }
+  switch (kind) {
+    case 'timeout':
+      return 'This request took too long. Check your connection, then retry.'
+    case 'abort':
+      return 'This request was cancelled. Retry when you are ready.'
+    case 'network':
+      return 'Could not reach box-box. Check your connection, then retry.'
+    case 'http':
+    default:
+      return 'Something went wrong loading this view. Retry to try again.'
+  }
+}
+
+export function isApiError(err: unknown): err is ApiError {
+  return err instanceof ApiError
+}
+
+export function isTimeoutError(err: unknown): boolean {
+  return isApiError(err) && err.kind === 'timeout'
+}
+
+export function userFacingError(err: unknown): string {
+  if (isApiError(err)) return err.userMessage
+  if (err instanceof Error && err.message) {
+    // Never surface raw "API 500: Internal Server Error" style strings.
+    if (/^API\s+\d+/i.test(err.message) || /status\s+\d+/i.test(err.message)) {
+      return defaultUserMessage('http')
+    }
+    return err.message
+  }
+  return defaultUserMessage('http')
+}
+
+export interface ApiFetchOptions {
+  timeoutMs?: number
+  signal?: AbortSignal
+  /** When set, concurrent identical in-flight requests share one promise. */
+  dedupeKey?: string
+  method?: string
+  headers?: HeadersInit
+  body?: BodyInit | null
+}
+
+interface InflightEntry {
+  /** Shared underlying fetch — not tied to any single caller's AbortSignal. */
+  promise: Promise<unknown>
+  /** Aborts the shared request only when the last subscriber cancels. */
+  controller: AbortController
+  subscribers: number
+}
+
+const inflight = new Map<string, InflightEntry>()
+
+function abortError(): ApiError {
+  return new ApiError('abort', 'Request aborted', {
+    userMessage: defaultUserMessage('abort'),
+  })
+}
+
+function combineAbortSignals(signals: AbortSignal[]): AbortSignal {
+  const controller = new AbortController()
+  const onAbort = () => {
+    const reason = signals.find((s) => s.aborted)?.reason
+    if (!controller.signal.aborted) {
+      controller.abort(reason)
+    }
+  }
+  for (const signal of signals) {
+    if (signal.aborted) {
+      onAbort()
+      break
+    }
+    signal.addEventListener('abort', onAbort, { once: true })
+  }
+  return controller.signal
+}
+
+async function parseErrorBody(res: Response): Promise<{ error?: string; stale?: boolean }> {
+  try {
+    const data = (await res.json()) as { error?: string; stale?: boolean }
+    return data ?? {}
+  } catch {
+    return {}
+  }
+}
+
+async function rawApiFetch<T>(url: string, options: ApiFetchOptions = {}): Promise<T> {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS
+  const timeoutController = new AbortController()
+  const timer = setTimeout(() => {
+    timeoutController.abort(new DOMException('Request timed out', 'TimeoutError'))
+  }, timeoutMs)
+
+  const signals = [timeoutController.signal]
+  if (options.signal) signals.push(options.signal)
+  const signal = combineAbortSignals(signals)
+
+  try {
+    let res: Response
+    try {
+      res = await fetch(url, {
+        method: options.method,
+        headers: options.headers,
+        body: options.body,
+        signal,
+      })
+    } catch (err) {
+      if (timeoutController.signal.aborted && !options.signal?.aborted) {
+        throw new ApiError('timeout', 'Request timed out', {
+          userMessage: defaultUserMessage('timeout'),
+        })
+      }
+      if (options.signal?.aborted || (err instanceof DOMException && err.name === 'AbortError')) {
+        throw abortError()
+      }
+      throw new ApiError('network', err instanceof Error ? err.message : 'Network error', {
+        userMessage: defaultUserMessage('network'),
+      })
+    }
+
+    if (!res.ok) {
+      const body = await parseErrorBody(res)
+      throw new ApiError('http', body.error || `HTTP ${res.status}`, {
+        status: res.status,
+        stale: Boolean(body.stale),
+        userMessage: body.stale
+          ? defaultUserMessage('http', true)
+          : defaultUserMessage('http'),
+      })
+    }
+
+    const data = (await res.json()) as T
+    captureResponseAvailability(data, res.headers)
+    return data
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+/**
+ * Attach a caller to a shared in-flight request.
+ * One caller's abort rejects only that caller; the shared fetch continues
+ * while other subscribers remain, and is cancelled only when the last one leaves.
+ */
+function subscribeToInflight<T>(
+  key: string,
+  entry: InflightEntry,
+  callerSignal?: AbortSignal,
+): Promise<T> {
+  if (callerSignal?.aborted) {
+    return Promise.reject(abortError())
+  }
+
+  entry.subscribers += 1
+
+  return new Promise<T>((resolve, reject) => {
+    let settled = false
+
+    const leave = () => {
+      entry.subscribers -= 1
+      if (entry.subscribers <= 0) {
+        if (!entry.controller.signal.aborted) {
+          entry.controller.abort()
+        }
+        if (inflight.get(key) === entry) {
+          inflight.delete(key)
+        }
+      }
+    }
+
+    const onCallerAbort = () => {
+      if (settled) return
+      settled = true
+      leave()
+      reject(abortError())
+    }
+
+    if (callerSignal) {
+      callerSignal.addEventListener('abort', onCallerAbort, { once: true })
+    }
+
+    entry.promise.then(
+      (value) => {
+        if (settled) return
+        settled = true
+        callerSignal?.removeEventListener('abort', onCallerAbort)
+        resolve(value as T)
+      },
+      (err) => {
+        if (settled) return
+        settled = true
+        callerSignal?.removeEventListener('abort', onCallerAbort)
+        reject(err)
+      },
+    )
+  })
+}
+
+/**
+ * Fetch JSON with a bounded timeout, abort propagation, typed errors,
+ * and optional in-flight deduplication (same key shares one underlying request).
+ *
+ * Deduped requests are subscriber-safe: aborting one consumer does not cancel
+ * or poison other consumers that still hold the same key (React Strict Mode remounts).
+ */
+export function apiFetch<T>(url: string, options: ApiFetchOptions = {}): Promise<T> {
+  const key = options.dedupeKey
+  if (!key) {
+    return rawApiFetch<T>(url, options)
+  }
+
+  if (options.signal?.aborted) {
+    return Promise.reject(abortError())
+  }
+
+  let entry = inflight.get(key)
+  if (!entry) {
+    const controller = new AbortController()
+    // Shared fetch only listens to the ref-counted controller + timeout —
+    // never to any single caller's AbortSignal.
+    const promise = rawApiFetch<T>(url, {
+      ...options,
+      signal: controller.signal,
+    }).finally(() => {
+      if (inflight.get(key)?.promise === promise) {
+        inflight.delete(key)
+      }
+    })
+    entry = { promise, controller, subscribers: 0 }
+    inflight.set(key, entry)
+  }
+
+  return subscribeToInflight<T>(key, entry, options.signal)
+}
+
+/** Test helper — clears the in-flight dedupe map. */
+export function clearApiFetchInflight(): void {
+  inflight.clear()
+}

frontend/src/lib/liveState.ts

@@ -0,0 +1,168 @@
+// Live timing state model.
+//
+// The Live page has to hold four *orthogonal* concepts that used to be
+// conflated into a single "connected / offline" flag:
+//
+//   1. transport health  — is the SSE stream up? (connecting/connected/…)
+//   2. active session     — is a session actually running right now?
+//   3. archive availability — do we retain a final snapshot to inspect?
+//   4. analysis readiness — is the completed session ingested for Race Hub?
+//
+// `deriveLivePhase` collapses the first three inputs into a single UI phase so
+// the page never, for example, calls a finished session "offline" or lets a
+// dropped socket masquerade as "archive mode".
+//
+// Critical distinction (issue #74 P0): the server's `deactivate()` path moves a
+// STILL-ACTIVE snapshot into `last_snapshot` whenever the upstream FIA SignalR
+// connection ends or idles — WITHOUT changing SessionStatus. So `is_live=false`
+// alone is ambiguous. We rely on the retained snapshot's terminal SessionStatus
+// (Finished/Ended/…) as the only trustworthy "the session really ended" signal.
+// A non-terminal retained snapshot means the feed dropped, not that the session
+// finished, and must render as `disconnected` (retain snapshot, warn, recover),
+// never `settling`/archive.
+
+export type TransportHealth = 'connecting' | 'connected' | 'disconnected' | 'error'
+
+export type LivePhase =
+  | 'connecting' // cold start: no snapshot yet, still opening the feed
+  | 'live' // a session is running and streaming
+  | 'disconnected' // was live, transport/feed dropped — keep the last snapshot, warn
+  | 'settling' // session truly ended; a final snapshot is retained, analysis pending
+  | 'archive' // user opened the retained snapshot as an explicit read-only view
+  | 'inactive' // no session and nothing retained — show weekend context instead
+
+export interface LiveStateInputs {
+  transport: TransportHealth
+  /** The feed reports an active session AND carries a snapshot for it. */
+  isLive: boolean
+  hasActiveSnapshot: boolean
+  /** A retained snapshot from the last stream is held (may be a dropped feed). */
+  hasArchive: boolean
+  /** The user explicitly opened the archive as a read-only timing view. */
+  archiveMode: boolean
+  /**
+   * The retained snapshot ended on a *terminal* FIA SessionStatus. Only true
+   * here means the session genuinely finished (vs. the transport dropping).
+   */
+  sessionEndedCleanly: boolean
+  /** We have observed this session live at least once in this page session. */
+  wasLive: boolean
+  /**
+   * The initial `/api/v1/live/state` query has resolved. `connecting` is a
+   * cold-start-only phase: once we know the current state (even if the SSE
+   * transport handshake is still pending), an idle feed is `inactive`, not a
+   * perpetual "connecting…" spinner.
+   */
+  stateLoaded: boolean
+}
+
+// Raw FIA SessionStatus values that mean the session is genuinely over. Mirrors
+// the backend `terminalSessionStatus` used by the weekend-context resolver so
+// the client and server agree on "finished".
+const TERMINAL_STATUSES = new Set(['finished', 'finalised', 'finalized', 'ended', 'aborted'])
+
+function normalizeStatus(status: string | undefined | null): string {
+  if (!status) return ''
+  return status.replace(/[^a-zA-Z]/g, '').toLowerCase()
+}
+
+/** Whether a raw FIA SessionStatus represents a genuinely completed session. */
+export function terminalSessionStatus(status: string | undefined | null): boolean {
+  return TERMINAL_STATUSES.has(normalizeStatus(status))
+}
+
+export function transportDown(transport: TransportHealth): boolean {
+  return transport === 'disconnected' || transport === 'error'
+}
+
+/**
+ * Map transport + session + archive inputs to one UI phase. Session lifecycle
+ * and transport health are deliberately orthogonal: a live session with a
+ * dropped socket is `disconnected` (snapshot retained), never `archive` or
+ * `settling`.
+ */
+export function deriveLivePhase(input: LiveStateInputs): LivePhase {
+  const {
+    transport,
+    isLive,
+    hasActiveSnapshot,
+    hasArchive,
+    archiveMode,
+    sessionEndedCleanly,
+    stateLoaded,
+  } = input
+
+  // Explicit read-only archive wins — it is a user-chosen mode.
+  if (archiveMode && hasArchive) return 'archive'
+
+  // An active session: transport health only downgrades the *presentation*,
+  // it never removes the session.
+  if (isLive && hasActiveSnapshot) {
+    return transportDown(transport) ? 'disconnected' : 'live'
+  }
+
+  // Feed reports no active session but a snapshot is retained. Distinguish a
+  // genuine session end from an upstream feed drop using the *only* trustworthy
+  // signal: whether the retained snapshot carries a terminal SessionStatus.
+  if (hasArchive) {
+    if (sessionEndedCleanly) return 'settling'
+    // Non-terminal retained snapshot means the upstream feed dropped, not that
+    // the session finished. Hold the last frame and warn — never settle/archive.
+    return 'disconnected'
+  }
+
+  // Cold start only: still opening the feed and we have not yet learned the
+  // current state. Once the initial state query resolves, an idle feed is
+  // `inactive`, not a perpetual "connecting…".
+  if (transport === 'connecting' && !stateLoaded) return 'connecting'
+
+  return 'inactive'
+}
+
+/** Phases that render the live timing tower / snapshot surface. */
+export function rendersSnapshot(phase: LivePhase): boolean {
+  return phase === 'live' || phase === 'disconnected' || phase === 'archive'
+}
+
+/**
+ * Whether live-only interpretations (pit-window rejoin, tyre-deg slope, "what
+ * just happened" deltas) are meaningful. They require a moving session, so an
+ * archived single frame must never present them as current insight.
+ */
+export function allowsLiveInterpretations(phase: LivePhase): boolean {
+  return phase === 'live' || phase === 'disconnected'
+}
+
+/** Read-only, timestamped phases that must not show live/connected chrome. */
+export function isReadOnlyPhase(phase: LivePhase): boolean {
+  return phase === 'archive'
+}
+
+/**
+ * Fan-facing feed health. Browser SSE can stay `connected` after an upstream
+ * FIA drop leaves us in `disconnected` with a retained non-terminal snapshot —
+ * present that as reconnecting, never "Feed healthy" beside "Connection lost".
+ */
+export function effectiveFeedHealth(
+  transport: TransportHealth,
+  phase: LivePhase,
+): TransportHealth {
+  if (phase === 'disconnected' && !transportDown(transport)) {
+    return 'disconnected'
+  }
+  return transport
+}
+
+/** Short, human transport-health label — always secondary to session state. */
+export function feedHealthLabel(transport: TransportHealth): string {
+  switch (transport) {
+    case 'connected':
+      return 'Feed healthy'
+    case 'connecting':
+      return 'Connecting'
+    case 'disconnected':
+      return 'Reconnecting'
+    case 'error':
+      return 'Feed unavailable'
+  }
+}

frontend/src/lib/queryClient.ts

@@ -0,0 +1,16 @@
+import { QueryClient } from '@tanstack/react-query'
+import { availabilityAwareStructuralSharing } from './fetch'
+
+/** Shared QueryClient defaults — availability-aware structural sharing for header metadata. */
+export function createAppQueryClient(): QueryClient {
+  return new QueryClient({
+    defaultOptions: {
+      queries: {
+        staleTime: 30_000,
+        // Explicit Retry on RouteState — avoid automatic retry storms.
+        retry: false,
+        structuralSharing: availabilityAwareStructuralSharing,
+      },
+    },
+  })
+}

frontend/src/lib/replayMap.ts

@@ -0,0 +1,14 @@
+import type { ReplayFramesResponse, TrackOutline } from '../types'
+
+/** Whether replay map can render (probe uses existing frames + outline queries). */
+export function isReplayMapAvailable(
+  replay: ReplayFramesResponse | null | undefined,
+  outline: TrackOutline | null | undefined,
+  hasError: boolean,
+): boolean {
+  if (hasError) return false
+  const frames = replay?.frames ?? []
+  if (frames.length < 2) return false
+  if (!outline?.points?.length) return false
+  return true
+}

frontend/src/lib/rivalry.ts

@@ -0,0 +1,61 @@
+// Pure helpers for the championship rivalry compare view.
+
+/** One round that counted toward the head-to-head tally. */
+export interface H2HRound {
+  round: number // 1-based season round
+  label: string
+  posA: number
+  posB: number
+  winner: 'a' | 'b'
+}
+
+export interface H2HTally {
+  a: number
+  b: number
+  /** Rounds counted in the tally, in season order. */
+  rounds: H2HRound[]
+  /** Rounds skipped because either driver had no finishing position. */
+  skipped: number
+}
+
+/**
+ * Per-round points gap (a − b) across the rounds both cumulative series
+ * cover. Positive values mean driver A is ahead.
+ */
+export function gapSeries(a: number[], b: number[]): number[] {
+  const n = Math.min(a.length, b.length)
+  const out: number[] = []
+  for (let i = 0; i < n; i++) out.push(a[i] - b[i])
+  return out
+}
+
+/**
+ * Race head-to-head: per round, the lower finishing position wins. Rounds
+ * where either driver has no position (0 / missing) are skipped from the
+ * tally, as are equal positions (defensive — races can't tie).
+ */
+export function h2hTally(posA: number[], posB: number[], labels: string[]): H2HTally {
+  const n = Math.max(posA.length, posB.length)
+  const rounds: H2HRound[] = []
+  let a = 0
+  let b = 0
+  let skipped = 0
+  for (let i = 0; i < n; i++) {
+    const pa = posA[i] ?? 0
+    const pb = posB[i] ?? 0
+    if (pa <= 0 || pb <= 0 || pa === pb) {
+      skipped++
+      continue
+    }
+    const winner = pa < pb ? 'a' : 'b'
+    if (winner === 'a') a++
+    else b++
+    rounds.push({ round: i + 1, label: labels[i] ?? `R${i + 1}`, posA: pa, posB: pb, winner })
+  }
+  return { a, b, rounds, skipped }
+}
+
+/** Last n counted rounds of a tally, for the mini strip. */
+export function lastRounds(tally: H2HTally, n: number): H2HRound[] {
+  return tally.rounds.slice(-n)
+}

frontend/src/lib/routeSearch.ts

@@ -0,0 +1,40 @@
+/** Shared URL search contracts for deep-linkable Weekend ↔ Race Hub navigation. */
+
+export type WeekendSearch = {
+  meeting_key?: number
+  session_key?: number
+}
+
+export type RaceHubSearch = {
+  session_key?: number
+}
+
+function parsePositiveInt(value: unknown): number | undefined {
+  const n = Number(value)
+  return Number.isFinite(n) && n > 0 ? n : undefined
+}
+
+export function parseWeekendSearch(search: Record<string, unknown>): WeekendSearch {
+  const meeting_key = parsePositiveInt(search.meeting_key)
+  const session_key = parsePositiveInt(search.session_key)
+  return {
+    ...(meeting_key ? { meeting_key } : {}),
+    ...(session_key ? { session_key } : {}),
+  }
+}
+
+export function parseRaceHubSearch(search: Record<string, unknown>): RaceHubSearch {
+  const session_key = parsePositiveInt(search.session_key)
+  return session_key ? { session_key } : {}
+}
+
+/** Build Weekend `/` search so a Race Hub return is reload-safe and deep-linkable. */
+export function weekendFocusSearch(
+  meetingKey?: number | null,
+  sessionKey?: number | null,
+): WeekendSearch {
+  return {
+    ...(meetingKey && meetingKey > 0 ? { meeting_key: meetingKey } : {}),
+    ...(sessionKey && sessionKey > 0 ? { session_key: sessionKey } : {}),
+  }
+}

frontend/src/lib/sessionState.ts

@@ -0,0 +1,194 @@
+import type { ContextSession, WeekendContext, WeekendSession } from '../types'
+import { isSessionComplete } from './coverage'
+import { sessionStartTime } from './schedule'
+
+/**
+ * User-facing lifecycle state for a weekend session.
+ *
+ * Live comes only from Weekend Context's FIA-backed active identity — never from
+ * the scheduled start/end window alone. Preparing / partial / ready / unavailable
+ * come from structured `availability.local_analysis` when a context ref exists,
+ * otherwise from local dataset coverage after the scheduled start.
+ */
+export type SessionState =
+  | 'upcoming'
+  | 'live'
+  | 'preparing'
+  | 'partial'
+  | 'ready'
+  | 'unavailable'
+  | 'cancelled'
+
+export interface SessionStateInput {
+  weekendSession?: WeekendSession
+  context?: WeekendContext | null
+  now: Date
+}
+
+function contextRefFor(
+  context: WeekendContext | null | undefined,
+  sessionKey: number | undefined,
+): ContextSession | undefined {
+  if (!context || !sessionKey) return undefined
+  const refs = [
+    context.active_session,
+    context.default_analysis_session,
+    context.previous_completed_session,
+    context.next_session,
+  ]
+  return refs.find((ref) => ref?.session.session_key === sessionKey)
+}
+
+function fromAvailability(ref: ContextSession): SessionState | undefined {
+  const { schedule, live_session, local_analysis } = ref.availability
+  if (live_session === 'active') return 'live'
+  if (schedule === 'unavailable' || local_analysis === 'unavailable') return 'unavailable'
+  if (local_analysis === 'not_applicable') return 'upcoming'
+  if (local_analysis === 'pending') return 'preparing'
+  if (local_analysis === 'partial') return 'partial'
+  if (local_analysis === 'complete') return 'ready'
+  return undefined
+}
+
+/**
+ * Resolve fan-facing session state. Prefer Weekend Context availability; never
+ * assert Live from wall-clock schedule alone.
+ */
+export function resolveSessionState({
+  weekendSession,
+  context,
+  now,
+}: SessionStateInput): SessionState {
+  if (weekendSession?.source === 'cancelled') return 'cancelled'
+
+  const sessionKey = weekendSession?.session.session_key
+  const active = context?.active_session
+  if (
+    active &&
+    sessionKey &&
+    active.session.session_key === sessionKey &&
+    active.availability.live_session === 'active'
+  ) {
+    return 'live'
+  }
+
+  const ref = contextRefFor(context, sessionKey)
+  if (ref) {
+    const fromCtx = fromAvailability(ref)
+    if (fromCtx) return fromCtx
+  }
+
+  // Settling temporal state with no analysis yet — even without a matching ref.
+  if (
+    context?.temporal_state === 'session_settling' &&
+    weekendSession &&
+    weekendSession.source === 'none'
+  ) {
+    return 'preparing'
+  }
+
+  if (!weekendSession) return 'unavailable'
+
+  const start = sessionStartTime(weekendSession.session)
+  if (start && start > now) return 'upcoming'
+
+  if (isSessionComplete(weekendSession.datasets)) return 'ready'
+  if (weekendSession.source === 'none') return 'preparing'
+  if (weekendSession.source === 'partial') return 'partial'
+  return 'ready'
+}
+
+/** @deprecated Prefer resolveSessionState with Weekend Context. */
+export function sessionState(session: WeekendSession, now: Date): SessionState {
+  return resolveSessionState({ weekendSession: session, now })
+}
+
+/** Short label suitable for chips and the session switcher. */
+export function sessionStateLabel(state: SessionState): string {
+  switch (state) {
+    case 'upcoming':
+      return 'Upcoming'
+    case 'live':
+      return 'Live'
+    case 'preparing':
+      return 'Preparing'
+    case 'partial':
+      return 'Partial'
+    case 'ready':
+      return 'Ready'
+    case 'unavailable':
+      return 'Unavailable'
+    case 'cancelled':
+      return 'Cancelled'
+  }
+}
+
+/** Longer, sentence-style description for headers and empty states. */
+export function sessionStateDescription(state: SessionState): string {
+  switch (state) {
+    case 'upcoming':
+      return 'Session has not started yet.'
+    case 'live':
+      return 'Session is running now.'
+    case 'preparing':
+      return 'Analysis is being prepared — local data is still settling.'
+    case 'partial':
+      return 'Partial analysis available — some datasets are still missing.'
+    case 'ready':
+      return 'Full analysis is ready.'
+    case 'unavailable':
+      return 'Analysis is not available for this session.'
+    case 'cancelled':
+      return 'This session was cancelled.'
+  }
+}
+
+/**
+ * Class suffix used for the coverage dot, so the rail can colour a session by
+ * its lifecycle state rather than only by data source.
+ */
+export function sessionStateDotClass(state: SessionState): string {
+  switch (state) {
+    case 'ready':
+      return 'rh-state-ready'
+    case 'partial':
+      return 'rh-state-partial'
+    case 'live':
+      return 'rh-state-live'
+    case 'upcoming':
+      return 'rh-state-upcoming'
+    case 'unavailable':
+      return 'rh-state-unavailable'
+    case 'cancelled':
+      return 'rh-state-cancelled'
+    default:
+      return 'rh-state-preparing'
+  }
+}
+
+/** Whether a session should render the pre-session (expected availability) view. */
+export function isPreSession(state: SessionState): boolean {
+  return state === 'upcoming'
+}
+
+/** Settling / empty post-session — not yet analysable. */
+export function isPreparing(state: SessionState): boolean {
+  return state === 'preparing'
+}
+
+export function isUnavailable(state: SessionState): boolean {
+  return state === 'unavailable' || state === 'cancelled'
+}
+
+/** Show fan analysis with a partial banner; keep available capabilities. */
+export function isPartialAnalysis(state: SessionState): boolean {
+  return state === 'partial'
+}
+
+/** Canonical default analysis session key from Weekend Context, if any. */
+export function defaultAnalysisSessionKey(
+  context: WeekendContext | null | undefined,
+): number | undefined {
+  const key = context?.default_analysis_session?.session.session_key
+  return key && key > 0 ? key : undefined
+}

frontend/src/lib/weekendContext.ts

@@ -0,0 +1,181 @@
+import type {
+  ChampionshipHub,
+  ContextSession,
+  EnrichedResult,
+  Meeting,
+  NewsItem,
+  Session,
+  WeekendBriefingItem,
+  WeekendChampionshipImpact,
+  WeekendChampionshipMover,
+  WeekendContext,
+  WeekendPodiumEntry,
+  WeekendViewState,
+} from '../types'
+
+/**
+ * resolveViewState maps the canonical `temporal_state` onto the rendered Weekend
+ * view. It is a total function: every valid canonical `temporal_state` resolves
+ * to a concrete view, so a well-formed payload never falls through to a
+ * limited/empty placeholder. Loading and error are hook-level states that are
+ * not part of the #72 contract.
+ */
+export function resolveViewState(context: WeekendContext): WeekendViewState {
+  switch (context.temporal_state) {
+    case 'no_season':
+      return 'no_season'
+    case 'between_weekends':
+      return 'between_weekends'
+    case 'pre_session':
+      return 'pre_session'
+    case 'session_live':
+      return 'session_live'
+    case 'session_settling':
+      return 'session_settling'
+    case 'between_sessions':
+      return 'between_sessions'
+    case 'post_weekend':
+      return 'post_weekend'
+    case 'season_complete':
+      return 'season_complete'
+    default:
+      // Unknown/absent temporal_state is an invalid payload — treat as no_season
+      // rather than inventing a state. The hook still shows an explicit surface.
+      return 'no_season'
+  }
+}
+
+export interface MeetingIdentity {
+  meeting_key: number
+  meeting_name: string
+  short_name: string
+  country_code: string
+  country_flag: string
+  circuit_short_name: string
+  circuit_key?: number
+  date_start?: string
+  date_end?: string
+}
+
+/** Presentation identity for a meeting, tolerant of partial/absent fields. */
+export function meetingIdentity(meeting: Meeting | undefined): MeetingIdentity | undefined {
+  if (!meeting) return undefined
+  return {
+    meeting_key: meeting.meeting_key,
+    meeting_name: meeting.meeting_name || meeting.location || 'Grand Prix',
+    short_name: (meeting.meeting_name || meeting.location || 'Grand Prix').replace(/ Grand Prix$/i, ''),
+    country_code: meeting.country_code,
+    country_flag: meeting.country_flag,
+    circuit_short_name: meeting.circuit_short_name || meeting.location || '',
+    circuit_key: meeting.circuit_key,
+    date_start: meeting.date_start || undefined,
+    date_end: meeting.date_end || undefined,
+  }
+}
+
+/** Session identity paired with its resolved meeting for a canonical ContextSession. */
+export function sessionMeeting(ref: ContextSession | undefined): Meeting | undefined {
+  return ref?.meeting
+}
+
+export function sessionOf(ref: ContextSession | undefined): Session | undefined {
+  return ref?.session
+}
+
+/**
+ * analysisSessionKey resolves the session a user should open to read analysis for
+ * a completed event. It prefers the canonical default analysis session, falling
+ * back to the previous completed session. Returns undefined when nothing analysable
+ * is available (e.g. an archived result with no local analysis).
+ */
+export function analysisSessionKey(context: WeekendContext): number | undefined {
+  const key =
+    context.default_analysis_session?.session.session_key ??
+    context.previous_completed_session?.session.session_key
+  return key && key > 0 ? key : undefined
+}
+
+/** True when a ContextSession has local analysis worth linking to. */
+export function hasLocalAnalysis(ref: ContextSession | undefined): boolean {
+  const status = ref?.availability.local_analysis
+  return status === 'complete' || status === 'partial'
+}
+
+/** Countdown target for a session reference — its scheduled start, if known. */
+export function sessionStart(ref: ContextSession | undefined): string | undefined {
+  const start = ref?.session.date_start
+  return start ? start : undefined
+}
+
+export function podiumFromResults(results: EnrichedResult[]): WeekendPodiumEntry[] {
+  return [...results]
+    .filter((r) => r.position >= 1)
+    .sort((a, b) => a.position - b.position)
+    .slice(0, 3)
+    .map((r) => ({
+      position: r.position,
+      driver_number: r.driver_number,
+      name_acronym: r.name_acronym,
+      team_name: r.team_name,
+      team_colour: r.team_colour,
+      gap: formatResultGap(r),
+    }))
+}
+
+function formatResultGap(r: EnrichedResult): string {
+  if (r.dnf) return 'DNF'
+  if (r.dns) return 'DNS'
+  if (r.dsq) return 'DSQ'
+  if (r.position === 1) {
+    if (typeof r.duration === 'number' && r.duration > 0) return formatDuration(r.duration)
+    return 'Winner'
+  }
+  const gap = Array.isArray(r.gap_to_leader) ? r.gap_to_leader[r.gap_to_leader.length - 1] : r.gap_to_leader
+  if (typeof gap === 'number') return `+${gap.toFixed(3)}`
+  if (typeof gap === 'string' && gap) return gap.startsWith('+') ? gap : `+${gap}`
+  return '—'
+}
+
+function formatDuration(seconds: number): string {
+  const h = Math.floor(seconds / 3600)
+  const m = Math.floor((seconds % 3600) / 60)
+  const s = seconds % 60
+  if (h > 0) return `${h}:${String(m).padStart(2, '0')}:${s.toFixed(3).padStart(6, '0')}`
+  return `${m}:${s.toFixed(3).padStart(6, '0')}`
+}
+
+/**
+ * championshipImpact derives the top-of-standings movers from the championship
+ * hub. This is supplementary data layered onto the canonical context, not part of
+ * the #72 contract.
+ */
+export function championshipImpact(hub: ChampionshipHub | undefined): WeekendChampionshipImpact | undefined {
+  if (!hub || hub.drivers.length === 0) return undefined
+  const leaders: WeekendChampionshipMover[] = hub.drivers.slice(0, 3).map((d) => {
+    const cumulative = d.cumulative ?? []
+    const delta =
+      cumulative.length >= 2 ? cumulative[cumulative.length - 1] - cumulative[cumulative.length - 2] : undefined
+    return {
+      position: d.position,
+      driver_number: d.driver_number,
+      name_acronym: d.name_acronym,
+      team_colour: d.team_colour,
+      points: d.points,
+      delta,
+    }
+  })
+  const note = hub.last_race ? `Standings after ${hub.last_race}.` : undefined
+  return { leaders, note }
+}
+
+/** At most three briefing items, mapped from the news feed. */
+export function briefingItems(news: NewsItem[]): WeekendBriefingItem[] {
+  return news.slice(0, 3).map((item) => ({
+    category: item.category,
+    title: item.title,
+    url: item.url,
+    source: item.source,
+    published_at: item.published_at,
+    image_url: item.og_image_url,
+  }))
+}

frontend/src/main.tsx

@@ -1,18 +1,12 @@
 import React from 'react'
 import ReactDOM from 'react-dom/client'
 import { RouterProvider } from '@tanstack/react-router'
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { QueryClientProvider } from '@tanstack/react-query'
+import { createAppQueryClient } from './lib/queryClient'
 import { router } from './router'
 import './styles/app.css'
 
-const queryClient = new QueryClient({
-  defaultOptions: {
-    queries: {
-      staleTime: 30_000,
-      retry: 1,
-    },
-  },
-})
+const queryClient = createAppQueryClient()
 
 ReactDOM.createRoot(document.getElementById('root')!).render(
   <React.StrictMode>

frontend/src/pages/BriefingPage.tsx

@@ -24,6 +24,8 @@ import {
 } from '../lib/digest'
 import { stripHtml, timeAgo } from '../utils'
 import type { ArticleContent, NewsItem } from '../types'
+import { DataNotice, RouteState } from '../components/RouteState'
+import { aggregateNotices, noticeFromResponse, noticeMessage } from '../lib/availability'
 import '../styles/digest.css'
 
 type Category = 'all' | 'official' | 'news' | 'video'
@@ -406,27 +408,27 @@ export function BriefingPage() {
   const queryClient = useQueryClient()
   const now = useMemo(() => new Date(), [])
 
-  const { data: allNews = [], isLoading, isError } = useQuery({
+  const { data: allNews = [], isLoading, isError, error, refetch, isFetching } = useQuery({
     queryKey: ['news'],
-    queryFn: () => fetchNews(100),
+    queryFn: ({ signal }) => fetchNews(100, undefined, signal),
     staleTime: 60_000,
   })
 
   const seasonsQuery = useQuery({
     queryKey: ['seasons'],
-    queryFn: fetchSeasons,
+    queryFn: ({ signal }) => fetchSeasons(signal),
   })
   const latestSeason = seasonsQuery.data?.[0] ?? null
 
   const meetingsQuery = useQuery({
     queryKey: ['season-meetings', latestSeason],
-    queryFn: () => fetchSeasonMeetings(latestSeason!),
+    queryFn: ({ signal }) => fetchSeasonMeetings(latestSeason!, signal),
     enabled: latestSeason != null,
   })
 
   const hubQuery = useQuery({
     queryKey: ['championship-hub', latestSeason],
-    queryFn: () => fetchChampionshipHub(latestSeason!),
+    queryFn: ({ signal }) => fetchChampionshipHub(latestSeason!, signal),
     enabled: latestSeason != null,
   })
 
@@ -515,6 +517,43 @@ export function BriefingPage() {
   const hasDigest = meetings.length > 0
   const showEmpty = tagFiltered.length === 0 && grouped.recent.length === 0
 
+  const supplementsFetching =
+    meetingsQuery.isFetching || hubQuery.isFetching || seasonsQuery.isFetching
+  // React Query v5 clears isError while a post-error refetch is in flight
+  // (status → pending). Keep Limited mounted so Retry can show aria-busy.
+  const supplementDegraded = (q: {
+    isError: boolean
+    isFetching: boolean
+    isFetched: boolean
+    data: unknown
+  }) => q.isError || (q.isFetching && q.isFetched && q.data == null)
+  const supplementsLimited =
+    !isLoading &&
+    !isError &&
+    (supplementDegraded(meetingsQuery) ||
+      supplementDegraded(hubQuery) ||
+      supplementDegraded(seasonsQuery))
+  const supplementsRetrying = supplementsLimited && supplementsFetching
+
+  const retrySupplements = () => {
+    if (supplementDegraded(meetingsQuery) && !meetingsQuery.isFetching) {
+      void meetingsQuery.refetch()
+    }
+    if (supplementDegraded(hubQuery) && !hubQuery.isFetching) {
+      void hubQuery.refetch()
+    }
+    if (supplementDegraded(seasonsQuery) && !seasonsQuery.isFetching) {
+      void seasonsQuery.refetch()
+    }
+  }
+
+  // Aggregate by severity so routine local News cannot mask stale hub/meetings.
+  const availability = aggregateNotices([
+    noticeFromResponse(allNews, { includeLocal: true }),
+    noticeFromResponse(hub, { includeLocal: false }),
+    noticeFromResponse(meetings, { includeLocal: false }),
+  ])
+
   return (
     <div className="bp-page" data-testid="briefing-page">
       <div className="bp-topbar">
@@ -524,11 +563,45 @@ export function BriefingPage() {
         </span>
       </div>
 
-      {isLoading && <div className="loading-state">loading briefing…</div>}
-      {isError && <div className="error-box">Failed to load paddock briefing.</div>}
+      {isLoading && (
+        <RouteState kind="loading" title="loading briefing…" testId="briefing-loading" />
+      )}
+      {isError && (
+        <RouteState
+          kind="error"
+          title="Briefing unavailable"
+          error={error}
+          onRetry={() => {
+            if (!isFetching) void refetch()
+          }}
+          retrying={isFetching}
+          testId="briefing-error"
+        />
+      )}
 
       {!isLoading && !isError && (
         <>
+          {supplementsLimited && (
+            <DataNotice
+              availability="limited"
+              message="Weekend grouping or driver tags are limited. Articles are still available."
+              onRetry={retrySupplements}
+              retrying={supplementsRetrying}
+              testId="briefing-data-notice"
+            />
+          )}
+          {!supplementsLimited && availability && (
+            <DataNotice
+              availability={availability}
+              message={noticeMessage(availability)}
+              onRetry={() => {
+                if (!isFetching) void refetch()
+              }}
+              retrying={isFetching}
+              testId="briefing-data-notice"
+            />
+          )}
+
           <CategoryTabs
             active={activeCategory}
             counts={counts}

frontend/src/pages/ChampionshipPage.tsx

@@ -5,12 +5,15 @@ import { fetchChampionshipHub, fetchSeasons } from '../api'
 import { teamColor } from '../utils'
 import type { ChampHubDriver, ChampionshipHub } from '../types'
 import { ChampionshipSimulator } from '../components/ChampionshipSimulator'
+import { RivalryCompare } from '../components/RivalryCompare'
 import { Meaning } from '../components/Meaning'
+import { DataNotice, RouteState } from '../components/RouteState'
 import { TeammateH2H } from '../components/TeammateH2H'
+import { noticeFromResponse, noticeMessage } from '../lib/availability'
 import { teammatePairs } from '../lib/h2h'
 import { pointsGapMeaning } from '../lib/meaning'
 
-type View = 'drivers' | 'constructors' | 'progression' | 'simulator'
+type View = 'drivers' | 'constructors' | 'progression' | 'rivalry' | 'simulator'
 
 const GOLD = '#ffd700'
 const SILVER = '#c0c0c0'
@@ -80,23 +83,55 @@ function teamSplit(teamName: string, drivers: ChampHubDriver[]): TeamSplit {
 export function ChampionshipPage() {
   const [view, setView] = useState<View>('drivers')
 
-  const seasonsQuery = useQuery({ queryKey: ['seasons'], queryFn: fetchSeasons })
+  const seasonsQuery = useQuery({
+    queryKey: ['seasons'],
+    queryFn: ({ signal }) => fetchSeasons(signal),
+  })
   const latestSeason = seasonsQuery.data?.[0] ?? null
 
   const hubQuery = useQuery({
     queryKey: ['championship-hub', latestSeason],
-    queryFn: () => fetchChampionshipHub(latestSeason ?? undefined),
+    queryFn: ({ signal }) => fetchChampionshipHub(latestSeason ?? undefined, signal),
     enabled: latestSeason != null,
     staleTime: 5 * 60_000,
   })
 
   if (seasonsQuery.isLoading || hubQuery.isLoading) {
-    return <div className="page loading-state">loading championship…</div>
+    return (
+      <div className="page">
+        <RouteState kind="loading" title="loading championship…" testId="championship-loading" />
+      </div>
+    )
+  }
+  if (seasonsQuery.isError) {
+    return (
+      <div className="page">
+        <RouteState
+          kind="error"
+          title="Championship unavailable"
+          error={seasonsQuery.error}
+          onRetry={() => {
+            if (!seasonsQuery.isFetching) void seasonsQuery.refetch()
+          }}
+          retrying={seasonsQuery.isFetching}
+          testId="championship-error"
+        />
+      </div>
+    )
   }
   if (hubQuery.isError) {
     return (
-      <div className="page error-box">
-        {hubQuery.error instanceof Error ? hubQuery.error.message : 'Failed to load championship'}
+      <div className="page">
+        <RouteState
+          kind="error"
+          title="Championship unavailable"
+          error={hubQuery.error}
+          onRetry={() => {
+            if (!hubQuery.isFetching) void hubQuery.refetch()
+          }}
+          retrying={hubQuery.isFetching}
+          testId="championship-error"
+        />
       </div>
     )
   }
@@ -117,16 +152,32 @@ export function ChampionshipPage() {
     )
   }
 
-  return <ChampionshipBody hub={hub} view={view} setView={setView} />
+  const availability = noticeFromResponse(hub, { includeLocal: true })
+
+  return (
+    <ChampionshipBody
+      hub={hub}
+      view={view}
+      setView={setView}
+      availability={availability}
+      onRetry={() => {
+        if (!hubQuery.isFetching) void hubQuery.refetch()
+      }}
+      retrying={hubQuery.isFetching}
+    />
+  )
 }
 
 interface BodyProps {
   hub: ChampionshipHub
   view: View
   setView: (v: View) => void
+  availability?: ReturnType<typeof noticeFromResponse>
+  onRetry?: () => void
+  retrying?: boolean
 }
 
-function ChampionshipBody({ hub, view, setView }: BodyProps) {
+function ChampionshipBody({ hub, view, setView, availability, onRetry, retrying }: BodyProps) {
   const { drivers, teams } = hub
   const leader = drivers[0]
   const remaining = hub.rounds_left * 25
@@ -182,6 +233,15 @@ function ChampionshipBody({ hub, view, setView }: BodyProps) {
 
   return (
     <div className="champ-page" data-testid="championship">
+      {availability && (
+        <DataNotice
+          availability={availability}
+          message={noticeMessage(availability)}
+          onRetry={onRetry}
+          retrying={retrying}
+          testId="championship-data-notice"
+        />
+      )}
       <div className="champ-header">
         <div className="champ-title-row">
           <span className="champ-accent" aria-hidden="true" />
@@ -216,6 +276,14 @@ function ChampionshipBody({ hub, view, setView }: BodyProps) {
           >
             Progression
           </button>
+          <button
+            type="button"
+            className={`champ-tab${view === 'rivalry' ? ' is-active' : ''}`}
+            onClick={() => setView('rivalry')}
+            data-testid="champ-tab-rivalry"
+          >
+            Rivalry
+          </button>
           <button
             type="button"
             className={`champ-tab${view === 'simulator' ? ' is-active' : ''}`}
@@ -251,6 +319,7 @@ function ChampionshipBody({ hub, view, setView }: BodyProps) {
       )}
       {view === 'constructors' && <ConstructorsView hub={hub} />}
       {view === 'progression' && <ProgressionView hub={hub} />}
+      {view === 'rivalry' && <RivalryCompare hub={hub} />}
       {view === 'simulator' && <ChampionshipSimulator hub={hub} />}
     </div>
   )

frontend/src/pages/CommandCenterPage.tsx

@@ -1,451 +0,0 @@
-import { useEffect, useMemo, useState } from 'react'
-import { useQueries, useQuery } from '@tanstack/react-query'
-import { Link } from '@tanstack/react-router'
-import {
-  fetchChampionshipHub,
-  fetchLiveState,
-  fetchLocalMeetings,
-  fetchRaceHub,
-  fetchSeasonMeetings,
-  fetchSeasons,
-  fetchSessions,
-  fetchWeekend,
-} from '../api'
-import { CommandCenterHero } from '../components/CommandCenterHero'
-import { PaddockBriefing } from '../components/PaddockBriefing'
-import { RACE_HUB_DATASETS, countWeekendStats, formatCoverageHint, sessionTypeAbbrev } from '../lib/coverage'
-import { countryAccent, countryDecal, countryFlag, formatGpDateRange } from '../lib/gpIdentity'
-import { classifySessionStatus, heroState } from '../lib/hero'
-import {
-  currentAndNextSession,
-  focusMeetingKind,
-  formatSessionScheduleTime,
-  meetingHasStarted,
-  mostRecentPastMeeting,
-  nextUpcomingMeeting,
-  pickFocusMeeting,
-  sortSessionsByStart,
-} from '../lib/schedule'
-import type { Meeting, Session, Weekend, WeekendSession } from '../types'
-import { Trophy } from 'lucide-react'
-
-const missingDatasets = Object.fromEntries(
-  RACE_HUB_DATASETS.map((dataset) => [dataset, { status: 'missing', source: 'none', count: 0 }]),
-) as WeekendSession['datasets']
-
-function meetingStatus(meeting: Meeting, focusKey: number | undefined, now: Date) {
-  if (meeting.meeting_key === focusKey) return 'focus'
-  if (meetingHasStarted(meeting, now)) return 'past'
-  return 'future'
-}
-
-function pickAnalysisSession(weekend: Weekend | undefined): WeekendSession | undefined {
-  if (!weekend) return undefined
-  const local = weekend.sessions.filter((s) => s.source === 'local')
-  const partial = weekend.sessions.filter((s) => s.source === 'partial')
-  const pool = local.length > 0 ? local : partial.length > 0 ? partial : weekend.sessions
-  const race = pool.find((s) => s.session.session_type?.toLowerCase().includes('race'))
-  if (race) return race
-  const qual = pool.find((s) => s.session.session_type?.toLowerCase().includes('qualifying'))
-  if (qual) return qual
-  return pool[0]
-}
-
-export function CommandCenterPage() {
-  const [now, setNow] = useState(() => Date.now())
-
-  const seasonsQuery = useQuery({
-    queryKey: ['seasons'],
-    queryFn: fetchSeasons,
-  })
-
-  const latestSeason = seasonsQuery.data?.[0] ?? null
-
-  const meetingsQuery = useQuery({
-    queryKey: ['meetings', latestSeason],
-    queryFn: () => fetchLocalMeetings(latestSeason!),
-    enabled: latestSeason != null,
-  })
-
-  const seasonMeetingsQuery = useQuery({
-    queryKey: ['season-meetings', latestSeason],
-    queryFn: () => fetchSeasonMeetings(latestSeason!),
-    enabled: latestSeason != null,
-  })
-
-  const localMeetings = meetingsQuery.data ?? []
-  const seasonMeetings = seasonMeetingsQuery.data?.length ? seasonMeetingsQuery.data : localMeetings
-  const focusMeetings = seasonMeetings.length > 0 ? seasonMeetings : localMeetings
-
-  const weekendQueries = useQueries({
-    queries: localMeetings.map((meeting) => ({
-      queryKey: ['weekend', meeting.meeting_key],
-      queryFn: () => fetchWeekend(meeting.meeting_key),
-      enabled: localMeetings.length > 0,
-      staleTime: 60_000,
-    })),
-  })
-
-  const liveQuery = useQuery({
-    queryKey: ['live-state'],
-    queryFn: fetchLiveState,
-    staleTime: 5_000,
-  })
-
-  const championshipQuery = useQuery({
-    queryKey: ['championship-hub', latestSeason],
-    queryFn: () => fetchChampionshipHub(latestSeason!),
-    enabled: latestSeason != null,
-  })
-  const champHub = championshipQuery.data
-
-  useEffect(() => {
-    const timer = window.setInterval(() => setNow(Date.now()), 1000)
-    return () => window.clearInterval(timer)
-  }, [])
-
-  const nowDate = useMemo(() => new Date(now), [now])
-
-  const weekendsByKey = useMemo(() => {
-    const map = new Map<number, Weekend>()
-    localMeetings.forEach((meeting, i) => {
-      const data = weekendQueries[i]?.data
-      if (data) map.set(meeting.meeting_key, data)
-    })
-    return map
-  }, [localMeetings, weekendQueries])
-
-  const weekendList = useMemo(() => weekendQueries.map((q) => q.data), [weekendQueries])
-  const meetingStats = countWeekendStats(weekendList)
-  const focusMeeting = pickFocusMeeting(focusMeetings, nowDate)
-  const focusWeekend = focusMeeting ? weekendsByKey.get(focusMeeting.meeting_key) : undefined
-  const openF1SessionsQuery = useQuery({
-    queryKey: ['sessions', focusMeeting?.meeting_key, 'openf1'],
-    queryFn: () => fetchSessions(focusMeeting!.meeting_key, 'openf1'),
-    enabled: focusMeeting != null && focusWeekend == null,
-    staleTime: 60_000,
-  })
-  const openF1WeekendSessions: WeekendSession[] = useMemo(
-    () =>
-      (openF1SessionsQuery.data ?? []).map((session) => ({
-        session,
-        source: 'none',
-        datasets: missingDatasets,
-      })),
-    [openF1SessionsQuery.data],
-  )
-  const focusWeekendSessions = focusWeekend?.sessions ?? openF1WeekendSessions
-  const focusKind = focusMeeting ? focusMeetingKind(focusMeeting, nowDate) : null
-  const focusSessions: Session[] = sortSessionsByStart(focusWeekendSessions.map((s) => s.session))
-  const { current: currentSession, next: nextSession } = currentAndNextSession(focusSessions, nowDate)
-
-  const analysisSession = pickAnalysisSession(focusWeekend)
-  const actionSession =
-    analysisSession?.session ??
-    currentSession ??
-    nextSession ??
-    focusWeekendSessions.find((s) => s.session.session_key === focusWeekend?.default_session_key)?.session ??
-    focusWeekendSessions[0]?.session
-  const analysisSessionKey = actionSession?.session_key
-
-  const liveActive = liveQuery.data?.is_live === true
-  const heroStateKind = heroState({
-    now: nowDate,
-    liveActive,
-    currentSession,
-    focusKind,
-  })
-
-  const lastPastMeeting = useMemo(
-    () => mostRecentPastMeeting(focusMeetings, nowDate),
-    [focusMeetings, nowDate],
-  )
-  const lastPastWeekend = lastPastMeeting ? weekendsByKey.get(lastPastMeeting.meeting_key) : undefined
-  const lastRaceAnalysis = pickAnalysisSession(lastPastWeekend)
-  const lastRaceSessionKey = lastRaceAnalysis?.session.session_key
-
-  const lastRaceHubQuery = useQuery({
-    queryKey: ['race-hub', lastRaceSessionKey, 'hero-podium'],
-    queryFn: () => fetchRaceHub(lastRaceSessionKey!),
-    enabled: lastRaceSessionKey != null && heroStateKind === 'between',
-    staleTime: 60_000,
-  })
-
-  const nextMeetingForHero = useMemo(() => {
-    if (heroStateKind !== 'between') return null
-    return nextUpcomingMeeting(focusMeetings, nowDate)
-  }, [heroStateKind, focusMeetings, nowDate])
-
-  const lastRacePodium = lastRaceHubQuery.data?.results ?? []
-  const lastRaceName = champHub?.last_race ?? lastPastMeeting?.meeting_name ?? ''
-
-  if (seasonsQuery.isLoading) {
-    return <div className="page loading-state">loading command center…</div>
-  }
-
-  if (seasonsQuery.isError) {
-    return (
-      <div className="page error-box">
-        {seasonsQuery.error instanceof Error ? seasonsQuery.error.message : 'Failed to load seasons'}
-      </div>
-    )
-  }
-
-  const seasons = seasonsQuery.data ?? []
-
-  if (seasons.length === 0) {
-    return (
-      <div className="cc-page cc-empty" data-testid="command-center-empty">
-        <div className="cc-empty-band">
-          <span className="cc-empty-eyebrow mono">box-box · command center</span>
-          <h1 className="cc-empty-title">No local data yet</h1>
-          <p className="cc-empty-sub">
-            Ingest a race weekend from the CLI to populate this screen with live status, next-session
-            countdowns, and analysis links.
-          </p>
-        </div>
-        <div className="cc-empty-actions">
-          <Link to="/live" className="cc-action cc-action-live">
-            <span className="cc-action-label">Live Timing</span>
-            <span className="cc-action-meta">Standby</span>
-          </Link>
-          <Link to="/admin" className="cc-action">
-            <span className="cc-action-label">Admin · Data Health</span>
-            <span className="cc-action-meta">Ingestion guidance</span>
-          </Link>
-        </div>
-      </div>
-    )
-  }
-
-  const accent = countryAccent(focusMeeting ?? null)
-  const accentStyle = { '--gp-accent': accent } as React.CSSProperties
-
-  return (
-    <div className="cc-page" data-testid="command-center" style={accentStyle}>
-      <div className="cc-topbar">
-        <span className="cc-topbar-label mono">box-box · command center</span>
-        <span className="cc-topbar-meta mono">
-          {latestSeason} season · {meetingStats.full}/{meetingStats.total || 0} weekends full
-        </span>
-        <span className="cc-live-pill" data-testid="cc-live-status">
-          <span className={`cc-live-dot ${liveActive ? 'live' : ''}`} />
-          {liveActive ? 'Live session active' : 'No live session'}
-        </span>
-      </div>
-
-      {!focusMeeting && (
-        <div className="missing-notice">
-          No meetings ingested for {latestSeason}. Run{' '}
-          <code>box-box --ingest-year {latestSeason}</code>
-        </div>
-      )}
-
-      {focusMeeting && focusKind && (
-        <CommandCenterHero
-          state={heroStateKind}
-          now={nowDate}
-          accent={accent}
-          liveActive={liveActive}
-          liveData={liveQuery.data?.data}
-          focusMeeting={focusMeeting}
-          focusKind={focusKind}
-          sessions={focusWeekendSessions}
-          currentSession={currentSession}
-          nextSession={nextSession}
-          analysisSessionKey={analysisSessionKey}
-          analysisSessionName={actionSession?.session_name}
-          lastRaceName={lastRaceName}
-          lastRacePodium={lastRacePodium}
-          lastRaceSessionKey={lastRaceSessionKey}
-          nextMeeting={nextMeetingForHero}
-        />
-      )}
-
-      <div className="cc-dashboard-grid">
-        <div className="cc-dashboard-main">
-          <div 
-            className="cc-ambient-aura" 
-            aria-hidden="true" 
-            style={focusMeeting ? { '--aura-accent': countryAccent(focusMeeting) } as React.CSSProperties : undefined} 
-          />
-          <div className="cc-dashboard-panel">
-            {seasonMeetings.length > 0 && (
-              <section className="cc-season-calendar" data-testid="cc-season-calendar">
-              <div className="sec-header">
-                <span className="sec-title">Season Calendar</span>
-                <span className="sec-meta mono">
-                  {seasonMeetings.length} rounds · {meetingStats.full}/{meetingStats.total || 0} local
-                </span>
-              </div>
-              <div className="cc-calendar-grid" role="list">
-                {seasonMeetings.map((meeting, index) => {
-                  const weekend = weekendsByKey.get(meeting.meeting_key)
-                  const target = pickAnalysisSession(weekend)
-                  const targetKey = target?.session.session_key ?? weekend?.default_session_key
-                  const status = meetingStatus(meeting, focusMeeting?.meeting_key, nowDate)
-                  const cardAccent = countryAccent(meeting)
-                  return (
-                    <Link
-                      key={meeting.meeting_key}
-                      to="/race-hub"
-                      search={targetKey ? { session_key: targetKey } : {}}
-                      className={`cc-calendar-card cc-calendar-${status}`}
-                      data-testid={`cc-calendar-${meeting.meeting_key}`}
-                      role="listitem"
-                      style={{ '--gp-card-accent': cardAccent } as React.CSSProperties}
-                    >
-                      <div className="cc-calendar-accent" aria-hidden="true" />
-                      <div className="cc-calendar-top mono">
-                        <span className="cc-calendar-round">R{String(index + 1).padStart(2, '0')}</span>
-                        <span className={`cc-cov-dot cc-cov-${weekend?.source ?? 'none'}`} aria-hidden="true" />
-                      </div>
-                      <div className="cc-calendar-id">
-                        {countryFlag(meeting) && <span className="cc-calendar-flag">{countryFlag(meeting)}</span>}
-                      </div>
-                      <span className="cc-calendar-decal mono">{countryDecal(meeting)}</span>
-                      <div className="cc-calendar-copy">
-                        <div className="cc-calendar-name">{meeting.meeting_name}</div>
-                        <div className="cc-calendar-circuit mono">{meeting.circuit_short_name || meeting.location}</div>
-                        <div className="cc-calendar-date mono">{formatGpDateRange(meeting)}</div>
-                      </div>
-                    </Link>
-                  )
-                })}
-              </div>
-              {seasonMeetingsQuery.isError && (
-                <div className="cc-side-empty">Using local meetings because the full calendar could not load.</div>
-              )}
-            </section>
-            )}
-          </div>
-        </div>
-
-        <div className="cc-dashboard-sidebar">
-          {champHub && (
-            <section className="cc-champ-snapshot glass-panel" data-testid="cc-champ-snapshot" style={{ padding: 'var(--s5)', borderRadius: '12px' }}>
-              <div className="cc-champ-header">
-                <span>Championship Leaders</span>
-                <Link to="/championship" className="cc-champ-link">Full Standings →</Link>
-              </div>
-              <div className="cc-champ-group-label">Drivers</div>
-              <div className="cc-champ-list">
-                {champHub.drivers.slice(0, 3).map((d) => (
-                  <div key={d.driver_number} className="cc-champ-row">
-                    <div className="cc-champ-left">
-                      <div className="cc-champ-color" style={{ color: `#${d.team_colour}`, background: 'currentColor' }} />
-                      <span className="cc-champ-name">{d.name_acronym}</span>
-                    </div>
-                    <div className="cc-champ-form" title="Last 5 races">
-                      <FormSparkline form={d.form} color={`#${d.team_colour}`} />
-                    </div>
-                    <div className="cc-champ-right">
-                      <span className="cc-champ-gap">
-                        {d.position === 1 ? '—' : `-${champHub.drivers[0].points - d.points}`}
-                      </span>
-                      <span className="cc-champ-pts">{d.points}</span>
-                    </div>
-                  </div>
-                ))}
-              </div>
-              <div className="cc-champ-group-label">Constructors</div>
-              <div className="cc-champ-list">
-                {champHub.teams.slice(0, 3).map((t, i) => (
-                  <div key={t.team_name} className="cc-champ-row">
-                    <div className="cc-champ-left">
-                      <div className="cc-champ-color" style={{ color: `#${t.team_colour}`, background: 'currentColor' }} />
-                      <span className="cc-champ-name">{t.team_name}</span>
-                    </div>
-                    <div className="cc-champ-form" style={{ opacity: 0.4, fontSize: '11px', display: 'flex', gap: '4px', alignItems: 'center' }} title={`${t.wins} Wins`}>
-                      <Trophy size={12} /> {t.wins}
-                    </div>
-                    <div className="cc-champ-right">
-                      <span className="cc-champ-gap">
-                        {i === 0 ? '—' : `-${champHub.teams[0].points - t.points}`}
-                      </span>
-                      <span className="cc-champ-pts">{t.points}</span>
-                    </div>
-                  </div>
-                ))}
-              </div>
-            </section>
-          )}
-
-          {focusWeekendSessions.length > 0 && (
-            <section className="cc-schedule" data-testid="cc-schedule">
-              <div className="sec-header">
-                <span className="sec-title">Weekend Schedule</span>
-                <span className="sec-meta mono">{focusWeekendSessions.length} sessions</span>
-              </div>
-              <div className="cc-session-strip" role="list">
-                {focusWeekendSessions.map(({ session, source, datasets }) => {
-                  const status = classifySessionStatus(session, nowDate)
-                  const isNext = nextSession?.session_key === session.session_key
-                  const isCurrent = currentSession?.session_key === session.session_key
-                  const isLive = isCurrent && liveActive
-                  return (
-                    <Link
-                      key={session.session_key}
-                      to="/race-hub"
-                      search={{ session_key: session.session_key }}
-                      className={`cc-session-card ui-card interactive cc-status-${status}${isNext ? ' is-next' : ''}${
-                        isLive ? ' is-live glass-panel' : ''
-                      }`}
-                      data-testid={`cc-session-${session.session_key}`}
-                      role="listitem"
-                    >
-                      <div className="cc-session-card-head">
-                        <span className="cc-session-abbrev mono">
-                          {sessionTypeAbbrev(session.session_type, session.session_name)}
-                        </span>
-                        <span className={`cc-session-status cc-status-pill-${status}`}>
-                          {isCurrent ? 'On track' : status === 'done' ? 'Done' : isNext ? 'Next' : 'Upcoming'}
-                        </span>
-                      </div>
-                      <div className="cc-session-name">{session.session_name}</div>
-                      <div className="cc-session-time mono">{formatSessionScheduleTime(session.date_start)}</div>
-                      <div className="cc-session-cov mono">
-                        <span className={`cc-cov-dot cc-cov-${source}`} aria-hidden="true" />
-                        {formatCoverageHint(datasets)}
-                      </div>
-                    </Link>
-                  )
-                })}
-              </div>
-            </section>
-          )}
-
-          <PaddockBriefing />
-        </div>
-      </div>
-    </div>
-  )
-}
-
-function FormSparkline({ form, color }: { form: number[], color: string }) {
-  if (!form || form.length === 0) return null
-  const max = Math.max(...form, 26) // 26 is standard max for a race win
-  const width = 45
-  const height = 14
-  const step = width / Math.max(form.length - 1, 1)
-
-  const points = form.map((val, i) => {
-    const x = i * step
-    const y = height - (val / max) * height
-    return `${x},${y}`
-  }).join(' ')
-
-  return (
-    <svg width={width} height={height} style={{ overflow: 'visible' }}>
-      <polyline
-        fill="none"
-        stroke={color}
-        strokeWidth="1.5"
-        strokeLinecap="round"
-        strokeLinejoin="round"
-        points={points}
-      />
-    </svg>
-  )
-}
-

frontend/src/pages/DataLibraryPage.tsx

@@ -11,6 +11,7 @@ import {
 import { SourceBadge, weekendStatusLabel } from '../components/SourceBadge'
 import { CliCommands, ingestYearCommands } from '../components/CliCommands'
 import { MeetingDetailPanel } from '../components/MeetingDetailPanel'
+import { RouteState } from '../components/RouteState'
 import type { Meeting, Weekend } from '../types'
 
 function formatMeetingDate(meeting: Meeting): string {
@@ -27,12 +28,12 @@ export function DataLibraryPage() {
 
   const seasonsQuery = useQuery({
     queryKey: ['seasons'],
-    queryFn: fetchSeasons,
+    queryFn: ({ signal }) => fetchSeasons(signal),
   })
 
   const meetingsQuery = useQuery({
     queryKey: ['meetings', selectedYear],
-    queryFn: () => fetchLocalMeetings(selectedYear!),
+    queryFn: ({ signal }) => fetchLocalMeetings(selectedYear!, signal),
     enabled: selectedYear != null,
   })
 
@@ -41,7 +42,7 @@ export function DataLibraryPage() {
   const weekendQueries = useQueries({
     queries: meetings.map((meeting) => ({
       queryKey: ['weekend', meeting.meeting_key],
-      queryFn: () => fetchWeekend(meeting.meeting_key),
+      queryFn: ({ signal }: { signal: AbortSignal }) => fetchWeekend(meeting.meeting_key, signal),
       enabled: meetings.length > 0,
       staleTime: 60_000,
     })),
@@ -78,13 +79,26 @@ export function DataLibraryPage() {
   const weekendsLoading = weekendQueries.some((q) => q.isLoading)
 
   if (seasonsQuery.isLoading) {
-    return <div className="page loading-state">loading local data library…</div>
+    return (
+      <div className="page">
+        <RouteState kind="loading" title="loading local data library…" testId="weekend-loading" />
+      </div>
+    )
   }
 
   if (seasonsQuery.isError) {
     return (
-      <div className="page error-box">
-        {seasonsQuery.error instanceof Error ? seasonsQuery.error.message : 'Failed to load seasons'}
+      <div className="page">
+        <RouteState
+          kind="error"
+          title="Weekend data unavailable"
+          error={seasonsQuery.error}
+          onRetry={() => {
+            if (!seasonsQuery.isFetching) void seasonsQuery.refetch()
+          }}
+          retrying={seasonsQuery.isFetching}
+          testId="weekend-error"
+        />
       </div>
     )
   }
@@ -222,15 +236,20 @@ export function DataLibraryPage() {
           </div>
 
           {meetingsQuery.isLoading && (
-            <div className="loading-state">loading meetings…</div>
+            <RouteState kind="loading" title="loading meetings…" testId="weekend-meetings-loading" />
           )}
 
           {meetingsQuery.isError && (
-            <div className="error-box">
-              {meetingsQuery.error instanceof Error
-                ? meetingsQuery.error.message
-                : 'Failed to load meetings'}
-            </div>
+            <RouteState
+              kind="error"
+              title="Weekend meetings unavailable"
+              error={meetingsQuery.error}
+              onRetry={() => {
+                if (!meetingsQuery.isFetching) void meetingsQuery.refetch()
+              }}
+              retrying={meetingsQuery.isFetching}
+              testId="weekend-error"
+            />
           )}
 
           {!meetingsQuery.isLoading && !meetingsQuery.isError && meetings.length === 0 && (
@@ -316,11 +335,16 @@ export function DataLibraryPage() {
 
               <div className="dl-detail-wrap">
                 {weekendsLoading && selectedWeekend == null && (
-                  <div className="loading-state">loading weekend details…</div>
+                  <RouteState kind="loading" title="loading weekend details…" testId="weekend-detail-loading" />
                 )}
                 {selectedWeekend && <MeetingDetailPanel weekend={selectedWeekend} />}
                 {selectedMeetingKey != null && !weekendsLoading && selectedWeekend == null && (
-                  <div className="missing-notice">Could not load weekend details.</div>
+                  <RouteState
+                    kind="empty"
+                    title="Weekend details missing"
+                    message="Could not load weekend details for this meeting."
+                    testId="weekend-detail-empty"
+                  />
                 )}
               </div>
             </div>

frontend/src/pages/DriverProfilePage.tsx

@@ -1,6 +1,8 @@
 import { useQuery } from '@tanstack/react-query'
 import { Link } from '@tanstack/react-router'
 import { fetchDriverSummary, fetchSeasons } from '../api'
+import { DataNotice, RouteState } from '../components/RouteState'
+import { noticeFromResponse, noticeMessage } from '../lib/availability'
 import { teamColor } from '../utils'
 import { countryFlag } from '../lib/gpIdentity'
 import {
@@ -26,7 +28,7 @@ export function DriverProfilePage({ driverNumber, year }: Props) {
   // seasons list is empty/unavailable the backend falls back to the current year.
   const seasonsQuery = useQuery({
     queryKey: ['seasons'],
-    queryFn: fetchSeasons,
+    queryFn: ({ signal }) => fetchSeasons(signal),
     enabled: year == null,
   })
   const resolvedYear = year ?? seasonsQuery.data?.[0]
@@ -34,39 +36,102 @@ export function DriverProfilePage({ driverNumber, year }: Props) {
 
   const summaryQuery = useQuery({
     queryKey: ['driver-summary', driverNumber, resolvedYear ?? 'latest'],
-    queryFn: () => fetchDriverSummary(driverNumber, resolvedYear),
+    queryFn: ({ signal }) => fetchDriverSummary(driverNumber, resolvedYear, signal),
     enabled: seasonsSettled && driverNumber > 0,
     staleTime: 5 * 60_000,
   })
 
   if (driverNumber <= 0) {
-    return <div className="page error-box">Invalid driver number</div>
+    return (
+      <div className="page">
+        <RouteState kind="empty" title="Invalid driver number" message="Pick a driver from the championship standings." />
+      </div>
+    )
   }
   if (!seasonsSettled || summaryQuery.isLoading) {
-    return <div className="page loading-state">loading driver profile…</div>
+    return (
+      <div className="page">
+        <RouteState kind="loading" title="loading driver profile…" testId="driver-profile-loading" />
+      </div>
+    )
   }
   if (summaryQuery.isError) {
     return (
-      <div className="page error-box">
-        {summaryQuery.error instanceof Error
-          ? summaryQuery.error.message
-          : 'Failed to load driver profile'}
+      <div className="page">
+        <RouteState
+          kind="error"
+          title="Driver profile unavailable"
+          error={summaryQuery.error}
+          onRetry={() => {
+            if (!summaryQuery.isFetching) void summaryQuery.refetch()
+          }}
+          retrying={summaryQuery.isFetching}
+          testId="driver-profile-error"
+        />
       </div>
     )
   }
   const summary = summaryQuery.data
   if (!summary) {
-    return <div className="page error-box">No driver data</div>
+    return (
+      <div className="page">
+        <RouteState
+          kind="empty"
+          title="No driver data"
+          message="This driver is not in the local season standings yet."
+        />
+      </div>
+    )
   }
-  return <DriverProfileBody summary={summary} />
+  return (
+    <DriverProfileBody
+      summary={summary}
+      availability={noticeFromResponse(summary, { includeLocal: false })}
+      onRetry={() => {
+        if (!summaryQuery.isFetching) void summaryQuery.refetch()
+      }}
+      retrying={summaryQuery.isFetching}
+    />
+  )
 }
 
-function DriverProfileBody({ summary }: { summary: DriverSummary }) {
+function DriverProfileBody({
+  summary,
+  availability,
+  onRetry,
+  retrying,
+}: {
+  summary: DriverSummary
+  availability?: ReturnType<typeof noticeFromResponse>
+  onRetry?: () => void
+  retrying?: boolean
+}) {
   const color = teamColor(summary.team_colour)
   const deltas = gridFinishDeltas(summary.rounds)
 
   return (
     <div className="dp-page" data-testid="driver-profile">
+      {summary.enrichment === 'limited' && (
+        <DataNotice
+          availability="limited"
+          message="Optional remote details are unavailable. Showing local season identity and results."
+          onRetry={onRetry}
+          retrying={retrying}
+          testId="driver-profile-limited"
+        />
+      )}
+      {summary.source === 'local' && summary.enrichment !== 'limited' && (
+        <DataNotice availability="local" message="Loaded from local season data." testId="driver-profile-local" />
+      )}
+      {availability === 'stale' && summary.enrichment !== 'limited' && (
+        <DataNotice
+          availability="stale"
+          message={noticeMessage('stale')}
+          onRetry={onRetry}
+          retrying={retrying}
+          testId="driver-profile-stale"
+        />
+      )}
       <header className="dp-header" data-testid="dp-header" style={{ borderLeftColor: color }}>
         <div className="dp-identity">
           <div className="dp-title-row">

frontend/src/pages/ExplorePage.tsx

@@ -0,0 +1,159 @@
+import { useMemo } from 'react'
+import { useQueries, useQuery } from '@tanstack/react-query'
+import { Link } from '@tanstack/react-router'
+import {
+  fetchChampionshipHub,
+  fetchLocalMeetings,
+  fetchSeasonMeetings,
+  fetchSeasons,
+  fetchWeekend,
+} from '../api'
+import { countryFlag, formatGpDateRange } from '../lib/gpIdentity'
+import { meetingHasStarted } from '../lib/schedule'
+import { teamColor } from '../utils'
+import type { Weekend } from '../types'
+import '../styles/weekend.css'
+
+function analysisKey(weekend: Weekend | undefined): number | undefined {
+  if (!weekend) return undefined
+  const race = weekend.sessions.find((s) => s.session.session_type?.toLowerCase().includes('race'))
+  return race?.session.session_key ?? weekend.default_session_key
+}
+
+export function ExplorePage() {
+  const now = useMemo(() => new Date(), [])
+
+  const seasonsQuery = useQuery({
+    queryKey: ['seasons'],
+    queryFn: ({ signal }) => fetchSeasons(signal),
+  })
+  const season = seasonsQuery.data?.[0] ?? null
+
+  const localMeetingsQuery = useQuery({
+    queryKey: ['meetings', season, 'local'],
+    queryFn: ({ signal }) => fetchLocalMeetings(season!, signal),
+    enabled: season != null,
+  })
+  const seasonMeetingsQuery = useQuery({
+    queryKey: ['season-meetings', season],
+    queryFn: ({ signal }) => fetchSeasonMeetings(season!, signal),
+    enabled: season != null,
+  })
+  const championshipQuery = useQuery({
+    queryKey: ['championship-hub', season],
+    queryFn: ({ signal }) => fetchChampionshipHub(season!, signal),
+    enabled: season != null,
+  })
+
+  const localMeetings = localMeetingsQuery.data ?? []
+  const meetings = seasonMeetingsQuery.data?.length ? seasonMeetingsQuery.data : localMeetings
+
+  const weekendQueries = useQueries({
+    queries: localMeetings.map((m) => ({
+      queryKey: ['weekend', m.meeting_key],
+      queryFn: ({ signal }: { signal: AbortSignal }) => fetchWeekend(m.meeting_key, signal),
+      enabled: localMeetings.length > 0,
+      staleTime: 60_000,
+    })),
+  })
+  const weekendsByKey = useMemo(() => {
+    const map = new Map<number, Weekend>()
+    localMeetings.forEach((m, i) => {
+      const data = weekendQueries[i]?.data
+      if (data) map.set(m.meeting_key, data)
+    })
+    return map
+  }, [localMeetings, weekendQueries])
+
+  const drivers = championshipQuery.data?.drivers ?? []
+  const activeMeetings = meetings.filter((m) => !m.is_cancelled)
+
+  if (seasonsQuery.isLoading) {
+    return <div className="wk-status" data-testid="explore-loading"><p className="wk-status-title">Loading…</p></div>
+  }
+
+  return (
+    <main className="wk-page wk-explore" data-testid="explore-page">
+      <div className="wk-eyebrow mono">Explore · {season ?? 'season'}</div>
+
+      <section className="wk-explore-section" aria-labelledby="explore-calendar-title">
+        <header className="wk-card-head">
+          <span className="wk-card-title" id="explore-calendar-title">Season races</span>
+          <span className="wk-card-link mono">{activeMeetings.length} rounds</span>
+        </header>
+        {activeMeetings.length === 0 ? (
+          <p className="wk-status-sub" data-testid="explore-calendar-empty">No season calendar available yet.</p>
+        ) : (
+          <ol className="wk-explore-grid" role="list">
+            {activeMeetings.map((meeting, index) => {
+              const weekend = weekendsByKey.get(meeting.meeting_key)
+              const target = analysisKey(weekend)
+              const done = meetingHasStarted(meeting, now)
+              const card = (
+                <>
+                  <div className="wk-explore-top mono">
+                    <span>R{String(index + 1).padStart(2, '0')}</span>
+                    <span className="wk-explore-flag">
+                      {countryFlag(meeting) || meeting.country_code}
+                    </span>
+                  </div>
+                  <div className="wk-explore-name">{meeting.meeting_name}</div>
+                  <div className="wk-explore-meta mono">{meeting.circuit_short_name || meeting.location}</div>
+                  <div className="wk-explore-meta mono">{formatGpDateRange(meeting)}</div>
+                  <span className={`wk-explore-state ${done ? 'is-done' : 'is-upcoming'}`}>
+                    {done ? 'Completed' : 'Upcoming'}
+                  </span>
+                </>
+              )
+              return (
+                <li key={meeting.meeting_key} className="wk-explore-item" role="listitem">
+                  {target ? (
+                    <Link
+                      to="/race-hub"
+                      search={{ session_key: target }}
+                      className="wk-explore-card is-link"
+                      data-testid={`explore-race-${meeting.meeting_key}`}
+                    >
+                      {card}
+                    </Link>
+                  ) : (
+                    <div className="wk-explore-card" data-testid={`explore-race-${meeting.meeting_key}`}>{card}</div>
+                  )}
+                </li>
+              )
+            })}
+          </ol>
+        )}
+      </section>
+
+      <section className="wk-explore-section" aria-labelledby="explore-drivers-title">
+        <header className="wk-card-head">
+          <span className="wk-card-title" id="explore-drivers-title">Drivers</span>
+          <Link to="/championship" className="wk-card-link">Championship →</Link>
+        </header>
+        {drivers.length === 0 ? (
+          <p className="wk-status-sub" data-testid="explore-drivers-empty">Driver data not available yet.</p>
+        ) : (
+          <ol className="wk-explore-drivers" role="list">
+            {drivers.map((d) => (
+              <li key={d.driver_number} role="listitem">
+                <Link
+                  to="/drivers/$driverNumber"
+                  params={{ driverNumber: String(d.driver_number) }}
+                  search={season ? { year: season } : {}}
+                  className="wk-driver-chip"
+                  style={{ ['--wk-team' as string]: teamColor(d.team_colour) }}
+                  data-testid={`explore-driver-${d.driver_number}`}
+                >
+                  <span className="wk-driver-pos mono">{d.position}</span>
+                  <span className="wk-driver-code">{d.name_acronym}</span>
+                  <span className="wk-driver-pts mono">{d.points}</span>
+                </Link>
+              </li>
+            ))}
+          </ol>
+        )}
+      </section>
+    </main>
+  )
+}

frontend/src/pages/LiveTimingPage.tsx

@@ -1,6 +1,6 @@
 import { useEffect, useMemo, useRef, useState } from 'react'
 import { useQuery } from '@tanstack/react-query'
-import { fetchLiveState } from '../api'
+import { fetchLiveState, fetchWeekendContext } from '../api'
 import type { LivePosition, LiveStreamData } from '../types'
 import {
   loadPinnedDrivers,
@@ -17,6 +17,15 @@ import { recordGapSamples } from '../lib/gapHistory'
 import { battleNumbers, detectBattles } from '../lib/battles'
 import type { LiveEvent } from '../lib/events'
 import { appendEvents, diffSnapshots, sessionSignature } from '../lib/events'
+import {
+  allowsLiveInterpretations,
+  deriveLivePhase,
+  effectiveFeedHealth,
+  rendersSnapshot,
+  terminalSessionStatus,
+} from '../lib/liveState'
+import type { TransportHealth } from '../lib/liveState'
+import { shouldPollHandoffAnalysis } from '../components/live/LiveHandoff'
 import { SessionBanner } from '../components/live/SessionBanner'
 import { TrackStatusBanner } from '../components/live/TrackStatusBanner'
 import { TimingTower } from '../components/live/TimingTower'
@@ -26,9 +35,14 @@ import { RaceControlFeed } from '../components/live/RaceControlFeed'
 import { EventRail } from '../components/live/EventRail'
 import { TeamRadioTicker } from '../components/live/TeamRadioTicker'
 import { TyreDegPanel } from '../components/live/TyreDegPanel'
-import { Archive, Radio } from 'lucide-react'
+import { LiveHandoff } from '../components/live/LiveHandoff'
+import { DataNotice, RouteState } from '../components/RouteState'
+import { weekendContextNotice } from '../lib/availability'
+import '../styles/live-state.css'
 
-type StreamStatus = 'connecting' | 'connected' | 'disconnected' | 'error'
+/** How often to re-check weekend-context while analysis is still ingesting. */
+export const WEEKEND_CONTEXT_POLL_MS = 15_000
+const WEEKEND_CONTEXT_STALE_MS = 15_000
 
 export function LiveTimingPage() {
   const [activeSnapshot, setActiveSnapshot] = useState<LiveStreamData | null>(null)
@@ -37,31 +51,96 @@ export function LiveTimingPage() {
   const [archiveSnapshotAt, setArchiveSnapshotAt] = useState<string | null>(null)
   const [archiveMode, setArchiveMode] = useState(false)
   const [isLive, setIsLive] = useState(false)
-  const [streamStatus, setStreamStatus] = useState<StreamStatus>('connecting')
+  const [streamStatus, setStreamStatus] = useState<TransportHealth>('connecting')
   const [now, setNow] = useState(Date.now())
   const [gapHistory, setGapHistory] = useState<GapHistoryMap>({})
   const [pinned, setPinned] = useState<string[]>(() => loadPinnedDrivers())
   const [visibleSectors, setVisibleSectors] = useState<VisibleSectorState>({})
-  const [positions, setPositions] = useState<Record<string, LivePosition>>({})
+  const [, setPositions] = useState<Record<string, LivePosition>>({})
   const [events, setEvents] = useState<LiveEvent[]>([])
+  // Authoritative SSE snapshot/event receipt — distinct from non-null timing rows.
+  // An inactive `is_live:false,data:null,last_snapshot:null` event is still valid.
+  const [authoritativeSseReceived, setAuthoritativeSseReceived] = useState(false)
   const prevSnapshotRef = useRef<LiveStreamData | null>(null)
   const sessionSigRef = useRef('')
   const isLiveRef = useRef(false)
   const archiveModeRef = useRef(false)
-  const snapshot = isLive ? activeSnapshot : archiveMode ? archiveSnapshot : null
+  // Whether we ever observed this session as live — used to reason about a
+  // dropped feed vs. a session that was never live in this page session.
+  const wasLiveRef = useRef(false)
   const hasArchive = Boolean(archiveSnapshot)
 
-  const { data, isLoading, isError, error } = useQuery({
+  const {
+    data,
+    isLoading,
+    isError,
+    error,
+    refetch,
+    isFetching,
+    isFetched: liveStateFetched,
+  } = useQuery({
     queryKey: ['live-state'],
-    queryFn: fetchLiveState,
+    queryFn: ({ signal }) => fetchLiveState(signal),
     staleTime: 5_000,
   })
 
+  // A retained snapshot is only "settled" (session genuinely finished) if it
+  // carries a terminal FIA SessionStatus. Otherwise the upstream feed dropped
+  // while the session was still active and we must stay in `disconnected`.
+  const sessionEndedCleanly = terminalSessionStatus(archiveSnapshot?.SessionStatus)
+
+  // Transport health, active-session state, and archive availability are
+  // orthogonal inputs; deriveLivePhase collapses them into one UI phase.
+  const phase = deriveLivePhase({
+    transport: streamStatus,
+    isLive,
+    hasActiveSnapshot: Boolean(activeSnapshot),
+    hasArchive,
+    archiveMode,
+    sessionEndedCleanly,
+    wasLive: wasLiveRef.current,
+    stateLoaded: liveStateFetched,
+  })
+  const snapshot =
+    phase === 'archive'
+      ? archiveSnapshot
+      : isLive
+        ? activeSnapshot
+        : phase === 'disconnected'
+          ? archiveSnapshot
+          : null
+
+  // Canonical weekend context (issue #72) — the single source of truth for
+  // previous/next/default-analysis identity and temporal state. Only needed
+  // when no session is streaming; keep it idle during a live session. Poll
+  // while a completed session is still ingesting so `settling` can flip to
+  // analysis-ready without a manual refresh.
+  const contextQuery = useQuery({
+    queryKey: ['weekend-context'],
+    queryFn: ({ signal }) => fetchWeekendContext(signal),
+    enabled: !isLive,
+    staleTime: WEEKEND_CONTEXT_STALE_MS,
+    refetchInterval: (query) => {
+      // Poll until the just-finished previous_completed_session is ready — an
+      // older already-complete default_analysis_session must not stop us.
+      return shouldPollHandoffAnalysis(query.state.data) ? WEEKEND_CONTEXT_POLL_MS : false
+    },
+    refetchIntervalInBackground: false,
+  })
+  const weekendContext = contextQuery.data
+  // Context freshness belongs only on inactive/settling handoff — never relabel
+  // active FIA timing because an optional REST supplement reported stale/limited.
+  const contextAvailabilityNotice =
+    (phase === 'settling' || phase === 'inactive') && weekendContext
+      ? weekendContextNotice(weekendContext)
+      : null
+
   useEffect(() => {
     if (!data) return
     const nextLive = data.is_live && Boolean(data.data)
     setIsLive(nextLive)
     isLiveRef.current = nextLive
+    if (nextLive) wasLiveRef.current = true
     if (nextLive && data.data) {
       setActiveSnapshot(data.data)
       setArchiveMode(false)
@@ -104,6 +183,9 @@ export function LiveTimingPage() {
     events.addEventListener('snapshot', (event) => {
       const state = parseLiveStateEvent(event.data)
       if (!state || cancelled) return
+      // Valid SSE state clears a false fatal REST error even when all snapshots
+      // are null (inactive handoff) — do not require non-null timing rows.
+      setAuthoritativeSseReceived(true)
       const nextLive = state.is_live && Boolean(state.data)
       setIsLive(nextLive)
       if (nextLive && state.data) {
@@ -111,6 +193,7 @@ export function LiveTimingPage() {
           setPositions({})
         }
         isLiveRef.current = true
+        wasLiveRef.current = true
         setActiveSnapshot(state.data)
         setArchiveMode(false)
       } else {
@@ -167,6 +250,8 @@ export function LiveTimingPage() {
   }, [snapshot])
 
   const rawRows = useMemo(() => sortLiveTimingRows(snapshot), [snapshot])
+  // Final-snapshot rows for the settling handoff (independent of live rows).
+  const settlingRows = useMemo(() => sortLiveTimingRows(archiveSnapshot), [archiveSnapshot])
 
   useEffect(() => {
     if (rawRows.length === 0) {
@@ -210,68 +295,100 @@ export function LiveTimingPage() {
     setPositions(archivePositions)
   }
 
+  const handleExitArchive = () => {
+    setArchiveMode(false)
+  }
+
   const archiveTimestamp = archiveSnapshotAt ? new Date(archiveSnapshotAt) : null
   const archiveLabel =
     archiveTimestamp && !Number.isNaN(archiveTimestamp.getTime())
       ? `Archived snapshot from ${archiveTimestamp.toLocaleString()}`
       : 'Archived live timing snapshot'
 
+  const showLiveInterpretations = allowsLiveInterpretations(phase)
+  // Upstream FIA loss can leave the browser SSE open; present one coherent
+  // feed-health truth rather than "Connection lost" + "Feed healthy".
+  const feedHealth = effectiveFeedHealth(streamStatus, phase)
+
+  // Usable timing rows OR an authoritative SSE state event (including inactive
+  // null payloads) clear the fatal initial REST error. Preserve error+Retry only
+  // when neither REST nor SSE yields a valid state.
+  const hasUsableStreamData = Boolean(activeSnapshot) || Boolean(archiveSnapshot)
+  const showInitialError = isError && !hasUsableStreamData && !authoritativeSseReceived
+
   return (
-    <div className="page live-page" data-testid="live-page">
-      {isError && (
-        <div className="error-box">
-          {error instanceof Error ? error.message : 'Failed to load live timing state'}
+    <div className="page live-page" data-testid="live-page" data-phase={phase}>
+      {showInitialError && (
+        <RouteState
+          kind="error"
+          title="Live timing unavailable"
+          error={error}
+          onRetry={() => {
+            if (!isFetching) void refetch()
+          }}
+          retrying={isFetching}
+          testId="live-initial-error"
+        />
+      )}
+
+      {phase === 'disconnected' && (
+        <div className="live-status-strip live-status-warn" data-testid="live-disconnected-strip">
+          Connection lost — showing the last live data while we reconnect. This is not an archive.
         </div>
       )}
 
-      {streamStatus === 'disconnected' && snapshot && !archiveMode && (
-        <div className="live-status-strip live-status-warn">
-          Stream disconnected — showing last received snapshot
-        </div>
-      )}
-
-      {archiveMode && snapshot && (
+      {phase === 'archive' && (
         <div className="live-status-strip live-status-archive" data-testid="live-archive-strip">
-          {archiveLabel} — live updates are paused for this archive view
-        </div>
-      )}
-
-      {isLoading && !snapshot && (
-        <div className="loading-state">connecting to live timing…</div>
-      )}
-
-      {!isLoading && !snapshot && (
-        <div className="empty-state ui-card glass-panel" style={{ padding: '40px', textAlign: 'center', marginTop: '20vh', maxWidth: '400px', marginLeft: 'auto', marginRight: 'auto' }} data-testid="live-empty">
-          <div className="live-empty-status" style={{ marginBottom: '16px' }}>
-            <span className={`live-conn live-conn-${streamStatus}`}>{streamStatus}</span>
-          </div>
-          <Radio size={48} style={{ color: 'var(--text-3)', margin: '0 auto 16px auto', display: 'block' }} />
-          <h2 className="empty-state-title" style={{ fontSize: '20px', marginBottom: '8px' }}>No live session active</h2>
-          <p className="empty-state-desc" style={{ color: 'var(--text-2)' }}>
-            The telemetry feed is currently offline. <br /><br /> Check the <a href="/" style={{ color: 'var(--red)', textDecoration: 'underline' }}>Command Center</a> for the weekend schedule or explore historical data in the <a href="/race-hub" style={{ color: 'var(--red)', textDecoration: 'underline' }}>Race Hub</a>.
-          </p>
-          {hasArchive && (
-            <button type="button" className="live-archive-btn" onClick={handleViewArchive}>
-              <Archive size={15} />
-              View Last Session
+          <span>{archiveLabel} — read-only, live updates are paused</span>
+          <button type="button" className="live-archive-exit" onClick={handleExitArchive}>
+            Exit archive
           </button>
-          )}
         </div>
       )}
 
-      {snapshot && (
+      {phase === 'connecting' && (isLoading || !liveStateFetched) && !hasUsableStreamData && (
+        <RouteState
+          kind="loading"
+          title="connecting to live timing…"
+          testId="live-initial-loading"
+        />
+      )}
+
+      {(phase === 'settling' || phase === 'inactive') && !showInitialError && (
+        <>
+          {contextAvailabilityNotice && (
+            <DataNotice
+              availability={contextAvailabilityNotice}
+              testId="live-context-data-notice"
+            />
+          )}
+          <LiveHandoff
+            phase={phase}
+            transport={feedHealth}
+            context={weekendContext}
+            rows={settlingRows}
+            capturedAt={archiveSnapshotAt}
+            hasArchive={hasArchive}
+            onViewArchive={handleViewArchive}
+          />
+        </>
+      )}
+
+      {snapshot && rendersSnapshot(phase) && (
         <>
           <SessionBanner
-            isLive={isLive}
-            isArchive={archiveMode}
+            phase={phase}
             snapshot={snapshot}
             rows={rows}
-            connection={streamStatus}
+            transport={feedHealth}
             now={now}
+            capturedAt={phase === 'archive' ? archiveSnapshotAt : null}
           />
           <TrackStatusBanner status={snapshot.TrackStatus} />
           <PinnedDrivers rows={rows} history={gapHistory} pinned={pinned} onToggle={handleTogglePin} />
+          {showLiveInterpretations && (
             <TyreDegPanel rows={rows} sessionType={snapshot.Session?.SessionType} pinned={pinned} />
+          )}
           <div className="live-columns">
             <div className="live-tower-col">
               <div className="sec-header">

frontend/src/pages/RaceHubPage.tsx

@@ -1,12 +1,8 @@
-import { useEffect, useMemo, useState } from 'react'
+import { useEffect, useState } from 'react'
 import { useQuery } from '@tanstack/react-query'
-import { useNavigate } from '@tanstack/react-router'
-import {
-  fetchLocalMeetings,
-  fetchRaceHub,
-  fetchSeasons,
-  fetchWeekend,
-} from '../api'
+import { Link, useNavigate } from '@tanstack/react-router'
+import { fetchRaceHub, fetchWeekend, fetchWeekendContext } from '../api'
+import { weekendFocusSearch } from '../lib/routeSearch'
 import { DatasetStrip } from '../components/DatasetStrip'
 import { RaceStoryCanvas } from '../components/RaceStoryCanvas'
 import { TabBar, type Tab } from '../components/TabBar'
@@ -17,80 +13,69 @@ import { CompareView } from '../components/CompareView'
 import { RaceControlView } from '../components/RaceControlView'
 import { WeatherView } from '../components/WeatherView'
 import { OverviewView } from '../components/OverviewView'
+import {
+  PartialAnalysisBanner,
+  PreSessionView,
+  SessionPhaseView,
+} from '../components/PreSessionView'
 import { WeekendSwitcher } from '../components/WeekendSwitcher'
 import { SourceBadge } from '../components/SourceBadge'
+import { DataNotice, RouteState } from '../components/RouteState'
+import { noticeFromResponse, noticeMessage } from '../lib/availability'
 import { countryAccent, countryDecal, formatGpDateRange } from '../lib/gpIdentity'
-import { formatCoverageHint, sessionTypeAbbrev } from '../lib/coverage'
+import { sessionTypeAbbrev } from '../lib/coverage'
+import { formatSessionScheduleTime, sortSessionsByStart } from '../lib/schedule'
 import {
-  formatSessionScheduleTime,
-  pickFocusMeeting,
-  sortSessionsByStart,
-} from '../lib/schedule'
-import type { Weekend, WeekendSession } from '../types'
+  defaultAnalysisSessionKey,
+  isPartialAnalysis,
+  isPreSession,
+  isPreparing,
+  isUnavailable,
+  resolveSessionState,
+  sessionStateDotClass,
+  sessionStateLabel,
+} from '../lib/sessionState'
+import type { WeekendSession } from '../types'
 
 interface Props {
   sessionKey: number
 }
 
-function pickAnalysisSession(weekend: Weekend | undefined): WeekendSession | undefined {
-  if (!weekend) return undefined
-  const local = weekend.sessions.filter((s) => s.source === 'local')
-  const partial = weekend.sessions.filter((s) => s.source === 'partial')
-  const pool = local.length > 0 ? local : partial.length > 0 ? partial : weekend.sessions
-  const race = pool.find((s) => s.session.session_type?.toLowerCase().includes('race'))
-  if (race) return race
-  const qual = pool.find((s) => s.session.session_type?.toLowerCase().includes('qualifying'))
-  if (qual) return qual
-  return pool[0]
-}
-
 export function RaceHubPage({ sessionKey }: Props) {
   const navigate = useNavigate()
   const [activeTab, setActiveTab] = useState<Tab>('overview')
   const [switcherOpen, setSwitcherOpen] = useState(false)
+  const [showDiagnostics, setShowDiagnostics] = useState(false)
+  const [phaseDiagnostics, setPhaseDiagnostics] = useState(false)
+  const [now, setNow] = useState(() => new Date())
 
-  // ─── Auto-redirect when no session_key is supplied ───
-  const seasonsQuery = useQuery({
-    queryKey: ['seasons'],
-    queryFn: fetchSeasons,
-    enabled: sessionKey === 0,
-  })
-
-  const latestSeason = seasonsQuery.data?.[0] ?? null
-
-  const meetingsQuery = useQuery({
-    queryKey: ['meetings', latestSeason],
-    queryFn: () => fetchLocalMeetings(latestSeason!),
-    enabled: sessionKey === 0 && latestSeason != null,
-  })
-
-  const focusMeeting = useMemo(() => {
-    if (sessionKey !== 0 || !meetingsQuery.data) return null
-    return pickFocusMeeting(meetingsQuery.data, new Date())
-  }, [sessionKey, meetingsQuery.data])
-
-  const fallbackWeekendQuery = useQuery({
-    queryKey: ['weekend', focusMeeting?.meeting_key],
-    queryFn: () => fetchWeekend(focusMeeting!.meeting_key),
-    enabled: sessionKey === 0 && focusMeeting != null,
+  // Keep schedule-adjacent UI (countdown) moving; Live/completion come from context.
+  useEffect(() => {
+    const id = window.setInterval(() => setNow(new Date()), 1000)
+    return () => window.clearInterval(id)
+  }, [])
+
+  const contextQuery = useQuery({
+    queryKey: ['weekend-context'],
+    queryFn: ({ signal }) => fetchWeekendContext(signal),
+    staleTime: 15_000,
+    refetchInterval: 30_000,
   })
+  const context = contextQuery.data ?? null
 
+  // Bare `/race-hub` resolves only through canonical Weekend Context.
   useEffect(() => {
     if (sessionKey !== 0) return
-    const weekend = fallbackWeekendQuery.data
-    if (!weekend) return
-    const target = pickAnalysisSession(weekend)?.session.session_key
-      ?? weekend.default_session_key
-      ?? weekend.sessions[0]?.session.session_key
+    if (!contextQuery.isSuccess || !context) return
+    const target = defaultAnalysisSessionKey(context)
     if (target) {
       navigate({ to: '/race-hub', search: { session_key: target }, replace: true })
     }
-  }, [sessionKey, fallbackWeekendQuery.data, navigate])
+  }, [sessionKey, contextQuery.isSuccess, context, navigate])
 
-  // ─── Active session payload ───
   const raceHubQuery = useQuery({
     queryKey: ['race-hub', sessionKey],
-    queryFn: () => fetchRaceHub(sessionKey),
+    queryFn: ({ signal }) => fetchRaceHub(sessionKey, signal),
     enabled: sessionKey > 0,
     staleTime: 30_000,
   })
@@ -98,7 +83,7 @@ export function RaceHubPage({ sessionKey }: Props) {
   const meetingKey = raceHubQuery.data?.meeting?.meeting_key
   const weekendQuery = useQuery({
     queryKey: ['weekend', meetingKey],
-    queryFn: () => fetchWeekend(meetingKey!),
+    queryFn: ({ signal }) => fetchWeekend(meetingKey!, signal),
     enabled: meetingKey != null && meetingKey > 0,
     staleTime: 60_000,
   })
@@ -108,37 +93,90 @@ export function RaceHubPage({ sessionKey }: Props) {
   const accent = countryAccent(data?.meeting ?? null)
   const accentStyle = { '--gp-accent': accent } as React.CSSProperties
 
-  // ─── No session_key: show resolving state, fall back to switcher if no local data ───
+  const openDiagnostics = () => {
+    setActiveTab('data_status')
+    setShowDiagnostics(true)
+    setPhaseDiagnostics(true)
+  }
+
+  // ─── No session_key: resolve via Weekend Context ───
   if (sessionKey === 0) {
-    if (seasonsQuery.isLoading || meetingsQuery.isLoading || fallbackWeekendQuery.isLoading) {
+    if (contextQuery.isLoading) {
       return (
         <div className="rh-page" style={accentStyle}>
-          <div className="loading-state">resolving latest local weekend…</div>
+          <RouteState
+            kind="loading"
+            title="resolving weekend context…"
+            testId="race-hub-loading"
+          />
         </div>
       )
     }
-    const seasons = seasonsQuery.data ?? []
-    if (seasons.length === 0) {
+    if (contextQuery.isError) {
       return (
-        <div className="rh-page rh-empty" data-testid="race-hub-empty" style={accentStyle}>
+        <div className="rh-page" data-testid="race-hub-error" style={accentStyle}>
+          <RouteState
+            kind="error"
+            title="Weekend unavailable"
+            error={contextQuery.error}
+            onRetry={() => {
+              if (!contextQuery.isFetching) void contextQuery.refetch()
+            }}
+            retrying={contextQuery.isFetching}
+            retryTestId="rh-retry"
+          >
+            <div className="rh-recover-actions">
+              <Link to="/" search={{}} className="rh-recover-btn" data-testid="rh-back-weekend">
+                Back to Weekend
+              </Link>
+            </div>
+          </RouteState>
+        </div>
+      )
+    }
+
+    if (context && !defaultAnalysisSessionKey(context)) {
+      return (
+        <div className="rh-page rh-empty" data-testid="race-hub-no-analysis" style={accentStyle}>
           <div className="rh-empty-band">
             <span className="rh-empty-eyebrow mono">box-box · race hub</span>
-            <h1 className="rh-empty-title">No local sessions yet</h1>
+            <h1 className="rh-empty-title">No completed session to analyse yet</h1>
             <p className="rh-empty-sub">
-              The Race Hub reads from local ingest only. Once a weekend is ingested
-              it will open here automatically.
+              Weekend Context has no default analysis session. Pick a past session
+              to review, or check back once a session completes with local analysis.
             </p>
             <div className="rh-empty-actions">
-              <a href="/admin" className="rh-empty-action">Open Admin · Data Health</a>
-              <a href="/" className="rh-empty-action">Back to Command Center</a>
+              <button
+                type="button"
+                className="rh-empty-action"
+                onClick={() => setSwitcherOpen(true)}
+              >
+                Browse Weekends
+              </button>
+              <Link to="/" search={{}} className="rh-empty-action" data-testid="rh-back-weekend">
+                Back to Weekend
+              </Link>
             </div>
           </div>
+          {switcherOpen && (
+            <WeekendSwitcher
+              currentMeetingKey={context.focus_meeting?.meeting_key}
+              context={context}
+              now={now}
+              onClose={() => setSwitcherOpen(false)}
+            />
+          )}
         </div>
       )
     }
+
     return (
       <div className="rh-page" style={accentStyle}>
-        <div className="loading-state">resolving latest local weekend…</div>
+        <RouteState
+          kind="loading"
+          title="resolving weekend context…"
+          testId="race-hub-loading"
+        />
       </div>
     )
   }
@@ -147,18 +185,50 @@ export function RaceHubPage({ sessionKey }: Props) {
   if (raceHubQuery.isLoading) {
     return (
       <div className="rh-page" style={accentStyle}>
-        <div className="loading-state">loading session {sessionKey}…</div>
+        <RouteState
+          kind="loading"
+          title={`loading session ${sessionKey}…`}
+          testId="race-hub-loading"
+        />
       </div>
     )
   }
   if (raceHubQuery.isError || !data) {
+    const backMeeting =
+      context?.focus_meeting?.meeting_key ??
+      context?.previous_completed_session?.meeting?.meeting_key
+    const backSearch = weekendFocusSearch(backMeeting, sessionKey)
+
     return (
-      <div className="rh-page" style={accentStyle}>
-        <div className="error-box">
-          {raceHubQuery.error instanceof Error
-            ? raceHubQuery.error.message
-            : `Failed to load session ${sessionKey}.`}
+      <div className="rh-page" data-testid="race-hub-error" style={accentStyle}>
+        <RouteState
+          kind="error"
+          title="Session unavailable"
+          error={raceHubQuery.error}
+          message={
+            raceHubQuery.error
+              ? undefined
+              : `Session ${sessionKey} could not be loaded from local data.`
+          }
+          onRetry={() => {
+            if (!raceHubQuery.isFetching) void raceHubQuery.refetch()
+          }}
+          retrying={raceHubQuery.isFetching}
+          retryTestId="rh-retry"
+        >
+          <div className="rh-recover-actions">
+            <Link
+              to="/"
+              search={backSearch}
+              className="rh-recover-btn"
+              data-testid="rh-back-weekend"
+              data-meeting-key={backMeeting ?? undefined}
+              data-session-key={sessionKey}
+            >
+              Back to Weekend
+            </Link>
           </div>
+        </RouteState>
       </div>
     )
   }
@@ -168,12 +238,35 @@ export function RaceHubPage({ sessionKey }: Props) {
   const sessionMeta = weekend
     ? Object.fromEntries(weekend.sessions.map((w) => [w.session.session_key, w]))
     : {}
-  const activeSessionMeta = sessionMeta[sessionKey]
+  const activeSessionMeta: WeekendSession | undefined = sessionMeta[sessionKey]
+  const activeState = resolveSessionState({
+    weekendSession: activeSessionMeta,
+    context,
+    now,
+  })
+  const preSession = isPreSession(activeState)
+  const preparing = isPreparing(activeState)
+  const unavailable = isUnavailable(activeState)
+  const partial = isPartialAnalysis(activeState)
+  // Distinct stale disclosure from response headers — skip routine local (already
+  // covered by SourceBadge) and skip partial when the readiness banner is shown.
+  const freshnessNotice = noticeFromResponse(data, { includeLocal: false })
+  const showFreshnessNotice =
+    freshnessNotice != null && !(partial && freshnessNotice === 'partial')
 
   return (
     <div className="rh-page" data-testid="race-hub" style={accentStyle}>
-      {/* Topbar */}
       <div className="rh-topbar">
+        <Link
+          to="/"
+          search={weekendFocusSearch(meetingKey, sessionKey)}
+          className="rh-back-weekend"
+          data-testid="rh-back-weekend"
+          data-meeting-key={meetingKey ?? undefined}
+          data-session-key={sessionKey}
+        >
+          Back to Weekend
+        </Link>
         <span className="rh-topbar-label mono">
           box-box · race hub
           {data.meeting?.year ? ` · ${data.meeting.year}` : ''}
@@ -191,15 +284,28 @@ export function RaceHubPage({ sessionKey }: Props) {
         </button>
       </div>
 
+      {showFreshnessNotice && freshnessNotice && (
+        <DataNotice
+          availability={freshnessNotice}
+          message={noticeMessage(freshnessNotice)}
+          onRetry={() => {
+            if (!raceHubQuery.isFetching) void raceHubQuery.refetch()
+          }}
+          retrying={raceHubQuery.isFetching}
+          testId="race-hub-data-notice"
+        />
+      )}
+
       {switcherOpen && (
         <WeekendSwitcher
           currentMeetingKey={meetingKey}
           currentSessionKey={sessionKey}
+          context={context}
+          now={now}
           onClose={() => setSwitcherOpen(false)}
         />
       )}
 
-      {/* GP Identity band */}
       {data.meeting && (
         <section className="rh-identity" data-testid="rh-identity">
           <div className="rh-identity-accent" aria-hidden="true" />
@@ -220,12 +326,16 @@ export function RaceHubPage({ sessionKey }: Props) {
         </section>
       )}
 
-      {/* Session rail */}
       {sessions.length > 0 && (
         <nav className="rh-session-rail" aria-label="Weekend sessions" data-testid="rh-session-rail">
           {sessions.map((session) => {
             const meta = sessionMeta[session.session_key]
             const active = session.session_key === sessionKey
+            const state = resolveSessionState({
+              weekendSession: meta,
+              context,
+              now,
+            })
             return (
               <button
                 key={session.session_key}
@@ -247,43 +357,70 @@ export function RaceHubPage({ sessionKey }: Props) {
                 <span className="rh-session-time mono">
                   {formatSessionScheduleTime(session.date_start)}
                 </span>
-                {meta && (
                 <span className="rh-session-cov mono">
                   <span
-                      className={`cc-cov-dot cc-cov-${meta.source}`}
+                    className={`cc-cov-dot ${sessionStateDotClass(state)}`}
                     aria-hidden="true"
                   />
-                    {formatCoverageHint(meta.datasets)}
+                  {sessionStateLabel(state)}
                 </span>
-                )}
               </button>
             )
           })}
         </nav>
       )}
 
-      {/* Active session sub-bar */}
       {data.session && (
         <div className="rh-active-bar" data-testid="rh-active-bar">
           <span className="rh-active-name">{data.session.session_name}</span>
           <span className="rh-active-meta mono">
             {formatSessionScheduleTime(data.session.date_start)}
           </span>
-          {activeSessionMeta && (
-            <span className="rh-active-cov mono">
+          <span className="rh-active-cov mono" data-testid="rh-active-state">
             <span
-                className={`cc-cov-dot cc-cov-${activeSessionMeta.source}`}
+              className={`cc-cov-dot ${sessionStateDotClass(activeState)}`}
               aria-hidden="true"
             />
-              {formatCoverageHint(activeSessionMeta.datasets)} datasets local
+            {sessionStateLabel(activeState)}
           </span>
-          )}
           <span className="rh-active-key mono">key {sessionKey}</span>
         </div>
       )}
 
+      {preSession && data.session ? (
+        <PreSessionView
+          session={data.session}
+          sessionName={data.session.session_name}
+          now={now}
+        />
+      ) : preparing || unavailable ? (
+        <>
+          <SessionPhaseView
+            state={
+              unavailable
+                ? activeState === 'cancelled'
+                  ? 'cancelled'
+                  : 'unavailable'
+                : 'preparing'
+            }
+            sessionName={data.session?.session_name ?? `Session ${sessionKey}`}
+            onOpenDiagnostics={openDiagnostics}
+          />
+          {phaseDiagnostics && (
+            <div className="data-section" data-testid="rh-phase-diagnostics">
+              <div className="sec-header">
+                <span className="sec-title">Diagnostics</span>
+              </div>
+              <DatasetStatusView datasets={data.datasets} />
+              <div style={{ marginTop: 'var(--s5)' }} data-testid="rh-dataset-strip">
                 <DatasetStrip datasets={data.datasets} />
-
+              </div>
+            </div>
+          )}
+        </>
+      ) : (
+        <>
+          {partial && <PartialAnalysisBanner onOpenDiagnostics={openDiagnostics} />}
           <TabBar active={activeTab} onChange={setActiveTab} />
 
           {activeTab === 'overview' && <OverviewView data={data} />}
@@ -360,11 +497,27 @@ export function RaceHubPage({ sessionKey }: Props) {
           {activeTab === 'data_status' && (
             <div className="data-section">
               <div className="sec-header">
-            <span className="sec-title">Data Status</span>
+                <span className="sec-title">Diagnostics</span>
+                <button
+                  type="button"
+                  className={`rh-diagnostics-toggle${showDiagnostics ? ' active' : ''}`}
+                  onClick={() => setShowDiagnostics((v) => !v)}
+                  aria-expanded={showDiagnostics}
+                  data-testid="rh-diagnostics-toggle"
+                >
+                  {showDiagnostics ? 'Hide dataset coverage' : 'Show dataset coverage'}
+                </button>
               </div>
               <DatasetStatusView datasets={data.datasets} />
+              {showDiagnostics && (
+                <div style={{ marginTop: 'var(--s5)' }} data-testid="rh-dataset-strip">
+                  <DatasetStrip datasets={data.datasets} />
                 </div>
               )}
             </div>
+          )}
+        </>
+      )}
+    </div>
   )
 }

frontend/src/pages/RacePreviewPage.tsx

@@ -9,6 +9,15 @@ import {
   fetchStartingGrid,
   fetchTrackOutline,
 } from '../api'
+import { DataNotice, RouteState } from '../components/RouteState'
+import {
+  aggregateNotices,
+  noticeFromResponse,
+  noticeMessage,
+  shouldShowEmbeddedNotice,
+  type DataAvailability,
+} from '../lib/availability'
+import { userFacingError } from '../lib/fetch'
 import { countryAccent, countryFlag, formatGpDateRange } from '../lib/gpIdentity'
 import {
   buildTitleFightContext,
@@ -37,7 +46,7 @@ function SectionState({
   children,
 }: {
   loading?: boolean
-  error?: Error | null
+  error?: unknown
   empty?: boolean
   emptyMessage?: string
   children: ReactNode
@@ -47,8 +56,8 @@ function SectionState({
   }
   if (error) {
     return (
-      <div className="preview-section-state error">
-        {error instanceof Error ? error.message : 'Failed to load'}
+      <div className="preview-section-state error" role="status">
+        {userFacingError(error)}
       </div>
     )
   }
@@ -66,7 +75,7 @@ function TrackOutlineCard({
 }: {
   outline: TrackOutline | null | undefined
   loading: boolean
-  error: Error | null
+  error: unknown
   accent: string
 }) {
   const outlinePath = useMemo(() => buildOutlinePath(outline?.points ?? []), [outline])
@@ -101,7 +110,7 @@ function LastYearCard({
 }: {
   year: number | null
   loading: boolean
-  error: Error | null
+  error: unknown
   podium: ReturnType<typeof extractPodium>
   pole: ReturnType<typeof extractPole>
   isFirstTime: boolean
@@ -150,7 +159,7 @@ function TitleFightCard({
   season,
 }: {
   loading: boolean
-  error: Error | null
+  error: unknown
   drivers: ReturnType<typeof buildTitleFightContext>
   sprintWeekend: boolean
   season: number | null
@@ -259,7 +268,29 @@ function PreviewHeader({
   )
 }
 
-export function RacePreviewPage() {
+export interface RacePreviewPageProps {
+  /**
+   * Canonical meeting identity from Weekend Context. When set, Preview must not
+   * independently re-select another current meeting/session.
+   */
+  meeting?: Meeting
+  /** Season for championship supplement; defaults to meeting.year. */
+  season?: number
+  /** Embedded under Weekend — identity failures stay non-blocking. */
+  embedded?: boolean
+  /**
+   * Availability already disclosed by the Weekend shell. Embedded Preview
+   * suppresses only an equivalent notice kind; distinct truth stays visible.
+   */
+  shellAvailability?: DataAvailability | null
+}
+
+export function RacePreviewPage({
+  meeting: canonicalMeeting,
+  season: canonicalSeason,
+  embedded = false,
+  shellAvailability = null,
+}: RacePreviewPageProps = {}) {
   const [now, setNow] = useState(() => Date.now())
 
   useEffect(() => {
@@ -268,28 +299,34 @@ export function RacePreviewPage() {
   }, [])
 
   const nowDate = useMemo(() => new Date(now), [now])
+  const hasCanonicalMeeting = canonicalMeeting != null && canonicalMeeting.meeting_key > 0
 
   const seasonsQuery = useQuery({
     queryKey: ['seasons'],
-    queryFn: fetchSeasons,
+    queryFn: ({ signal }) => fetchSeasons(signal),
+    enabled: !hasCanonicalMeeting,
   })
 
-  const latestSeason = seasonsQuery.data?.[0] ?? null
+  const latestSeason =
+    canonicalSeason ??
+    canonicalMeeting?.year ??
+    seasonsQuery.data?.[0] ??
+    null
 
   const meetingsQuery = useQuery({
     queryKey: ['meetings', latestSeason, 'auto'],
-    queryFn: () => fetchMeetings(latestSeason!, 'auto'),
-    enabled: latestSeason != null,
+    queryFn: ({ signal }) => fetchMeetings(latestSeason!, 'auto', signal),
+    enabled: !hasCanonicalMeeting && latestSeason != null,
   })
 
-  const previewMeeting = useMemo(
-    () => pickPreviewMeeting(meetingsQuery.data ?? [], nowDate),
-    [meetingsQuery.data, nowDate],
-  )
+  const previewMeeting = useMemo(() => {
+    if (hasCanonicalMeeting) return canonicalMeeting
+    return pickPreviewMeeting(meetingsQuery.data ?? [], nowDate)
+  }, [hasCanonicalMeeting, canonicalMeeting, meetingsQuery.data, nowDate])
 
   const sessionsQuery = useQuery({
     queryKey: ['sessions', previewMeeting?.meeting_key, 'auto'],
-    queryFn: () => fetchSessions(previewMeeting!.meeting_key, 'auto'),
+    queryFn: ({ signal }) => fetchSessions(previewMeeting!.meeting_key, 'auto', signal),
     enabled: previewMeeting != null,
   })
 
@@ -305,7 +342,7 @@ export function RacePreviewPage() {
 
   const priorMeetingsQuery = useQuery({
     queryKey: ['meetings', priorYear, 'auto'],
-    queryFn: () => fetchMeetings(priorYear!, 'auto'),
+    queryFn: ({ signal }) => fetchMeetings(priorYear!, 'auto', signal),
     enabled: priorYear != null && previewMeeting != null,
   })
 
@@ -316,7 +353,7 @@ export function RacePreviewPage() {
 
   const priorSessionsQuery = useQuery({
     queryKey: ['sessions', priorMeeting?.meeting_key, 'auto'],
-    queryFn: () => fetchSessions(priorMeeting!.meeting_key, 'auto'),
+    queryFn: ({ signal }) => fetchSessions(priorMeeting!.meeting_key, 'auto', signal),
     enabled: priorMeeting != null,
   })
 
@@ -327,25 +364,25 @@ export function RacePreviewPage() {
 
   const priorResultsQuery = useQuery({
     queryKey: ['results', priorRaceSession?.session_key, 'auto'],
-    queryFn: () => fetchResults(priorRaceSession!.session_key, 'auto'),
+    queryFn: ({ signal }) => fetchResults(priorRaceSession!.session_key, 'auto', signal),
     enabled: priorRaceSession != null,
   })
 
   const priorGridQuery = useQuery({
     queryKey: ['grid', priorRaceSession?.session_key, 'auto'],
-    queryFn: () => fetchStartingGrid(priorRaceSession!.session_key, 'auto'),
+    queryFn: ({ signal }) => fetchStartingGrid(priorRaceSession!.session_key, 'auto', signal),
     enabled: priorRaceSession != null,
   })
 
   const trackOutlineQuery = useQuery({
     queryKey: ['track-outline', previewMeeting?.circuit_key, previewMeeting?.year],
-    queryFn: () => fetchTrackOutline(previewMeeting!.circuit_key!, previewMeeting!.year),
+    queryFn: ({ signal }) => fetchTrackOutline(previewMeeting!.circuit_key!, previewMeeting!.year, signal),
     enabled: previewMeeting?.circuit_key != null && previewMeeting.circuit_key > 0,
   })
 
   const championshipQuery = useQuery({
     queryKey: ['championship-hub', latestSeason],
-    queryFn: () => fetchChampionshipHub(latestSeason!),
+    queryFn: ({ signal }) => fetchChampionshipHub(latestSeason!, signal),
     enabled: latestSeason != null,
   })
 
@@ -359,15 +396,56 @@ export function RacePreviewPage() {
   const accent = countryAccent(previewMeeting)
   const isFirstTimeCircuit = priorMeeting == null && priorYear != null && !priorMeetingsQuery.isLoading
 
-  if (seasonsQuery.isLoading || meetingsQuery.isLoading) {
-    return <div className="page loading-state" data-testid="preview-loading">loading preview…</div>
+  const identityLoading = !hasCanonicalMeeting && (seasonsQuery.isLoading || meetingsQuery.isLoading)
+  const identityError = !hasCanonicalMeeting && (seasonsQuery.isError || meetingsQuery.isError)
+  const identityRetrying = seasonsQuery.isFetching || meetingsQuery.isFetching
+
+  const retryIdentity = () => {
+    if (seasonsQuery.isError && !seasonsQuery.isFetching) void seasonsQuery.refetch()
+    if (meetingsQuery.isError && !meetingsQuery.isFetching) void meetingsQuery.refetch()
   }
 
-  if (seasonsQuery.isError || meetingsQuery.isError) {
+  // Worst reported truth across primary + supplements — Local must not mask
+  // Sessions/Prior Results Stale/Partial/Limited/Archive.
+  const dataNotice = aggregateNotices([
+    noticeFromResponse(championshipQuery.data, { includeLocal: true }),
+    noticeFromResponse(sessionsQuery.data, { includeLocal: false }),
+    noticeFromResponse(priorResultsQuery.data, { includeLocal: false }),
+  ])
+
+  const showFreshnessNotice =
+    Boolean(dataNotice) &&
+    (!embedded || shouldShowEmbeddedNotice(dataNotice, shellAvailability))
+
+  const sessionsFailed = sessionsQuery.isError
+  const sessionsRetrying = sessionsQuery.isFetching
+
+  const retrySessions = () => {
+    if (!sessionsQuery.isFetching) void sessionsQuery.refetch()
+  }
+
+  if (identityLoading) {
+    return (
+      <div className={embedded ? 'preview-embedded' : 'page'} data-testid="preview-loading">
+        <RouteState kind="loading" title="loading preview…" />
+      </div>
+    )
+  }
+
+  if (identityError) {
     const err = seasonsQuery.error ?? meetingsQuery.error
     return (
-      <div className="page error-box" data-testid="preview-error">
-        {err instanceof Error ? err.message : 'Failed to load preview'}
+      <div className={embedded ? 'preview-embedded' : 'page'} data-testid="preview-error">
+        <RouteState
+          kind="error"
+          title="Preview details unavailable"
+          error={err}
+          onRetry={() => {
+            if (!identityRetrying) retryIdentity()
+          }}
+          retrying={identityRetrying}
+          retryTestId="preview-retry"
+        />
       </div>
     )
   }
@@ -386,7 +464,7 @@ export function RacePreviewPage() {
         {titleFight.length > 0 && (
           <TitleFightCard
             loading={championshipQuery.isLoading}
-            error={championshipQuery.isError ? (championshipQuery.error as Error) : null}
+            error={championshipQuery.isError ? championshipQuery.error : null}
             drivers={titleFight}
             sprintWeekend={false}
             season={latestSeason}
@@ -397,7 +475,34 @@ export function RacePreviewPage() {
   }
 
   return (
-    <div className="preview-page" data-testid="preview-page">
+    <div
+      className="preview-page"
+      data-testid="preview-page"
+      data-meeting-key={previewMeeting.meeting_key}
+      data-embedded={embedded ? 'true' : undefined}
+    >
+      {showFreshnessNotice && dataNotice && (
+        <DataNotice
+          availability={dataNotice}
+          message={noticeMessage(dataNotice)}
+          testId="preview-data-notice"
+        />
+      )}
+
+      {sessionsFailed && (
+        <RouteState
+          kind="error"
+          title="Session schedule unavailable"
+          error={sessionsQuery.error}
+          onRetry={retrySessions}
+          retrying={sessionsRetrying}
+          testId="preview-sessions-error"
+          retryTestId="preview-sessions-retry"
+        />
+      )}
+
+      {/* Embedded Weekend already shows the canonical countdown header — skip the duplicate. */}
+      {!embedded && (
         <PreviewHeader
           meeting={previewMeeting}
           sessions={sessions}
@@ -405,12 +510,27 @@ export function RacePreviewPage() {
           now={nowDate}
           accent={accent}
         />
+      )}
+
+      {/* Embedded: still surface recovered schedule once sessions load. */}
+      {embedded && sessions.length > 0 && (
+        <div className="preview-schedule" data-testid="preview-schedule">
+          {sessions.map((session) => (
+            <div key={session.session_key} className="preview-schedule-item">
+              <span className="preview-schedule-name">{session.session_name}</span>
+              <span className="preview-schedule-time">
+                {formatSessionScheduleTime(session.date_start)}
+              </span>
+            </div>
+          ))}
+        </div>
+      )}
 
       <div className="preview-grid">
         <TrackOutlineCard
           outline={trackOutlineQuery.data}
           loading={trackOutlineQuery.isLoading}
-          error={trackOutlineQuery.isError ? (trackOutlineQuery.error as Error) : null}
+          error={trackOutlineQuery.isError ? trackOutlineQuery.error : null}
           accent={accent}
         />
 
@@ -419,9 +539,9 @@ export function RacePreviewPage() {
           loading={priorMeetingsQuery.isLoading || priorSessionsQuery.isLoading || priorResultsQuery.isLoading}
           error={
             priorMeetingsQuery.isError
-              ? (priorMeetingsQuery.error as Error)
+              ? priorMeetingsQuery.error
               : priorResultsQuery.isError
-                ? (priorResultsQuery.error as Error)
+                ? priorResultsQuery.error
                 : null
           }
           podium={podium}
@@ -432,7 +552,7 @@ export function RacePreviewPage() {
 
       <TitleFightCard
         loading={championshipQuery.isLoading}
-        error={championshipQuery.isError ? (championshipQuery.error as Error) : null}
+        error={championshipQuery.isError ? championshipQuery.error : null}
         drivers={titleFight}
         sprintWeekend={sprintWeekend}
         season={latestSeason}

frontend/src/pages/WeekendPage.tsx

@@ -0,0 +1,180 @@
+import { useWeekendContext } from '../hooks/useWeekendContext'
+import { BetweenRacesView } from '../components/weekend/BetweenRacesView'
+import { BetweenSessionsView } from '../components/weekend/BetweenSessionsView'
+import { LiveHandoffView } from '../components/weekend/LiveHandoffView'
+import { PreSessionView } from '../components/weekend/PreSessionView'
+import { WeekendError, WeekendLimited, WeekendLoading } from '../components/weekend/StatusViews'
+import { WeekendFocusBanner } from '../components/weekend/WeekendFocusBanner'
+import { DataNotice } from '../components/RouteState'
+import { noticeMessage, type DataAvailability } from '../lib/availability'
+import { resolveViewState } from '../lib/weekendContext'
+import type {
+  WeekendBriefingItem,
+  WeekendChampionshipImpact,
+  WeekendContext,
+  WeekendViewState,
+} from '../types'
+import '../styles/weekend.css'
+
+interface RenderArgs {
+  context: WeekendContext
+  now: Date
+  championship?: WeekendChampionshipImpact
+  briefing: WeekendBriefingItem[]
+  /** When true (the /preview alias), foreground the preparation surface. */
+  preview: boolean
+  /** Availability already disclosed by the Weekend shell (for Preview dedupe). */
+  shellAvailability: DataAvailability | null
+}
+
+function renderState(view: WeekendViewState, args: RenderArgs) {
+  const { context, now, championship, briefing, preview, shellAvailability } = args
+  // The /preview alias always resolves to the preparation surface as long as
+  // there is a next event to prepare for, regardless of the temporal state. This
+  // keeps saved /preview links and the "Prepare for …" CTA meaningful instead of
+  // redirecting straight back to the same between-races screen.
+  if (preview && context.next_meeting) {
+    return <PreSessionView context={context} now={now} shellAvailability={shellAvailability} />
+  }
+
+  switch (view) {
+    case 'no_season':
+      return <WeekendLimited season={context.season} />
+    case 'between_weekends':
+    case 'post_weekend':
+    case 'season_complete':
+      return (
+        <BetweenRacesView
+          context={context}
+          now={now}
+          view={view}
+          championship={championship}
+          briefing={briefing}
+        />
+      )
+    case 'between_sessions':
+    case 'session_settling':
+      return <BetweenSessionsView context={context} now={now} view={view} briefing={briefing} />
+    case 'session_live':
+      return <LiveHandoffView context={context} />
+    case 'pre_session':
+      return <PreSessionView context={context} now={now} shellAvailability={shellAvailability} />
+    default:
+      return <WeekendLimited season={context.season} />
+  }
+}
+
+function WeekendAvailabilityNotices({
+  availabilityNotice,
+  supplementsLimited,
+  onRetry,
+  retrying,
+}: {
+  availabilityNotice: DataAvailability | null
+  supplementsLimited: boolean
+  onRetry: () => void
+  retrying: boolean
+}) {
+  // Prefer a single reported freshness notice; Limited for failed supplements
+  // only when freshness itself is not already disclosing a stronger state.
+  if (availabilityNotice) {
+    return (
+      <DataNotice
+        availability={availabilityNotice}
+        message={noticeMessage(availabilityNotice)}
+        onRetry={onRetry}
+        retrying={retrying}
+        testId="weekend-data-notice"
+      />
+    )
+  }
+  if (supplementsLimited) {
+    return (
+      <DataNotice
+        availability="limited"
+        message="Championship or briefing supplements are unavailable. Weekend schedule context is still shown."
+        onRetry={onRetry}
+        retrying={retrying}
+        testId="weekend-data-notice"
+      />
+    )
+  }
+  return null
+}
+
+export function WeekendPage({
+  preview = false,
+  focusMeetingKey,
+  focusSessionKey,
+}: {
+  preview?: boolean
+  /** Restored from `/?meeting_key=` when returning from Race Hub analysis. */
+  focusMeetingKey?: number
+  /** Restored from `/?session_key=` when returning from Race Hub analysis. */
+  focusSessionKey?: number
+}) {
+  const {
+    context,
+    loadState,
+    error,
+    championship,
+    briefing,
+    availabilityNotice,
+    supplementsLimited,
+    now,
+    refetch,
+    isFetching,
+  } = useWeekendContext()
+  const hasFocus =
+    (focusMeetingKey != null && focusMeetingKey > 0) ||
+    (focusSessionKey != null && focusSessionKey > 0)
+
+  if (loadState === 'loading') {
+    return (
+      <main className="wk-page" data-testid="weekend-page" data-state="loading">
+        <WeekendLoading />
+      </main>
+    )
+  }
+
+  if (loadState === 'error' || context == null) {
+    return (
+      <main className="wk-page" data-testid="weekend-page" data-state="error">
+        <WeekendError error={error} onRetry={refetch} retrying={isFetching} />
+      </main>
+    )
+  }
+
+  const view = resolveViewState(context)
+  const shellAvailability = availabilityNotice ?? (supplementsLimited ? 'limited' : null)
+
+  return (
+    <main
+      className="wk-page"
+      data-testid="weekend-page"
+      data-state={view}
+      data-temporal-state={context.temporal_state}
+      data-preview={preview ? 'true' : undefined}
+      data-meeting-key={focusMeetingKey ?? undefined}
+      data-session-key={focusSessionKey ?? undefined}
+    >
+      {hasFocus && (
+        <WeekendFocusBanner meetingKey={focusMeetingKey} sessionKey={focusSessionKey} />
+      )}
+      <WeekendAvailabilityNotices
+        availabilityNotice={availabilityNotice}
+        supplementsLimited={supplementsLimited}
+        onRetry={refetch}
+        retrying={isFetching}
+      />
+      {renderState(view, {
+        context,
+        now,
+        championship,
+        briefing,
+        preview,
+        shellAvailability,
+      })}
+    </main>
+  )
+}

frontend/src/router.tsx

@@ -1,17 +1,14 @@
 import { createRootRoute, createRoute, createRouter, Outlet } from '@tanstack/react-router'
 import { Nav } from './components/Nav'
-import { CommandCenterPage } from './pages/CommandCenterPage'
+import { WeekendPage } from './pages/WeekendPage'
+import { ExplorePage } from './pages/ExplorePage'
 import { RaceHubPage } from './pages/RaceHubPage'
 import { DataLibraryPage } from './pages/DataLibraryPage'
 import { LiveTimingPage } from './pages/LiveTimingPage'
 import { BriefingPage } from './pages/BriefingPage'
 import { ChampionshipPage } from './pages/ChampionshipPage'
 import { DriverProfilePage } from './pages/DriverProfilePage'
-import { RacePreviewPage } from './pages/RacePreviewPage'
-
-type RaceHubSearch = {
-  session_key?: number
-}
+import { parseRaceHubSearch, parseWeekendSearch } from './lib/routeSearch'
 
 type DriverProfileSearch = {
   year?: number
@@ -26,19 +23,31 @@ const rootRoute = createRootRoute({
   ),
 })
 
-export const commandCenterRoute = createRoute({
+// Weekend is the adaptive home. `/` renders the current temporal state.
+// Optional meeting_key/session_key search restores Race Hub return context
+// (deep-linkable, reload-safe — no hidden component memory).
+export const weekendRoute = createRoute({
   getParentRoute: () => rootRoute,
   path: '/',
-  component: CommandCenterPage,
+  validateSearch: (search: Record<string, unknown>) => parseWeekendSearch(search),
+  component: function WeekendRoute() {
+    const { meeting_key, session_key } = weekendRoute.useSearch()
+    return (
+      <WeekendPage focusMeetingKey={meeting_key} focusSessionKey={session_key} />
+    )
+  },
+})
+
+export const exploreRoute = createRoute({
+  getParentRoute: () => rootRoute,
+  path: '/explore',
+  component: ExplorePage,
 })
 
 export const raceHubRoute = createRoute({
   getParentRoute: () => rootRoute,
   path: '/race-hub',
-  validateSearch: (search: Record<string, unknown>): RaceHubSearch => {
-    const sessionKey = Number(search.session_key)
-    return Number.isFinite(sessionKey) && sessionKey > 0 ? { session_key: sessionKey } : {}
-  },
+  validateSearch: (search: Record<string, unknown>) => parseRaceHubSearch(search),
   component: function RaceHubRoute() {
     const { session_key } = raceHubRoute.useSearch()
     return <RaceHubPage sessionKey={session_key ?? 0} />
@@ -90,14 +99,21 @@ export const briefingRoute = createRoute({
   component: BriefingPage,
 })
 
+// Preview folds into the Weekend home. /preview is a stable alias that renders the
+// Weekend page in its preparation surface (PreSessionView) whenever there is a next
+// event — so saved preview links and the "Prepare for …" CTA reach real preview
+// content instead of redirecting back to the same between-races screen.
 export const previewRoute = createRoute({
   getParentRoute: () => rootRoute,
   path: '/preview',
-  component: RacePreviewPage,
+  component: function PreviewRoute() {
+    return <WeekendPage preview />
+  },
 })
 
 const routeTree = rootRoute.addChildren([
-  commandCenterRoute,
+  weekendRoute,
+  exploreRoute,
   raceHubRoute,
   adminRoute,
   dataLibraryRoute,

frontend/src/styles/app.css

@@ -142,6 +142,53 @@ a { color: inherit; text-decoration: none; }
   background: var(--surface-2);
 }
 
+/* ── Mobile bottom nav ── */
+.app-bottom-nav {
+  display: none;
+  position: fixed;
+  bottom: 0;
+  left: 0;
+  right: 0;
+  z-index: 100;
+  height: 60px;
+  padding-bottom: env(safe-area-inset-bottom, 0);
+  background: rgba(18, 18, 18, 0.92);
+  backdrop-filter: blur(16px);
+  -webkit-backdrop-filter: blur(16px);
+  border-top: 1px solid rgba(255, 255, 255, 0.08);
+}
+.bottom-nav-link {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 3px;
+  font-size: 10px;
+  font-weight: 600;
+  color: var(--text-3);
+}
+.bottom-nav-link.active { color: var(--red); }
+.bottom-nav-link:hover { color: var(--text-2); }
+
+@media (max-width: 640px) {
+  /* On mobile the bottom bar is the single primary navigation system. The top
+     bar's Primary links are hidden so the two are never both shown; the top bar
+     keeps only the logo and the Admin operator utility. */
+  .app-bottom-nav { display: flex; }
+  .app-nav .nav-links { display: none; }
+  .app-nav { justify-content: space-between; }
+  /* Keep page content clear of the fixed bottom bar. */
+  .wk-page { padding-bottom: calc(60px + env(safe-area-inset-bottom, 0) + var(--s4)); }
+}
+
+/* ── Focus visibility (accessibility) ── */
+:focus-visible {
+  outline: 2px solid var(--red);
+  outline-offset: 2px;
+  border-radius: 3px;
+}
+
 /* ── Page ── */
 .page {
   max-width: 1040px;
@@ -363,6 +410,9 @@ a { color: inherit; text-decoration: none; }
 .badge-partial { background: rgba(255,214,0,.12); color: var(--yellow); border: 1px solid rgba(255,214,0,.25); }
 .badge-cancelled { background: rgba(255,107,53,.12); color: #ff8a5c; border: 1px solid rgba(255,107,53,.28); }
 .badge-none    { background: rgba(80,80,80,.12); color: var(--text-3); border: 1px solid var(--border); }
+.badge-stale   { background: rgba(255,214,0,.10); color: var(--yellow); border: 1px solid rgba(255,214,0,.22); }
+.badge-limited { background: rgba(120,160,220,.12); color: #9bb7e0; border: 1px solid rgba(120,160,220,.28); }
+.badge-missing { background: rgba(80,80,80,.12); color: var(--text-3); border: 1px solid var(--border); }
 
 /* ── Dataset strip ── */
 .dataset-strip {
@@ -538,6 +588,82 @@ a { color: inherit; text-decoration: none; }
   margin-bottom: var(--s5);
 }
 
+.route-state {
+  padding: var(--s7) var(--s5);
+  text-align: center;
+  max-width: 420px;
+  margin: 0 auto;
+}
+
+.route-state-availability {
+  margin-bottom: var(--s4);
+}
+
+.route-state-title {
+  font-family: var(--f-display, var(--f-mono));
+  font-size: 18px;
+  font-weight: 600;
+  color: var(--text);
+  margin-bottom: var(--s3);
+}
+
+.route-state-message {
+  font-size: 13px;
+  line-height: 1.5;
+  color: var(--text-2);
+  margin-bottom: var(--s5);
+}
+
+.route-state-retry {
+  appearance: none;
+  border: 1px solid rgba(255, 255, 255, 0.18);
+  background: rgba(255, 255, 255, 0.04);
+  color: var(--text);
+  font-family: var(--f-mono);
+  font-size: 12px;
+  padding: 8px 16px;
+  border-radius: 2px;
+  cursor: pointer;
+}
+
+.route-state-retry:hover:not(:disabled) {
+  border-color: rgba(225, 6, 0, 0.45);
+  color: #fff;
+}
+
+.route-state-retry:focus-visible {
+  outline: 2px solid var(--red);
+  outline-offset: 2px;
+}
+
+.route-state-retry:disabled {
+  opacity: 0.55;
+  cursor: not-allowed;
+}
+
+.data-notice {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: var(--s3);
+  padding: var(--s3) var(--s4);
+  margin-bottom: var(--s4);
+  background: rgba(255, 214, 0, 0.06);
+  border: 1px solid rgba(255, 214, 0, 0.2);
+  border-radius: 2px;
+  font-size: 12px;
+  color: var(--text-2);
+}
+
+.data-notice-text {
+  flex: 1;
+  min-width: 160px;
+}
+
+.data-notice-retry {
+  padding: 4px 10px;
+}
+
 /* ── Live timing ── */
 .live-page { max-width: 1320px; }
 
@@ -1773,6 +1899,163 @@ a { color: inherit; text-decoration: none; }
 .tab-btn:hover { color: var(--text-2); }
 .tab-btn.active { color: var(--text); border-bottom-color: var(--red); }
 
+/* ── Grouped analysis navigation ── */
+.tab-bar-grouped {
+  gap: var(--s5);
+  align-items: flex-end;
+}
+.tab-group {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  flex-shrink: 0;
+}
+.tab-group + .tab-group {
+  border-left: 1px solid var(--border);
+  padding-left: var(--s5);
+}
+.tab-group-label {
+  font-size: 9px;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+  color: var(--text-3);
+  opacity: 0.7;
+  padding: 0 14px;
+}
+.tab-group-btns {
+  display: flex;
+}
+
+/* ── Session lifecycle state dots ── */
+.rh-state-ready { background: var(--green); }
+.rh-state-partial { background: var(--yellow); }
+.rh-state-live { background: var(--red); }
+.rh-state-upcoming { background: var(--text-3); }
+.rh-state-preparing { background: var(--text-3); opacity: 0.5; }
+.rh-state-unavailable { background: var(--text-3); opacity: 0.4; }
+.rh-state-cancelled { background: var(--text-3); opacity: 0.35; }
+
+/* ── Pre-session (expected availability) view ── */
+.rh-presession {
+  display: flex;
+  flex-direction: column;
+  gap: var(--s5);
+}
+.rh-presession-band {
+  padding: var(--s6) var(--s5);
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-left: 3px solid var(--gp-accent);
+  border-radius: 4px;
+  display: flex;
+  flex-direction: column;
+  gap: var(--s3);
+}
+.rh-presession-eyebrow {
+  font-size: 10px;
+  letter-spacing: 0.14em;
+  text-transform: uppercase;
+  color: var(--text-3);
+}
+.rh-presession-title {
+  font-size: 22px;
+  font-weight: 700;
+  margin: 0;
+}
+.rh-presession-sub { color: var(--text-2); max-width: 60ch; }
+.rh-presession-countdown {
+  font-size: 15px;
+  color: var(--text);
+  margin-top: var(--s3);
+}
+.rh-partial-banner {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: var(--s3);
+  margin: 0 var(--s5) var(--s3);
+  padding: var(--s3) var(--s4);
+  border: 1px solid color-mix(in srgb, var(--yellow) 45%, var(--border));
+  background: color-mix(in srgb, var(--yellow) 12%, transparent);
+  color: var(--text-2);
+  font-size: 12px;
+}
+.rh-partial-banner-link {
+  appearance: none;
+  background: transparent;
+  border: 0;
+  color: var(--text);
+  text-decoration: underline;
+  cursor: pointer;
+  font: inherit;
+}
+.rh-expected-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(160px, 1fr));
+  gap: var(--s4);
+}
+.rh-expected-card {
+  padding: var(--s4);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  background: var(--surface);
+  display: flex;
+  align-items: center;
+  gap: var(--s3);
+  color: var(--text-2);
+  font-size: 13px;
+}
+.rh-expected-card .rh-expected-dot {
+  width: 6px;
+  height: 6px;
+  border-radius: 50%;
+  background: var(--text-3);
+  opacity: 0.6;
+}
+
+/* ── Loading / error recovery ── */
+.rh-recover {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: var(--s4);
+  padding: var(--s6) var(--s5);
+}
+.rh-recover-actions {
+  display: flex;
+  gap: var(--s3);
+  flex-wrap: wrap;
+}
+.rh-recover-btn {
+  padding: 8px 14px;
+  font-size: 12px;
+  font-weight: 600;
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  background: var(--surface);
+  color: var(--text);
+  cursor: pointer;
+  text-decoration: none;
+}
+.rh-recover-btn:hover { border-color: var(--gp-accent); }
+.rh-recover-btn.primary { border-color: var(--red); color: var(--text); }
+
+/* ── Diagnostics (secondary) action ── */
+.rh-diagnostics-toggle {
+  align-self: flex-start;
+  margin-left: auto;
+  padding: 6px 12px;
+  font-size: 11px;
+  font-weight: 600;
+  color: var(--text-3);
+  background: none;
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  cursor: pointer;
+}
+.rh-diagnostics-toggle:hover { color: var(--text-2); border-color: var(--gp-accent); }
+.rh-diagnostics-toggle.active { color: var(--text); }
+
 /* ── Dataset status view ── */
 .ds-legend {
   display: flex;
@@ -2622,6 +2905,31 @@ a { color: inherit; text-decoration: none; }
 
 .rh-topbar-spacer { flex: 1; }
 
+.rh-back-weekend {
+  flex-shrink: 0;
+  padding: 4px 10px;
+  font-size: 10px;
+  font-weight: 700;
+  font-family: var(--f-mono);
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+  color: var(--text-2);
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 2px;
+  transition: color 0.1s, border-color 0.1s, background 0.1s;
+}
+.rh-back-weekend:hover,
+.rh-back-weekend:focus-visible {
+  color: var(--text);
+  border-color: var(--gp-accent);
+  background: var(--surface-h);
+  outline: none;
+}
+.rh-back-weekend:focus-visible {
+  box-shadow: 0 0 0 2px color-mix(in srgb, var(--gp-accent) 45%, transparent);
+}
+
 .rh-switcher-toggle {
   padding: 4px 10px;
   font-size: 10px;
@@ -3197,7 +3505,10 @@ a { color: inherit; text-decoration: none; }
   .rh-overview-row { grid-template-columns: 1fr; }
 }
 @media (max-width: 640px) {
-  .rh-page { padding: var(--s4); gap: var(--s4); }
+  .rh-page { padding: var(--s4); gap: var(--s4); padding-bottom: 88px; }
+  .rh-topbar { flex-wrap: wrap; gap: var(--s3); }
+  .rh-topbar-spacer { display: none; }
+  .rh-back-weekend { order: -1; }
   .rh-identity-body { padding: var(--s3) var(--s4); gap: var(--s3); }
   .rh-identity-decal { font-size: 28px; }
   .rh-identity-name { font-size: 17px; }

frontend/src/styles/chapters.css

@@ -9,6 +9,7 @@
   align-items: center;
   justify-content: space-between;
   gap: var(--s4);
+  flex-wrap: wrap;
 }
 
 .chapter-strip-title {
@@ -44,6 +45,31 @@
   color: var(--text);
 }
 
+.chapter-strip-scroll-wrap {
+  position: relative;
+}
+
+.chapter-strip-scroll-wrap::before,
+.chapter-strip-scroll-wrap::after {
+  content: '';
+  position: absolute;
+  top: 0;
+  bottom: var(--s2);
+  width: 28px;
+  pointer-events: none;
+  z-index: 1;
+}
+
+.chapter-strip-scroll-wrap::before {
+  left: 0;
+  background: linear-gradient(to right, var(--bg), transparent);
+}
+
+.chapter-strip-scroll-wrap::after {
+  right: 0;
+  background: linear-gradient(to left, var(--bg), transparent);
+}
+
 .chapter-strip-scroll {
   display: flex;
   gap: var(--s3);
@@ -51,10 +77,26 @@
   padding-bottom: var(--s2);
   scroll-snap-type: x mandatory;
   -webkit-overflow-scrolling: touch;
+  scrollbar-width: thin;
+  scrollbar-color: var(--border-2) transparent;
+}
+
+.chapter-strip-scroll::-webkit-scrollbar {
+  height: 4px;
+}
+
+.chapter-strip-scroll::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+.chapter-strip-scroll::-webkit-scrollbar-thumb {
+  background: var(--border-2);
+  border-radius: 999px;
 }
 
 .chapter-card {
   flex: 0 0 min(240px, 72vw);
+  min-height: 88px;
   display: flex;
   flex-direction: column;
   gap: var(--s2);
@@ -64,7 +106,7 @@
   background: var(--surface);
   text-align: left;
   cursor: pointer;
-  scroll-snap-align: start;
+  scroll-snap-align: center;
   transition: border-color 0.15s, background 0.15s, box-shadow 0.15s;
 }
 
@@ -145,10 +187,22 @@
   -webkit-line-clamp: 2;
   -webkit-box-orient: vertical;
   overflow: hidden;
+  flex: 1;
 }
 
-.chapter-strip-empty {
-  font-size: 12px;
-  color: var(--text-3);
-  padding: var(--s3) 0;
+.chapter-strip-empty-card {
+  padding: var(--s6) var(--s5);
+  margin: 0;
+}
+
+.chapter-strip-empty-card .empty-state-icon {
+  display: block;
+  margin: 0 auto var(--s3);
+  color: var(--text-3);
+}
+
+@media (max-width: 900px) {
+  .chapter-strip-header {
+    align-items: flex-start;
+  }
 }

frontend/src/styles/live-state.css

@@ -0,0 +1,414 @@
+/* ── Live → settling → analysis handoff (issue #74) ──
+ *
+ * State-transition presentation for Live: session/flag chrome that replaces
+ * the old connection-as-session conflation, the connection-loss warning, the
+ * archive read-only strip, and the settling/inactive handoff surface.
+ */
+
+/* Session flag: primary session state. Feed health is secondary. */
+.live-session-flag {
+  display: inline-flex;
+  align-items: center;
+  gap: var(--s2);
+  padding: 5px 9px;
+  border-radius: 3px;
+  font-family: var(--f-mono);
+  font-size: 10px;
+  font-weight: 800;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+  white-space: nowrap;
+}
+
+.live-session-flag-live {
+  background: rgba(225, 6, 0, 0.14);
+  border: 1px solid rgba(225, 6, 0, 0.35);
+  color: #ff6b6b;
+}
+
+.live-session-flag-live.is-stale {
+  background: rgba(255, 214, 0, 0.1);
+  border-color: rgba(255, 214, 0, 0.35);
+  color: var(--yellow);
+}
+
+.live-session-flag-archive {
+  background: rgba(70, 140, 255, 0.12);
+  border: 1px solid rgba(70, 140, 255, 0.35);
+  color: #8bb7ff;
+}
+
+.live-session-dot {
+  width: 7px;
+  height: 7px;
+  border-radius: 50%;
+  background: currentColor;
+  box-shadow: 0 0 0 0 currentColor;
+  animation: live-pulse 1.6s ease-in-out infinite;
+}
+
+.live-session-flag-live.is-stale .live-session-dot {
+  animation: none;
+  opacity: 0.55;
+}
+
+.live-feed-health {
+  display: inline-flex;
+  align-items: center;
+  gap: var(--s2);
+  padding: 4px 7px;
+  border-radius: 2px;
+  font-family: var(--f-mono);
+  font-size: 10px;
+  font-weight: 700;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--text-3);
+  border: 1px solid var(--border-2);
+  background: rgba(255, 255, 255, 0.03);
+}
+
+.live-feed-dot {
+  width: 6px;
+  height: 6px;
+  border-radius: 50%;
+  background: currentColor;
+}
+
+.live-feed-connected {
+  color: var(--green);
+  border-color: rgba(57, 199, 58, 0.25);
+  background: rgba(57, 199, 58, 0.08);
+}
+
+.live-feed-connecting {
+  color: var(--yellow);
+  border-color: rgba(255, 214, 0, 0.25);
+  background: rgba(255, 214, 0, 0.08);
+}
+
+.live-feed-disconnected,
+.live-feed-error {
+  color: #ff6b6b;
+  border-color: rgba(225, 6, 0, 0.24);
+  background: rgba(225, 6, 0, 0.08);
+}
+
+.live-banner-archive {
+  border-color: rgba(70, 140, 255, 0.28);
+}
+
+.live-archive-stamp {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-end;
+  gap: 2px;
+}
+
+.live-archive-readonly {
+  font-size: 10px;
+  font-weight: 800;
+  letter-spacing: 0.08em;
+  color: #8bb7ff;
+}
+
+.live-archive-captured {
+  font-size: 10px;
+  color: var(--text-3);
+}
+
+.live-state-archive {
+  background: rgba(70, 140, 255, 0.12);
+  color: #8bb7ff;
+  border: 1px solid rgba(70, 140, 255, 0.28);
+}
+
+/* Disconnected warning: a live session whose feed dropped. Distinct from the
+ * blue archive strip so a dropped feed is never mistaken for a read-only
+ * archive. The retained tower stays visible beneath it. */
+.live-status-strip.live-status-warn {
+  display: flex;
+  align-items: center;
+  gap: var(--s3);
+}
+
+.live-status-strip.live-status-warn::before {
+  content: '';
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  background: var(--yellow);
+  animation: live-pulse 1.6s ease-in-out infinite;
+}
+
+@keyframes live-pulse {
+  0%,
+  100% {
+    opacity: 1;
+  }
+  50% {
+    opacity: 0.35;
+  }
+}
+
+.live-status-strip.live-status-archive {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: var(--s4);
+  flex-wrap: wrap;
+}
+
+.live-archive-exit {
+  min-height: 28px;
+  padding: 0 var(--s4);
+  border: 1px solid rgba(70, 140, 255, 0.4);
+  border-radius: 4px;
+  background: rgba(70, 140, 255, 0.12);
+  color: #8bb7ff;
+  font-family: var(--f-mono);
+  font-size: 11px;
+  font-weight: 700;
+  text-transform: uppercase;
+  cursor: pointer;
+}
+
+.live-archive-exit:hover {
+  border-color: rgba(70, 140, 255, 0.7);
+  background: rgba(70, 140, 255, 0.2);
+}
+
+/* ── Handoff surface (settling + inactive) ── */
+.live-handoff {
+  border: 1px solid var(--border-2);
+  border-radius: 10px;
+  padding: var(--s6) var(--s5);
+  background:
+    radial-gradient(120% 120% at 0% 0%, rgba(255, 255, 255, 0.04), transparent 55%),
+    var(--surface);
+}
+
+.live-handoff-settling {
+  border-left: 3px solid var(--yellow);
+}
+
+.live-handoff-inactive {
+  border-left: 3px solid var(--border-2);
+}
+
+.live-handoff-head {
+  display: flex;
+  flex-direction: column;
+  gap: var(--s3);
+  margin-bottom: var(--s5);
+}
+
+.live-handoff-eyebrow {
+  display: inline-flex;
+  align-items: center;
+  gap: var(--s2);
+  align-self: flex-start;
+  padding: 4px var(--s3);
+  border-radius: 3px;
+  font-size: 10px;
+  font-weight: 800;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+
+.live-handoff-settling .live-handoff-eyebrow {
+  color: var(--yellow);
+  background: rgba(245, 158, 11, 0.14);
+  border: 1px solid rgba(245, 158, 11, 0.3);
+}
+
+.live-handoff-inactive .live-handoff-eyebrow {
+  color: var(--text-2);
+  background: rgba(255, 255, 255, 0.05);
+  border: 1px solid var(--border-2);
+}
+
+.live-handoff-title {
+  font-size: 26px;
+  line-height: 1.15;
+  font-weight: 800;
+}
+
+.live-handoff-captured {
+  font-size: 11px;
+  color: var(--text-3);
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+}
+
+.live-handoff-sub {
+  font-size: 13px;
+  color: var(--text-2);
+  max-width: 62ch;
+}
+
+.live-handoff-feed {
+  align-self: flex-start;
+  margin-top: var(--s2);
+}
+
+/* Provisional final-order snapshot chips (settling only). */
+.live-handoff-snapshot {
+  margin-bottom: var(--s5);
+  padding: var(--s4);
+  border: 1px dashed var(--border-2);
+  border-radius: 8px;
+  background: rgba(255, 255, 255, 0.02);
+}
+
+.live-handoff-snapshot-label {
+  display: block;
+  margin-bottom: var(--s3);
+  font-size: 10px;
+  color: var(--text-3);
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+}
+
+.live-handoff-order {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--s3);
+  list-style: none;
+}
+
+.live-handoff-order li {
+  display: inline-flex;
+  align-items: center;
+  gap: var(--s2);
+  padding: var(--s2) var(--s3);
+  border: 1px solid var(--border-2);
+  border-radius: 4px;
+  background: rgba(255, 255, 255, 0.03);
+  font-size: 12px;
+}
+
+.live-handoff-order li span:first-child {
+  color: var(--text-3);
+  font-size: 11px;
+}
+
+.live-handoff-code {
+  font-weight: 800;
+  color: var(--text);
+}
+
+/* ── Action cards ── */
+.live-handoff-actions {
+  display: grid;
+  gap: var(--s3);
+}
+
+.live-handoff-action {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: var(--s4);
+  width: 100%;
+  padding: var(--s4) var(--s5);
+  border: 1px solid var(--border-2);
+  border-radius: 8px;
+  background: rgba(255, 255, 255, 0.03);
+  color: var(--text);
+  text-align: left;
+  cursor: pointer;
+  transition:
+    border-color 0.15s ease,
+    background 0.15s ease,
+    transform 0.15s ease;
+}
+
+button.live-handoff-action {
+  font: inherit;
+}
+
+.live-handoff-action:hover {
+  border-color: var(--border-glow);
+  background: rgba(255, 255, 255, 0.06);
+  transform: translateX(2px);
+}
+
+.live-handoff-action-body {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  min-width: 0;
+}
+
+.live-handoff-action-label {
+  display: inline-flex;
+  align-items: center;
+  gap: var(--s2);
+  font-size: 14px;
+  font-weight: 700;
+}
+
+.live-handoff-action-meta {
+  font-size: 11px;
+  color: var(--text-3);
+}
+
+/* The primary "open analysis" action is the strongest affordance. */
+.live-handoff-primary {
+  border-color: rgba(230, 36, 41, 0.4);
+  background: linear-gradient(90deg, rgba(230, 36, 41, 0.14), transparent 60%);
+}
+
+.live-handoff-primary:hover {
+  border-color: rgba(230, 36, 41, 0.7);
+  background: linear-gradient(90deg, rgba(230, 36, 41, 0.22), transparent 60%);
+}
+
+/* Pending-analysis states read as "waiting", not actionable links. */
+.live-handoff-primary[data-ready='false'] {
+  border-color: rgba(245, 158, 11, 0.4);
+  background: linear-gradient(90deg, rgba(245, 158, 11, 0.1), transparent 60%);
+}
+
+.live-handoff-pending {
+  cursor: default;
+  opacity: 0.75;
+}
+
+.live-handoff-pending:hover {
+  transform: none;
+  background: rgba(255, 255, 255, 0.03);
+  border-color: var(--border-2);
+}
+
+.live-handoff-next {
+  cursor: default;
+}
+
+.live-handoff-next:hover {
+  transform: none;
+}
+
+/* ── Responsive: keep the handoff usable at tablet / mobile widths ── */
+@media (max-width: 640px) {
+  .live-handoff {
+    padding: var(--s5) var(--s4);
+  }
+
+  .live-handoff-title {
+    font-size: 21px;
+  }
+
+  .live-handoff-action {
+    padding: var(--s4);
+  }
+
+  .live-handoff-action-label {
+    font-size: 13px;
+  }
+
+  .live-status-strip.live-status-archive {
+    flex-direction: column;
+    align-items: flex-start;
+  }
+}

frontend/src/styles/race-story.css

@@ -0,0 +1,157 @@
+.race-story-empty-card {
+  padding: var(--s6) var(--s5);
+  margin: 0;
+}
+
+.race-story-empty-card .empty-state-icon {
+  display: block;
+  margin: 0 auto var(--s3);
+  color: var(--text-3);
+}
+
+.rs-replay-shell {
+  display: grid;
+  grid-template-columns: 1fr;
+  gap: var(--s5);
+  align-items: stretch;
+}
+
+.rs-replay-shell--split {
+  grid-template-columns: minmax(0, 1.4fr) minmax(260px, 0.8fr);
+}
+
+.rs-replay-main {
+  min-width: 0;
+}
+
+.rs-chart-container {
+  --rs-chart-max-width: 100%;
+}
+
+.rs-chart-container--full {
+  --rs-chart-max-width: 100%;
+}
+
+.rs-segmented-control {
+  display: inline-flex;
+  align-items: stretch;
+  flex-wrap: wrap;
+  gap: 0;
+  margin-top: var(--s3);
+  border: 1px solid var(--border-2);
+  border-radius: var(--s1);
+  background: var(--surface);
+  overflow: hidden;
+}
+
+.rs-segment {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  min-height: 30px;
+  padding: 0 var(--s4);
+  font-family: var(--f-mono);
+  font-size: 10px;
+  font-weight: 700;
+  letter-spacing: 0.04em;
+  color: var(--text-3);
+  background: transparent;
+  border: none;
+  border-right: 1px solid var(--border);
+  cursor: pointer;
+  transition: background 0.12s, color 0.12s;
+}
+
+.rs-segment:last-child {
+  border-right: none;
+}
+
+.rs-segment:hover:not(:disabled) {
+  color: var(--text);
+  background: var(--surface-h);
+}
+
+.rs-segment:focus-visible {
+  outline: 2px solid var(--red);
+  outline-offset: -2px;
+  z-index: 1;
+}
+
+.rs-segment.active {
+  color: var(--text);
+  background: rgba(230, 36, 41, 0.12);
+  box-shadow: inset 0 -2px 0 var(--red);
+}
+
+.rs-segment:disabled {
+  opacity: 0.45;
+  cursor: not-allowed;
+}
+
+.rs-segment-divider {
+  width: 1px;
+  align-self: stretch;
+  background: var(--border);
+  flex-shrink: 0;
+}
+
+.rs-replay-map-slot {
+  min-width: 0;
+}
+
+.rs-position-chart-svg {
+  width: 100%;
+  min-width: 280px;
+  max-width: var(--rs-chart-max-width, 640px);
+  display: block;
+}
+
+.rs-chart-axis-label {
+  fill: var(--text-3);
+  font-family: var(--f-mono);
+  font-size: 9px;
+}
+
+.rs-chart-grid-line {
+  stroke: var(--border);
+  stroke-width: 0.5;
+}
+
+.rs-chart-lap-tick {
+  stroke: var(--border);
+  stroke-width: 1;
+}
+
+@media (max-width: 900px) {
+  .rs-replay-shell--split {
+    grid-template-columns: 1fr;
+  }
+
+  .rs-segmented-control {
+    width: 100%;
+  }
+
+  .rs-segment {
+    flex: 1 1 auto;
+  }
+}
+
+@media (max-width: 560px) {
+  .rs-segmented-control {
+    flex-direction: column;
+    align-items: stretch;
+  }
+
+  .rs-segment {
+    border-right: none;
+    border-bottom: 1px solid var(--border);
+  }
+
+  .rs-segment:last-child {
+    border-bottom: none;
+  }
+
+  .rs-segment-divider {
+    display: none;
+  }
+}

frontend/src/styles/replay-map.css

@@ -1,76 +1,9 @@
-.rs-replay-shell {
-  display: grid;
-  grid-template-columns: minmax(0, 1.4fr) minmax(260px, 0.8fr);
-  gap: var(--s5);
-  align-items: stretch;
-}
-
-.rs-replay-main {
-  min-width: 0;
-}
-
-.rs-replay-tools {
-  display: flex;
-  align-items: center;
-  flex-wrap: wrap;
-  gap: var(--s3);
-  margin-top: var(--s3);
-}
-
-.rs-tool-btn,
-.rs-speed-btn {
-  height: 28px;
-  padding: 0 var(--s4);
-  font-family: var(--f-mono);
-  font-size: 10px;
-  font-weight: 700;
-  color: var(--text-2);
-  background: var(--surface);
-  border: 1px solid var(--border-2);
-  border-radius: 2px;
-  cursor: pointer;
-}
-
-.rs-tool-btn:hover,
-.rs-speed-btn:hover {
-  color: var(--text);
-  border-color: var(--text-3);
-}
-
-.rs-tool-btn.active,
-.rs-speed-btn.active {
-  color: var(--text);
-  border-color: var(--red);
-  background: rgba(230, 36, 41, 0.12);
-}
-
-.rs-speed-group {
-  display: inline-flex;
-  gap: 2px;
-}
-
-.rs-replay-map-slot {
-  min-width: 0;
-}
-
-.rs-replay-map-placeholder {
-  min-height: 244px;
-  display: grid;
-  place-items: center;
-  padding: var(--s5);
-  color: var(--text-3);
-  font-family: var(--f-mono);
-  font-size: 11px;
-  text-align: center;
-  border: 1px dashed var(--border-2);
-  background: var(--surface);
-}
-
 .replay-map-panel {
   min-height: 244px;
   height: 100%;
   border: 1px solid var(--border);
   background: var(--surface);
+  border-radius: var(--s2);
 }
 
 .replay-map-stage {
@@ -143,19 +76,16 @@
   stroke-width: 1.2;
 }
 
-.replay-map-empty {
+.replay-map-empty-card {
   min-height: 244px;
   display: grid;
-  place-items: center;
-  padding: var(--s5);
-  color: var(--text-3);
-  font-family: var(--f-mono);
-  font-size: 11px;
-  text-align: center;
+  place-content: center;
+  padding: var(--s6);
+  margin: 0;
 }
 
-@media (max-width: 860px) {
-  .rs-replay-shell {
-    grid-template-columns: 1fr;
-  }
+.replay-map-empty-card .empty-state-icon {
+  display: block;
+  margin: 0 auto var(--s3);
+  color: var(--text-3);
 }

frontend/src/styles/rivalry.css

@@ -0,0 +1,134 @@
+.rivalry {
+  display: flex;
+  flex-direction: column;
+  gap: var(--s5);
+}
+
+.rivalry-pickers {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--s4);
+  align-items: flex-end;
+}
+
+.rivalry-vs {
+  font-size: 11px;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--text-3);
+  padding-bottom: var(--s3);
+}
+
+.rivalry-picker {
+  display: flex;
+  flex-direction: column;
+  gap: var(--s2);
+  min-width: 200px;
+}
+
+.rivalry-picker-label {
+  font-family: var(--f-mono);
+  font-size: 11px;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--text-3);
+}
+
+.rivalry-picker-select {
+  font-family: var(--f-mono);
+  font-size: 13px;
+  padding: var(--s2) var(--s3);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  background: var(--surface-2);
+  color: var(--text);
+}
+
+.rivalry-picker-select:focus {
+  outline: 2px solid var(--red);
+  outline-offset: 1px;
+}
+
+.rivalry-h2h {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: var(--s4) var(--s5);
+  padding: var(--s4) var(--s5);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  background: var(--surface-2);
+}
+
+.rivalry-h2h-score {
+  display: flex;
+  align-items: baseline;
+  gap: var(--s3);
+}
+
+.rivalry-h2h-code {
+  font-size: 14px;
+  font-weight: 700;
+}
+
+.rivalry-h2h-num {
+  font-size: 24px;
+  font-weight: 700;
+  color: var(--text);
+}
+
+.rivalry-h2h-meta {
+  font-family: var(--f-mono);
+  font-size: 11px;
+  color: var(--text-3);
+}
+
+.rivalry-strip {
+  display: flex;
+  align-items: center;
+  gap: var(--s2);
+  margin-left: auto;
+}
+
+.rivalry-strip-label {
+  font-family: var(--f-mono);
+  font-size: 10px;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--text-3);
+  margin-right: var(--s2);
+}
+
+.rivalry-chip {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 1px;
+  padding: var(--s1) var(--s3);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  background: var(--surface);
+}
+
+.rivalry-chip-round {
+  font-size: 9px;
+  color: var(--text-3);
+}
+
+.rivalry-chip-winner {
+  font-size: 11px;
+  font-weight: 700;
+}
+
+.rivalry-section {
+  display: flex;
+  flex-direction: column;
+  gap: var(--s3);
+}
+
+.rivalry-caption {
+  font-family: var(--f-mono);
+  font-size: 11px;
+  color: var(--text-3);
+  margin: 0;
+}

frontend/src/styles/weekend.css

@@ -0,0 +1,419 @@
+/* ── Weekend adaptive home ── */
+.wk-page {
+  max-width: 1280px;
+  margin: 0 auto;
+  padding: var(--s6) var(--s6) 64px;
+  width: 100%;
+}
+
+.wk-focus {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: var(--s5);
+  margin-bottom: var(--s5);
+  padding: var(--s5);
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-left: 3px solid var(--red);
+  border-radius: 8px;
+}
+.wk-focus-copy { display: flex; flex-direction: column; gap: var(--s2); min-width: 0; }
+.wk-focus-eyebrow {
+  font-size: 10px;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+  color: var(--text-3);
+}
+.wk-focus-title {
+  font-size: 18px;
+  font-weight: 700;
+  line-height: 1.2;
+}
+.wk-focus-session {
+  font-size: 13px;
+  color: var(--text-2);
+}
+.wk-focus-cta { flex-shrink: 0; }
+
+.wk-eyebrow {
+  display: flex;
+  align-items: center;
+  gap: var(--s4);
+  font-size: 11px;
+  font-weight: 700;
+  letter-spacing: 0.18em;
+  text-transform: uppercase;
+  color: var(--text-2);
+  margin-bottom: var(--s5);
+}
+.wk-eyebrow::after {
+  content: '';
+  flex: 1;
+  height: 1px;
+  background: linear-gradient(90deg, var(--red), transparent);
+}
+
+.wk-card-head {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: var(--s4);
+  margin-bottom: var(--s4);
+}
+.wk-card-title {
+  font-size: 13px;
+  font-weight: 700;
+  color: var(--text);
+}
+.wk-card-link {
+  font-size: 11px;
+  color: var(--text-2);
+  white-space: nowrap;
+}
+.wk-card-link:hover { color: var(--text); }
+
+.wk-flag { font-size: 22px; line-height: 1; }
+
+/* ── CTAs ── */
+.wk-cta {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: var(--s3);
+  padding: var(--s4) var(--s5);
+  font-size: 13px;
+  font-weight: 600;
+  border-radius: 6px;
+  transition: background 0.12s, border-color 0.12s, transform 0.12s;
+}
+.wk-cta-primary { background: var(--red); color: #fff; }
+.wk-cta-primary:hover { background: #ff3b3f; }
+.wk-cta:disabled,
+.wk-cta[aria-busy='true'] {
+  opacity: 0.55;
+  cursor: not-allowed;
+  pointer-events: none;
+}
+.wk-cta-ghost {
+  background: transparent;
+  color: var(--text-2);
+  border: 1px solid var(--border-2);
+}
+.wk-cta-ghost:hover { color: var(--text); border-color: var(--text-3); }
+.wk-cta-wide { width: 100%; }
+
+/* ── Between-races top grid ── */
+.wk-top-grid {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: var(--s5);
+  margin-bottom: var(--s5);
+}
+.wk-mid-grid {
+  display: grid;
+  grid-template-columns: minmax(0, 340px) minmax(0, 1fr);
+  gap: var(--s5);
+  margin-bottom: var(--s5);
+}
+
+.wk-event-card {
+  min-width: 0;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 12px;
+  padding: var(--s5);
+  display: flex;
+  flex-direction: column;
+  gap: var(--s5);
+}
+.wk-event-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: var(--s4);
+}
+.wk-event-id { display: flex; align-items: center; gap: var(--s4); min-width: 0; }
+.wk-event-name {
+  font-size: 24px;
+  font-weight: 700;
+  letter-spacing: -0.01em;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.wk-event-tag {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  font-size: 10px;
+  font-weight: 700;
+  letter-spacing: 0.1em;
+  text-transform: uppercase;
+  white-space: nowrap;
+}
+.wk-tag-done { color: var(--text-2); }
+.wk-tag-next { color: var(--red); }
+
+.wk-event-body {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) minmax(0, 200px);
+  gap: var(--s5);
+  align-items: stretch;
+}
+
+/* ── Podium ── */
+.wk-podium { list-style: none; display: flex; flex-direction: column; gap: var(--s3); }
+.wk-podium-row {
+  display: grid;
+  grid-template-columns: 20px minmax(0, 1fr) auto;
+  align-items: center;
+  gap: var(--s4);
+  padding: var(--s3) var(--s4);
+  background: var(--surface-h);
+  border-left: 3px solid var(--wk-team, var(--border-2));
+  border-radius: 4px;
+}
+.wk-podium-pos { font-weight: 700; color: var(--text-2); }
+.wk-podium-code { font-weight: 700; color: var(--wk-team, var(--text)); overflow: hidden; text-overflow: ellipsis; }
+.wk-podium-gap { color: var(--text-2); font-size: 12px; }
+.wk-podium-empty { color: var(--text-3); font-size: 12px; padding: var(--s4); }
+
+.wk-story-card {
+  display: flex;
+  flex-direction: column;
+  gap: var(--s3);
+  padding: var(--s4);
+  background: rgba(230, 36, 41, 0.05);
+  border: 1px solid rgba(230, 36, 41, 0.25);
+  border-radius: 8px;
+}
+.wk-story-label { font-size: 13px; font-weight: 700; color: var(--red); }
+.wk-story-text { font-size: 12px; color: var(--text-2); flex: 1; }
+
+/* ── Next event ── */
+.wk-next-body { display: flex; flex-direction: column; gap: var(--s5); }
+.wk-countdown { display: flex; gap: var(--s5); align-items: baseline; }
+.wk-count-unit { font-size: 13px; color: var(--text-2); font-family: var(--f-mono); }
+.wk-count-unit b { font-size: 40px; color: var(--red); font-weight: 700; margin-right: 2px; }
+.wk-countdown-clock { font-size: 32px; font-weight: 700; color: var(--blue); }
+.wk-countdown-live { font-size: 20px; font-weight: 700; color: var(--red); }
+.wk-next-session { display: flex; flex-direction: column; gap: 2px; }
+.wk-next-label { font-size: 10px; letter-spacing: 0.1em; text-transform: uppercase; color: var(--text-3); }
+.wk-next-value { font-size: 15px; font-weight: 600; }
+.wk-season-complete-copy { font-size: 13px; color: var(--text-2); }
+
+/* ── Championship impact ── */
+.wk-champ, .wk-briefing, .wk-season-nav {
+  min-width: 0;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 12px;
+  padding: var(--s5);
+}
+.wk-champ-list { list-style: none; display: flex; flex-direction: column; gap: var(--s3); }
+.wk-champ-row {
+  display: grid;
+  grid-template-columns: 18px minmax(0, 1fr) auto auto;
+  align-items: center;
+  gap: var(--s4);
+  padding: var(--s2) var(--s3);
+  border-left: 3px solid var(--wk-team, var(--border-2));
+}
+.wk-champ-pos { color: var(--text-3); }
+.wk-champ-code { font-weight: 700; color: var(--wk-team, var(--text)); }
+.wk-champ-pts { font-weight: 700; }
+.wk-champ-gap { color: var(--text-3); font-size: 11px; min-width: 34px; text-align: right; }
+.wk-champ-note { margin-top: var(--s4); font-size: 11px; color: var(--text-3); }
+
+/* ── Season progress strip ── */
+.wk-countdown-tbc { font-size: 14px; color: var(--text-3); }
+.wk-season-progress { display: flex; flex-direction: column; gap: var(--s3); }
+.wk-season-progress-head { display: flex; align-items: center; justify-content: space-between; gap: var(--s3); }
+.wk-season-bar {
+  position: relative;
+  height: 8px;
+  border-radius: 999px;
+  background: var(--surface-3);
+  overflow: hidden;
+}
+.wk-season-bar-fill {
+  position: absolute;
+  inset: 0 auto 0 0;
+  background: var(--red);
+  border-radius: 999px;
+}
+.wk-season-progress-label { font-size: 11px; color: var(--text-3); }
+
+/* ── Briefing ── */
+.wk-briefing-list { list-style: none; display: flex; flex-direction: column; }
+.wk-briefing-item { border-top: 1px solid var(--border); }
+.wk-briefing-item:first-child { border-top: none; }
+.wk-briefing-link {
+  display: grid;
+  grid-template-columns: minmax(0, auto) minmax(0, 1fr) auto;
+  align-items: center;
+  gap: var(--s4);
+  padding: var(--s4) 0;
+}
+.wk-briefing-link:hover .wk-briefing-title { color: var(--red); }
+.wk-briefing-cat { font-size: 10px; letter-spacing: 0.08em; text-transform: uppercase; color: var(--red); white-space: nowrap; }
+.wk-briefing-title { font-size: 13px; font-weight: 600; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.wk-briefing-source { font-size: 11px; color: var(--text-3); white-space: nowrap; }
+
+/* ── Between-sessions / live ── */
+.wk-sessions, .wk-live, .wk-pre { display: flex; flex-direction: column; gap: var(--s5); }
+.wk-sessions-head { display: flex; flex-direction: column; gap: 2px; }
+.wk-sessions-title { font-size: 28px; font-weight: 800; letter-spacing: -0.01em; }
+.wk-sessions-circuit { font-size: 12px; color: var(--text-3); text-transform: uppercase; letter-spacing: 0.06em; }
+
+.wk-timeline {
+  list-style: none;
+  display: flex;
+  gap: var(--s3);
+  overflow-x: auto;
+  padding-bottom: var(--s3);
+  scrollbar-width: thin;
+}
+.wk-timeline-node {
+  flex: 1 0 auto;
+  min-width: 72px;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: var(--s2);
+  padding: var(--s3);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+}
+.wk-timeline-dot { width: 10px; height: 10px; border-radius: 50%; background: var(--surface-3); }
+.wk-timeline-done .wk-timeline-dot { background: var(--green); }
+.wk-timeline-live .wk-timeline-dot { background: var(--red); box-shadow: 0 0 0 3px rgba(230,36,41,0.25); }
+.wk-timeline-next { border-color: var(--red); }
+.wk-timeline-next .wk-timeline-dot { border: 2px solid var(--red); }
+.wk-timeline-name { font-size: 12px; font-weight: 600; }
+.wk-timeline-state { font-size: 9px; letter-spacing: 0.08em; text-transform: uppercase; color: var(--text-3); }
+.wk-timeline-done .wk-timeline-state { color: var(--green); }
+.wk-timeline-live .wk-timeline-state, .wk-timeline-next .wk-timeline-state { color: var(--red); }
+
+.wk-recap-card, .wk-upnext-card, .wk-live-card {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 12px;
+  padding: var(--s5);
+  display: flex;
+  flex-direction: column;
+  gap: var(--s4);
+}
+.wk-recap-eyebrow, .wk-upnext-eyebrow { font-size: 10px; letter-spacing: 0.12em; text-transform: uppercase; color: var(--green); }
+.wk-recap-title, .wk-upnext-title { font-size: 20px; font-weight: 700; }
+.wk-upnext-when { font-size: 12px; color: var(--text-3); }
+.wk-upnext-card { border-color: rgba(230,36,41,0.3); }
+
+.wk-live-card { border-color: rgba(230,36,41,0.35); }
+.wk-live-head { display: flex; align-items: center; justify-content: space-between; }
+.wk-live-pulse { width: 12px; height: 12px; border-radius: 50%; background: var(--red); box-shadow: 0 0 0 4px rgba(230,36,41,0.2); }
+.wk-live-lead { font-size: 14px; color: var(--text-2); }
+
+/* ── Pre-session ── */
+.wk-pre-head {
+  display: flex;
+  align-items: center;
+  gap: var(--s5);
+  flex-wrap: wrap;
+}
+.wk-pre-countdown { display: flex; flex-direction: column; gap: 2px; margin-left: auto; }
+.wk-pre-preview { min-width: 0; }
+/* The folded preview page ships its own max-width page; reset it inside Weekend. */
+.wk-pre-preview .preview-page { max-width: 100%; padding: 0; }
+
+/* ── Status views ── */
+.wk-status {
+  max-width: 640px;
+  margin: 64px auto;
+  text-align: center;
+  display: flex;
+  flex-direction: column;
+  gap: var(--s4);
+  align-items: center;
+}
+.wk-status-eyebrow { font-size: 11px; letter-spacing: 0.16em; text-transform: uppercase; color: var(--text-3); }
+.wk-status-title { font-size: 22px; font-weight: 700; }
+.wk-status-sub { font-size: 13px; color: var(--text-2); }
+.wk-status-actions { display: flex; gap: var(--s4); margin-top: var(--s4); }
+.wk-status-error .wk-status-title { color: var(--red); }
+
+/* ── Responsive ── */
+@media (max-width: 900px) {
+  .wk-top-grid, .wk-mid-grid { grid-template-columns: 1fr; }
+  .wk-event-body { grid-template-columns: 1fr; }
+}
+@media (max-width: 640px) {
+  .wk-page { padding: var(--s5) var(--s5) 88px; }
+  .wk-focus {
+    flex-direction: column;
+    align-items: stretch;
+  }
+  .wk-focus-cta { width: 100%; justify-content: center; }
+  .wk-event-name { font-size: 20px; }
+  .wk-sessions-title { font-size: 22px; }
+  .wk-count-unit b { font-size: 32px; }
+  .wk-pre-head { flex-direction: column; align-items: flex-start; }
+  .wk-pre-countdown { margin-left: 0; }
+}
+
+/* ── Explore ── */
+.wk-explore { display: flex; flex-direction: column; gap: var(--s6); }
+.wk-explore-section {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 12px;
+  padding: var(--s5);
+}
+.wk-explore-grid {
+  list-style: none;
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(180px, 1fr));
+  gap: var(--s4);
+}
+.wk-explore-card {
+  display: flex;
+  flex-direction: column;
+  gap: var(--s2);
+  padding: var(--s4);
+  min-width: 0;
+  background: var(--surface-h);
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  height: 100%;
+}
+.wk-explore-card.is-link { transition: border-color 0.12s, background 0.12s; }
+.wk-explore-card.is-link:hover { border-color: var(--text-3); background: var(--surface-2); }
+.wk-explore-top { display: flex; justify-content: space-between; align-items: center; font-size: 11px; color: var(--text-3); }
+.wk-explore-flag { font-size: 18px; }
+.wk-explore-name { font-size: 14px; font-weight: 700; overflow: hidden; text-overflow: ellipsis; }
+.wk-explore-meta { font-size: 11px; color: var(--text-3); }
+.wk-explore-state { font-size: 10px; letter-spacing: 0.08em; text-transform: uppercase; margin-top: var(--s2); }
+.wk-explore-state.is-done { color: var(--green); }
+.wk-explore-state.is-upcoming { color: var(--text-3); }
+
+.wk-explore-drivers { list-style: none; display: flex; flex-wrap: wrap; gap: var(--s3); }
+.wk-driver-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: var(--s3);
+  padding: var(--s3) var(--s4);
+  background: var(--surface-h);
+  border: 1px solid var(--border);
+  border-left: 3px solid var(--wk-team, var(--border-2));
+  border-radius: 6px;
+  transition: border-color 0.12s;
+}
+.wk-driver-chip:hover { border-color: var(--text-3); }
+.wk-driver-pos { color: var(--text-3); font-size: 11px; }
+.wk-driver-code { font-weight: 700; color: var(--wk-team, var(--text)); }
+.wk-driver-pts { color: var(--text-2); font-size: 12px; }
+
+/* ── Reduced motion ── */
+@media (prefers-reduced-motion: reduce) {
+  .wk-cta, .wk-briefing-title, .wk-live-pulse, .wk-timeline-live .wk-timeline-dot { transition: none; }
+}

frontend/src/test/BriefingPage.test.tsx

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
 import { render, screen, waitFor, fireEvent, within } from '@testing-library/react'
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
 import { BriefingPage } from '../pages/BriefingPage'
@@ -21,6 +21,7 @@ import {
   fetchChampionshipHub,
   markNewsRead,
 } from '../api'
+import { rememberResponseAvailability } from '../lib/fetch'
 
 const mockFetchNews = vi.mocked(fetchNews)
 const mockFetchNewsArticle = vi.mocked(fetchNewsArticle)
@@ -73,6 +74,7 @@ const drivers: ChampHubDriver[] = [
     cumulative: [25, 43, 68, 100],
     teammate_wins: 4,
     teammate_losses: 1,
+    round_positions: [],
   },
   {
     driver_number: 4,
@@ -89,6 +91,7 @@ const drivers: ChampHubDriver[] = [
     cumulative: [18, 36, 54, 80],
     teammate_wins: 3,
     teammate_losses: 2,
+    round_positions: [],
   },
 ]
 
@@ -206,4 +209,62 @@ describe('BriefingPage digest layout', () => {
     })
     expect(screen.getByRole('tab', { name: /News/i })).toBeInTheDocument()
   })
+
+  it('keeps articles usable and shows Limited when grouping supplements fail', async () => {
+    mockFetchSeasonMeetings.mockRejectedValue(new Error('API 503: meetings failed'))
+    mockFetchHub.mockRejectedValue(new Error('API 503: hub failed'))
+    renderPage()
+
+    await waitFor(() => {
+      expect(screen.getByTestId('briefing-data-notice')).toHaveTextContent(/Limited/i)
+    })
+    expect(screen.getByText('Verstappen sets the pace in Bahrain')).toBeInTheDocument()
+    expect(screen.queryByTestId('briefing-error')).not.toBeInTheDocument()
+
+    let meetingsCalls = 1
+    let hubCalls = 1
+    let resolveMeetings!: (value: Meeting[]) => void
+    let resolveHub!: (value: ChampionshipHub) => void
+    mockFetchSeasonMeetings.mockImplementation(
+      () =>
+        new Promise<Meeting[]>((resolve) => {
+          meetingsCalls += 1
+          resolveMeetings = resolve
+        }),
+    )
+    mockFetchHub.mockImplementation(
+      () =>
+        new Promise<ChampionshipHub>((resolve) => {
+          hubCalls += 1
+          resolveHub = resolve
+        }),
+    )
+
+    fireEvent.click(screen.getByRole('button', { name: 'Retry' }))
+    await waitFor(() => expect(screen.getByRole('button', { name: 'Retrying…' })).toBeDisabled())
+    expect(screen.getByRole('button', { name: 'Retrying…' })).toHaveAttribute('aria-busy', 'true')
+    fireEvent.click(screen.getByRole('button', { name: 'Retrying…' }))
+    expect(meetingsCalls).toBe(2)
+    expect(hubCalls).toBe(2)
+
+    resolveMeetings([bahrain, monaco])
+    resolveHub(hub)
+    await waitFor(() => expect(screen.queryByTestId('briefing-data-notice')).not.toBeInTheDocument())
+    expect(screen.getByText('Verstappen sets the pace in Bahrain')).toBeInTheDocument()
+  })
+
+  it('preserves Stale hub over routine local News when sources conflict', async () => {
+    const localNews = [...newsItems]
+    rememberResponseAvailability(localNews, { source: 'local', freshness: 'local' })
+    const staleHub = { ...hub }
+    rememberResponseAvailability(staleHub, { source: 'openf1', freshness: 'stale' })
+    mockFetchNews.mockResolvedValue(localNews)
+    mockFetchHub.mockResolvedValue(staleHub)
+
+    renderPage()
+
+    await waitFor(() => expect(screen.getByTestId('briefing-data-notice')).toHaveTextContent(/Stale/i))
+    expect(screen.getByText('Verstappen sets the pace in Bahrain')).toBeInTheDocument()
+    expect(screen.queryByTestId('briefing-error')).not.toBeInTheDocument()
+  })
 })

frontend/src/test/ChampionshipPage.test.tsx

@@ -4,6 +4,7 @@ import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
 import { RouterProvider, createRouter, createRootRoute, createRoute } from '@tanstack/react-router'
 import { ChampionshipPage } from '../pages/ChampionshipPage'
 import type { ChampHubDriver, ChampHubTeam, ChampionshipHub } from '../types'
+import { rememberResponseAvailability } from '../lib/fetch'
 
 vi.mock('../api', () => ({
   fetchSeasons: vi.fn(),
@@ -29,6 +30,7 @@ function driver(over: Partial<ChampHubDriver>): ChampHubDriver {
     poles: 4,
     form: [25, 18, 25, 15, 25],
     cumulative: [25, 43, 68, 83, 108, 200],
+    round_positions: [1, 2, 1, 3, 1, 1],
     teammate_wins: 9,
     teammate_losses: 1,
     ...over,
@@ -47,6 +49,7 @@ const drivers: ChampHubDriver[] = [
     position: 2,
     wins: 3,
     cumulative: [18, 36, 54, 80, 120, 160],
+    round_positions: [2, 1, 2, 2, 2, 2],
   }),
   driver({
     driver_number: 16,
@@ -58,6 +61,7 @@ const drivers: ChampHubDriver[] = [
     position: 3,
     wins: 1,
     cumulative: [15, 28, 40, 60, 90, 120],
+    round_positions: [3, 3, 3, 0, 3, 3],
   }),
 ]
 
@@ -129,6 +133,22 @@ describe('ChampionshipPage', () => {
     expect(screen.getByText('Cumulative points', { exact: false })).toBeInTheDocument()
   })
 
+  it('switches to the rivalry view with the top two drivers preselected', async () => {
+    renderPage()
+
+    await waitFor(() => expect(screen.getByTestId('championship')).toBeInTheDocument())
+
+    fireEvent.click(screen.getByTestId('champ-tab-rivalry'))
+    expect(screen.getByTestId('champ-view-rivalry')).toBeInTheDocument()
+    // Default pair is the top two in the standings: VER vs NOR.
+    expect(screen.getByTestId('rivalry-pick-a')).toHaveValue('1')
+    expect(screen.getByTestId('rivalry-pick-b')).toHaveValue('4')
+    // VER beats NOR in rounds 1, 3, 5, 6 → 4–2.
+    expect(screen.getByTestId('rivalry-h2h-num')).toHaveTextContent('4–2')
+    expect(screen.getByTestId('rivalry-points-race')).toBeInTheDocument()
+    expect(screen.getByTestId('rivalry-gap')).toBeInTheDocument()
+  })
+
   it('switches to the simulator view and projects standings', async () => {
     renderPage()
 
@@ -207,4 +227,36 @@ describe('ChampionshipPage', () => {
     expect(rows[1]).toHaveTextContent('Red Bull')
     expect(rows[1]).toHaveTextContent('9–1')
   })
+
+  it('shows a non-blocking stale notice above usable standings', async () => {
+    const staleHub = { ...hub }
+    rememberResponseAvailability(staleHub, { source: 'openf1', freshness: 'stale' })
+    mockFetchHub.mockResolvedValue(staleHub)
+    renderPage()
+
+    await waitFor(() => expect(screen.getByTestId('championship')).toBeInTheDocument())
+    expect(screen.getByTestId('championship-data-notice')).toHaveTextContent(/Stale/i)
+    expect(screen.getByTestId('champ-view-drivers')).toBeInTheDocument()
+    expect(screen.getAllByText('VER').length).toBeGreaterThan(0)
+  })
+
+  it('shows a non-blocking partial notice when reported', async () => {
+    const partialHub = { ...hub }
+    rememberResponseAvailability(partialHub, { source: 'openf1', freshness: 'partial' })
+    mockFetchHub.mockResolvedValue(partialHub)
+    renderPage()
+
+    await waitFor(() => expect(screen.getByTestId('championship-data-notice')).toBeInTheDocument())
+    expect(screen.getByTestId('championship-data-notice')).toHaveTextContent(/Partial/i)
+  })
+
+  it('shows a non-blocking local notice when reported', async () => {
+    const localHub = { ...hub }
+    rememberResponseAvailability(localHub, { source: 'local', freshness: 'local' })
+    mockFetchHub.mockResolvedValue(localHub)
+    renderPage()
+
+    await waitFor(() => expect(screen.getByTestId('championship-data-notice')).toBeInTheDocument())
+    expect(screen.getByTestId('championship-data-notice')).toHaveTextContent(/Local/i)
+  })
 })

frontend/src/test/ChampionshipSimulator.test.tsx

@@ -17,6 +17,7 @@ function driver(over: Partial<ChampHubDriver>): ChampHubDriver {
     poles: 0,
     form: [],
     cumulative: [],
+    round_positions: [],
     teammate_wins: 0,
     teammate_losses: 0,
     ...over,

frontend/src/test/ChapterStrip.test.tsx

@@ -68,6 +68,25 @@ describe('ChapterStrip', () => {
     expect(screen.getByText('L12–L15')).toBeInTheDocument()
   })
 
+  it('renders an empty-state card when there are no chapters', () => {
+    const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+    render(
+      <QueryClientProvider client={queryClient}>
+        <ChapterStrip
+          chapters={[]}
+          scrubTime={null}
+          tMin={tMin}
+          tRange={tRange}
+          tourActive={false}
+          tourChapterIndex={null}
+          onChapterClick={vi.fn()}
+          onTourToggle={vi.fn()}
+        />
+      </QueryClientProvider>,
+    )
+    expect(screen.getByTestId('chapter-strip-empty')).toBeInTheDocument()
+  })
+
   it('highlights the active chapter from scrub time', () => {
     const scrub = (new Date('2025-05-25T13:13:00Z').getTime() - tMin) / tRange
     renderStrip({ scrubTime: scrub })
@@ -84,4 +103,26 @@ describe('ChapterStrip', () => {
     expect(index).toBe(1)
     expect(scrub).toBeCloseTo(0.6, 2)
   })
+
+  it('highlights an explicitly selected chapter even when scrub is outside its raw window', () => {
+    // Scrub parked at chart start; chapter 1's raw times are mid-race, but selection wins.
+    const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+    render(
+      <QueryClientProvider client={queryClient}>
+        <ChapterStrip
+          chapters={chapters}
+          scrubTime={0}
+          tMin={tMin}
+          tRange={tRange}
+          tourActive={false}
+          tourChapterIndex={null}
+          selectedChapterIndex={1}
+          onChapterClick={vi.fn()}
+          onTourToggle={vi.fn()}
+        />
+      </QueryClientProvider>,
+    )
+    expect(screen.getByTestId('chapter-card-1')).toHaveClass('active')
+    expect(screen.getByTestId('chapter-card-0')).not.toHaveClass('active')
+  })
 })

frontend/src/test/CommandCenterPage.test.tsx

@@ -1,245 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { render, screen, waitFor } from '@testing-library/react'
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
-import { RouterProvider, createRouter, createRootRoute, createRoute } from '@tanstack/react-router'
-import { CommandCenterPage } from '../pages/CommandCenterPage'
-import type { DatasetInfo, Meeting, Weekend } from '../types'
-
-vi.mock('../api', () => ({
-  fetchSeasons: vi.fn(),
-  fetchLocalMeetings: vi.fn(),
-  fetchSeasonMeetings: vi.fn(),
-  fetchSessions: vi.fn(),
-  fetchWeekend: vi.fn(),
-  fetchLiveState: vi.fn(),
-  fetchChampionshipHub: vi.fn(),
-  fetchRaceHub: vi.fn(),
-}))
-
-import {
-  fetchSeasons,
-  fetchLocalMeetings,
-  fetchSeasonMeetings,
-  fetchSessions,
-  fetchWeekend,
-  fetchLiveState,
-  fetchChampionshipHub,
-  fetchRaceHub,
-} from '../api'
-
-const mockFetchSeasons = vi.mocked(fetchSeasons)
-const mockFetchLocalMeetings = vi.mocked(fetchLocalMeetings)
-const mockFetchSeasonMeetings = vi.mocked(fetchSeasonMeetings)
-const mockFetchSessions = vi.mocked(fetchSessions)
-const mockFetchWeekend = vi.mocked(fetchWeekend)
-const mockFetchLiveState = vi.mocked(fetchLiveState)
-const mockFetchChampionshipHub = vi.mocked(fetchChampionshipHub)
-const mockFetchRaceHub = vi.mocked(fetchRaceHub)
-
-const meeting: Meeting = {
-  meeting_key: 1229,
-  meeting_name: 'Monaco',
-  meeting_official_name: 'FORMULA 1 GRAND PRIX DE MONACO 2025',
-  location: 'Monaco',
-  country_name: 'Monaco',
-  country_code: 'MON',
-  country_flag: '',
-  circuit_short_name: 'Monaco',
-  date_start: '2025-05-23T00:00:00+00:00',
-  date_end: '2025-05-25T00:00:00+00:00',
-  year: 2025,
-}
-
-const fullDatasets: Record<string, DatasetInfo> = {
-  meeting: { status: 'available', source: 'local', count: 1 },
-  session: { status: 'available', source: 'local', count: 1 },
-  drivers: { status: 'available', source: 'local', count: 20 },
-  results: { status: 'available', source: 'local', count: 20 },
-  starting_grid: { status: 'available', source: 'local', count: 20 },
-  stints: { status: 'available', source: 'local', count: 2 },
-  pit_stops: { status: 'available', source: 'local', count: 1 },
-  positions: { status: 'available', source: 'local', count: 3 },
-  race_control: { status: 'available', source: 'local', count: 1 },
-  weather: { status: 'available', source: 'local', count: 1 },
-  laps: { status: 'available', source: 'local', count: 1 },
-}
-
-const weekend: Weekend = {
-  source: 'local',
-  meeting_key: 1229,
-  meeting,
-  default_session_key: 9472,
-  sessions: [
-    {
-      session: {
-        session_key: 9472,
-        session_name: 'Race',
-        session_type: 'Race',
-        meeting_key: 1229,
-        date_start: '2025-05-25T13:00:00+00:00',
-        date_end: '2025-05-25T15:00:00+00:00',
-        gmt_offset: '02:00:00',
-      },
-      source: 'local',
-      datasets: fullDatasets,
-    },
-  ],
-}
-
-function renderPage() {
-  const queryClient = new QueryClient({
-    defaultOptions: { queries: { retry: false } },
-  })
-
-  const rootRoute = createRootRoute({
-    component: () => (
-      <QueryClientProvider client={queryClient}>
-        <CommandCenterPage />
-      </QueryClientProvider>
-    ),
-  })
-
-  const indexRoute = createRoute({
-    getParentRoute: () => rootRoute,
-    path: '/',
-    component: CommandCenterPage,
-  })
-
-  const router = createRouter({ routeTree: rootRoute.addChildren([indexRoute]) })
-
-  return render(<RouterProvider router={router} />)
-}
-
-describe('CommandCenterPage', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-    mockFetchLiveState.mockResolvedValue({ is_live: false, data: null })
-    mockFetchSessions.mockResolvedValue([])
-    mockFetchChampionshipHub.mockResolvedValue({
-      season: 2025,
-      round: 1,
-      total_rounds: 1,
-      rounds_left: 0,
-      last_race: 'Monaco',
-      round_labels: ['R1'],
-      drivers: [],
-      teams: [],
-    })
-    mockFetchRaceHub.mockResolvedValue({
-      source: 'local',
-      session_key: 9472,
-      datasets: fullDatasets,
-      results: [
-        {
-          driver_number: 1,
-          position: 1,
-          name_acronym: 'VER',
-          full_name: 'Max Verstappen',
-          team_name: 'Red Bull Racing',
-          team_colour: '3671c6',
-          dnf: false,
-          dns: false,
-          dsq: false,
-          duration: 7200,
-          gap_to_leader: null,
-          number_of_laps: 78,
-          points: 25,
-          session_key: 9472,
-          meeting_key: 1229,
-        },
-      ],
-      starting_grid: [],
-      drivers: [],
-      stints: [],
-      pit_stops: [],
-      positions: [],
-      race_control: [],
-      weather: [],
-      laps: [],
-      chapters: [],
-    })
-  })
-
-  it('shows empty state when no seasons are ingested', async () => {
-    mockFetchSeasons.mockResolvedValue([])
-
-    renderPage()
-
-    await waitFor(() => {
-      expect(screen.getByTestId('command-center-empty')).toBeInTheDocument()
-    })
-    expect(screen.getByText('No local data yet')).toBeInTheDocument()
-  })
-
-  it('shows weekend identity band and schedule when data exists', async () => {
-    mockFetchSeasons.mockResolvedValue([2025])
-    mockFetchLocalMeetings.mockResolvedValue([meeting])
-    mockFetchSeasonMeetings.mockResolvedValue([meeting])
-    mockFetchWeekend.mockResolvedValue(weekend)
-
-    renderPage()
-
-    await waitFor(() => {
-      expect(screen.getByTestId('command-center')).toBeInTheDocument()
-    })
-
-    await waitFor(() => {
-      expect(screen.getByTestId('cc-session-9472')).toBeInTheDocument()
-    })
-    expect(screen.getByTestId('cc-focus')).toHaveTextContent('Monaco')
-    expect(screen.getByTestId('cc-season-calendar')).toHaveTextContent('Season Calendar')
-    expect(screen.getByTestId('cc-calendar-1229')).toHaveTextContent('R01')
-    expect(screen.getByText('No live session')).toBeInTheDocument()
-    expect(screen.getByTestId('hero-last-race-link')).toHaveTextContent('Monaco')
-  })
-
-  it('uses OpenF1 calendar metadata to focus the current weekend when local ingest is behind', async () => {
-    const canada = {
-      ...meeting,
-      meeting_key: 1301,
-      meeting_name: 'Canada',
-      country_name: 'Canada',
-      country_code: 'CAN',
-      circuit_short_name: 'Montreal',
-      date_start: '2026-05-22T00:00:00+00:00',
-      date_end: '2026-05-24T23:59:59+00:00',
-      year: 2026,
-    }
-    const monaco = {
-      ...meeting,
-      meeting_key: 1302,
-      meeting_name: 'Monaco',
-      date_start: '2026-06-05T00:00:00+00:00',
-      date_end: '2026-06-07T23:59:59+00:00',
-      year: 2026,
-    }
-
-    vi.setSystemTime(new Date('2026-06-06T15:15:00Z'))
-    mockFetchSeasons.mockResolvedValue([2026])
-    mockFetchLocalMeetings.mockResolvedValue([canada])
-    mockFetchSeasonMeetings.mockResolvedValue([canada, monaco])
-    mockFetchWeekend.mockResolvedValue({ ...weekend, meeting: canada, meeting_key: canada.meeting_key })
-    mockFetchSessions.mockResolvedValue([
-      {
-        session_key: 9602,
-        session_name: 'Qualifying',
-        session_type: 'Qualifying',
-        meeting_key: monaco.meeting_key,
-        date_start: '2026-06-06T15:00:00+00:00',
-        date_end: '2026-06-06T16:00:00+00:00',
-        gmt_offset: '02:00:00',
-      },
-    ])
-
-    renderPage()
-
-    await waitFor(() => {
-      expect(screen.getByTestId('cc-focus')).toHaveTextContent('Monaco')
-    })
-    expect(screen.getByTestId('cc-focus')).toHaveTextContent('Live now')
-    expect(screen.getByTestId('cc-session-9602')).toHaveTextContent('On track')
-    expect(screen.getByTestId('hero-live-link')).toHaveAttribute('href', '/live')
-
-    vi.useRealTimers()
-  })
-})

frontend/src/test/DataLibraryPage.test.tsx

@@ -116,7 +116,7 @@ describe('DataLibraryPage', () => {
 
     expect(await screen.findByTestId('data-library')).toBeInTheDocument()
     await waitFor(() => {
-      expect(mockFetchLocalMeetings).toHaveBeenCalledWith(2025)
+      expect(mockFetchLocalMeetings).toHaveBeenCalledWith(2025, expect.any(AbortSignal))
     })
 
     expect(await screen.findByTestId('meeting-detail')).toBeInTheDocument()

frontend/src/test/DriverProfilePage.test.tsx

@@ -120,7 +120,7 @@ describe('DriverProfilePage', () => {
 
     // With an explicit year, the seasons list is not needed.
     expect(mockFetchSeasons).not.toHaveBeenCalled()
-    expect(mockFetchSummary).toHaveBeenCalledWith(1, 2025)
+    expect(mockFetchSummary).toHaveBeenCalledWith(1, 2025, expect.any(AbortSignal))
   })
 
   it('defaults to the latest season when no year is given', async () => {
@@ -129,16 +129,19 @@ describe('DriverProfilePage', () => {
     await waitFor(() => {
       expect(screen.getByTestId('driver-profile')).toBeInTheDocument()
     })
-    expect(mockFetchSummary).toHaveBeenCalledWith(1, 2025)
+    expect(mockFetchSummary).toHaveBeenCalledWith(1, 2025, expect.any(AbortSignal))
   })
 
-  it('shows the API error message on failure', async () => {
+  it('shows a user-facing error with retry instead of raw API jargon', async () => {
     mockFetchSummary.mockRejectedValue(new Error('API 404: Not Found'))
     renderPage({ driverNumber: 99, year: 2025 })
 
     await waitFor(() => {
-      expect(screen.getByText('API 404: Not Found')).toBeInTheDocument()
+      expect(screen.getByTestId('driver-profile-error')).toBeInTheDocument()
     })
+    expect(screen.queryByText(/API 404/i)).not.toBeInTheDocument()
+    expect(screen.getByRole('button', { name: 'Retry' })).toBeInTheDocument()
+    expect(screen.getByTestId('driver-profile-error')).toHaveTextContent(/Something went wrong/i)
   })
 
   it('shows empty states when no rounds are completed', async () => {

frontend/src/test/LiveHandoff.test.tsx

@@ -0,0 +1,289 @@
+import { render, screen } from '@testing-library/react'
+import { describe, expect, it, vi } from 'vitest'
+import {
+  LiveHandoff,
+  analysisIsReady,
+  handoffAnalysisSession,
+  shouldPollHandoffAnalysis,
+} from '../components/live/LiveHandoff'
+import type { LiveTimingRow } from '../lib/live'
+import type { ContextSession, WeekendContext } from '../types'
+
+function session(key: number, name: string, type = name): ContextSession['session'] {
+  return {
+    session_key: key,
+    session_name: name,
+    session_type: type,
+    meeting_key: 1,
+    date_start: '2026-07-05T14:00:00Z',
+    date_end: '2026-07-05T16:00:00Z',
+    gmt_offset: '',
+  }
+}
+
+function contextSession(
+  key: number,
+  name: string,
+  localAnalysis: string,
+): ContextSession {
+  return {
+    session: session(key, name),
+    availability: {
+      schedule: 'available',
+      live_transport: 'unknown',
+      live_session: 'inactive',
+      archive: 'unavailable',
+      local_analysis: localAnalysis,
+      freshness: 'fresh',
+      limitations: [],
+    },
+  }
+}
+
+const baseContext: WeekendContext = {
+  temporal_state: 'session_settling',
+  focus_meeting: {
+    meeting_key: 1,
+    meeting_name: 'British Grand Prix',
+    meeting_official_name: 'British Grand Prix',
+    location: 'Silverstone',
+    country_name: 'UK',
+    country_code: 'GB',
+    country_flag: '',
+    circuit_short_name: 'Silverstone',
+    date_start: '2026-07-03T09:00:00Z',
+    date_end: '2026-07-05T16:00:00Z',
+    year: 2026,
+  },
+  championship_round: 1,
+  total_championship_rounds: 1,
+}
+
+/** Canonical contract: archive-only just-finished Race vs older ready Practice. */
+function archiveOnlySettlingContext(previousAnalysis: string): WeekendContext {
+  return {
+    ...baseContext,
+    // Older already-ingested session remains the default analysis target.
+    default_analysis_session: contextSession(10, 'Practice 1', 'complete'),
+    // Just-finished Race is archive-complete but not yet analysis-ready.
+    previous_completed_session: contextSession(99, 'Race', previousAnalysis),
+    next_session: contextSession(12, 'Qualifying', 'not_applicable'),
+  }
+}
+
+const rows: LiveTimingRow[] = [
+  { RacingNumber: '1', Position: 1, Driver: { RacingNumber: '1', Position: 1 } as never, Info: { Tla: 'VER' } as never },
+  { RacingNumber: '4', Position: 2, Driver: { RacingNumber: '4', Position: 2 } as never, Info: { Tla: 'NOR' } as never },
+]
+
+describe('analysisIsReady', () => {
+  it('is true only when local analysis is complete', () => {
+    expect(analysisIsReady(contextSession(11, 'Race', 'complete'))).toBe(true)
+    expect(analysisIsReady(contextSession(11, 'Race', 'pending'))).toBe(false)
+    expect(analysisIsReady(contextSession(11, 'Race', 'partial'))).toBe(false)
+    expect(analysisIsReady(undefined)).toBe(false)
+  })
+})
+
+describe('handoffAnalysisSession', () => {
+  it('settling prefers previous_completed_session over an older default', () => {
+    const ctx = archiveOnlySettlingContext('pending')
+    const analysis = handoffAnalysisSession(ctx, 'settling')
+    expect(analysis?.session.session_key).toBe(99)
+    expect(analysis?.session.session_name).toBe('Race')
+    expect(analysisIsReady(analysis)).toBe(false)
+  })
+
+  it('inactive prefers default_analysis_session (shared analysisSessionKey)', () => {
+    const ctx = archiveOnlySettlingContext('pending')
+    const analysis = handoffAnalysisSession(ctx, 'inactive')
+    expect(analysis?.session.session_key).toBe(10)
+    expect(analysis?.session.session_name).toBe('Practice 1')
+  })
+
+  it('settling falls back to default when previous is absent', () => {
+    const ctx = {
+      ...baseContext,
+      default_analysis_session: contextSession(11, 'Race', 'pending'),
+    }
+    expect(handoffAnalysisSession(ctx, 'settling')?.session.session_key).toBe(11)
+  })
+})
+
+describe('shouldPollHandoffAnalysis', () => {
+  it('keeps polling when previous is pending even if default is already complete', () => {
+    expect(shouldPollHandoffAnalysis(archiveOnlySettlingContext('pending'))).toBe(true)
+  })
+
+  it('stops polling once the just-finished previous session is ready', () => {
+    expect(shouldPollHandoffAnalysis(archiveOnlySettlingContext('complete'))).toBe(false)
+  })
+})
+
+describe('LiveHandoff settling', () => {
+  it('shows SESSION SETTLING with a pending analysis action while ingesting', () => {
+    render(
+      <LiveHandoff
+        phase="settling"
+        transport="connected"
+        context={{
+          ...baseContext,
+          previous_completed_session: contextSession(11, 'Race', 'pending'),
+        }}
+        rows={rows}
+        capturedAt="2026-07-05T16:02:00Z"
+        hasArchive
+        onViewArchive={vi.fn()}
+      />,
+    )
+
+    expect(screen.getByTestId('live-settling')).toBeInTheDocument()
+    expect(screen.getByText('SESSION SETTLING')).toBeInTheDocument()
+    expect(screen.getByTestId('live-handoff-captured')).toHaveTextContent('Final feed snapshot captured')
+    const action = screen.getByTestId('live-handoff-analysis')
+    expect(action).toHaveAttribute('href', '/race-hub?session_key=11')
+    expect(action).toHaveAttribute('data-ready', 'false')
+    expect(action).toHaveTextContent('Open Race analysis')
+    expect(action).toHaveTextContent(/analysis will fill in as data ingests/i)
+    // Provisional final order from the retained snapshot.
+    expect(screen.getByTestId('live-handoff-snapshot')).toHaveTextContent('VER')
+  })
+
+  it('links/labels/readiness follow archive-only previous, not an older ready default', () => {
+    render(
+      <LiveHandoff
+        phase="settling"
+        transport="connected"
+        context={archiveOnlySettlingContext('pending')}
+        rows={rows}
+        capturedAt="2026-07-05T16:02:00Z"
+        hasArchive
+        onViewArchive={vi.fn()}
+      />,
+    )
+
+    const action = screen.getByTestId('live-handoff-analysis')
+    expect(action).toHaveAttribute('href', '/race-hub?session_key=99')
+    expect(action).toHaveAttribute('data-ready', 'false')
+    expect(action).toHaveTextContent('Open Race analysis')
+    expect(action).toHaveTextContent(/Settling — analysis will fill in as data ingests/i)
+    expect(action).not.toHaveTextContent('Practice 1')
+    expect(action).not.toHaveTextContent(/full timing, strategy & story ready/i)
+  })
+
+  it('flips to analysis-ready once local ingestion completes', () => {
+    render(
+      <LiveHandoff
+        phase="settling"
+        transport="connected"
+        context={{
+          ...baseContext,
+          previous_completed_session: contextSession(11, 'Race', 'complete'),
+        }}
+        rows={rows}
+        capturedAt="2026-07-05T16:02:00Z"
+        hasArchive={false}
+        onViewArchive={vi.fn()}
+      />,
+    )
+    const action = screen.getByTestId('live-handoff-analysis')
+    expect(action).toHaveAttribute('data-ready', 'true')
+    expect(action).toHaveTextContent(/full timing, strategy & story ready/i)
+  })
+
+  it('never renders live/connected chrome or a countdown in settling', () => {
+    const { container } = render(
+      <LiveHandoff
+        phase="settling"
+        transport="connected"
+        context={{
+          ...baseContext,
+          previous_completed_session: contextSession(11, 'Race', 'complete'),
+        }}
+        rows={rows}
+        capturedAt="2026-07-05T16:02:00Z"
+        hasArchive
+        onViewArchive={vi.fn()}
+      />,
+    )
+    expect(screen.queryByText('LIVE SESSION')).not.toBeInTheDocument()
+    expect(screen.queryByTestId('live-clock')).not.toBeInTheDocument()
+    expect(container.querySelector('.live-session-flag-live')).toBeNull()
+  })
+
+  it('uses non-settling readiness copy when inactive and analysis is still ingesting', () => {
+    render(
+      <LiveHandoff
+        phase="inactive"
+        transport="connected"
+        context={{ ...baseContext, default_analysis_session: contextSession(11, 'Race', 'pending') }}
+        rows={[]}
+        hasArchive={false}
+        onViewArchive={vi.fn()}
+      />,
+    )
+    const action = screen.getByTestId('live-handoff-analysis')
+    expect(action).toHaveAttribute('data-ready', 'false')
+    expect(action).toHaveTextContent(/analysis will fill in as data ingests/i)
+    expect(action).not.toHaveTextContent(/^Settling/i)
+  })
+})
+
+describe('LiveHandoff inactive', () => {
+  it('uses shared next + recap context instead of a telemetry-offline dead end', () => {
+    render(
+      <LiveHandoff
+        phase="inactive"
+        transport="connected"
+        context={{
+          ...baseContext,
+          temporal_state: 'between_sessions',
+          default_analysis_session: contextSession(11, 'Practice 1', 'complete'),
+          next_session: contextSession(12, 'Qualifying', 'not_applicable'),
+          previous_completed_session: contextSession(10, 'Practice 2', 'complete'),
+        }}
+        rows={[]}
+        hasArchive={false}
+        onViewArchive={vi.fn()}
+      />,
+    )
+    expect(screen.getByTestId('live-inactive')).toBeInTheDocument()
+    expect(screen.getByText('NO LIVE SESSION')).toBeInTheDocument()
+    expect(screen.getByTestId('live-handoff-next')).toHaveTextContent('Qualifying')
+    expect(screen.getByTestId('live-handoff-recap')).toHaveTextContent('Practice 2')
+    // No provisional-order snapshot when inactive.
+    expect(screen.queryByTestId('live-handoff-snapshot')).not.toBeInTheDocument()
+  })
+
+  it('does not duplicate the recap card when previous equals the analysis target', () => {
+    render(
+      <LiveHandoff
+        phase="inactive"
+        transport="connected"
+        context={{
+          ...baseContext,
+          default_analysis_session: contextSession(11, 'Race', 'complete'),
+          previous_completed_session: contextSession(11, 'Race', 'complete'),
+        }}
+        rows={[]}
+        hasArchive={false}
+        onViewArchive={vi.fn()}
+      />,
+    )
+    expect(screen.queryByTestId('live-handoff-recap')).not.toBeInTheDocument()
+  })
+
+  it('falls back to Weekend when the context has nothing to offer', () => {
+    render(
+      <LiveHandoff
+        phase="inactive"
+        transport="error"
+        context={{ temporal_state: 'no_season', championship_round: 0, total_championship_rounds: 0 }}
+        rows={[]}
+        hasArchive={false}
+        onViewArchive={vi.fn()}
+      />,
+    )
+    expect(screen.getByTestId('live-handoff-fallback')).toHaveTextContent('Weekend')
+  })
+})

frontend/src/test/LiveTimingPage.test.tsx

@@ -1,32 +1,34 @@
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
-import { fireEvent, render, screen, waitFor } from '@testing-library/react'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { LiveTimingPage } from '../pages/LiveTimingPage'
-import type { LiveStateResponse, LiveStreamData } from '../types'
+import { act, fireEvent, render, screen, waitFor } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { LiveTimingPage, WEEKEND_CONTEXT_POLL_MS } from '../pages/LiveTimingPage'
+import type { LiveStateResponse, LiveStreamData, WeekendContext } from '../types'
 
 vi.mock('../api', () => ({
   fetchLiveState: vi.fn(),
   fetchLiveTrackOutline: vi.fn(),
+  fetchWeekendContext: vi.fn(),
 }))
 
-import { fetchLiveState, fetchLiveTrackOutline } from '../api'
+import { fetchLiveState, fetchLiveTrackOutline, fetchWeekendContext } from '../api'
 
 const mockFetchLiveState = vi.mocked(fetchLiveState)
 const mockFetchLiveTrackOutline = vi.mocked(fetchLiveTrackOutline)
+const mockFetchWeekendContext = vi.mocked(fetchWeekendContext)
 
+// A MockEventSource that opens on construct but never emits a snapshot, so the
+// initial /api/v1/live/state query drives the rendered phase.
 class MockEventSource {
   onopen: (() => void) | null = null
   onerror: (() => void) | null = null
-
   constructor() {
     setTimeout(() => this.onopen?.(), 0)
   }
-
   addEventListener() {}
   close() {}
 }
 
-const archivedSnapshot: LiveStreamData = {
+const raceSnapshot: LiveStreamData = {
   Drivers: {
     '1': {
       RacingNumber: '1',
@@ -63,19 +65,10 @@ const archivedSnapshot: LiveStreamData = {
       LastName: 'Verstappen',
     },
   },
-  Tyres: {
-    '1': { Compound: 'HARD', New: false, Age: 12 },
-  },
+  Tyres: { '1': { Compound: 'HARD', New: false, Age: 12 } },
   Telemetry: {},
   RCMessages: [],
-  Weather: {
-    AirTemp: 22,
-    TrackTemp: 41,
-    Humidity: 58,
-    WindSpeed: 3,
-    WindDir: 180,
-    Rainfall: false,
-  },
+  Weather: { AirTemp: 22, TrackTemp: 41, Humidity: 58, WindSpeed: 3, WindDir: 180, Rainfall: false },
   Session: {
     MeetingName: 'Testonia Grand Prix',
     CircuitName: 'Testring',
@@ -84,9 +77,9 @@ const archivedSnapshot: LiveStreamData = {
     Path: '',
   },
   TeamRadio: [],
-  SessionStatus: 'Finished',
+  SessionStatus: 'Started',
   TrackStatus: '1',
-  CurrentLap: 57,
+  CurrentLap: 30,
   TotalLaps: 57,
   Clock: '',
   ClockRefTime: '',
@@ -94,17 +87,93 @@ const archivedSnapshot: LiveStreamData = {
   Stints: {},
 }
 
-function renderPage(response: LiveStateResponse) {
-  const queryClient = new QueryClient({
-    defaultOptions: { queries: { retry: false } },
-  })
+function weekendContext(localAnalysis: string): WeekendContext {
+  return {
+    temporal_state: 'session_settling',
+    focus_meeting: {
+      meeting_key: 1,
+      meeting_name: 'Testonia Grand Prix',
+      meeting_official_name: 'Testonia Grand Prix',
+      location: 'Testring',
+      country_name: 'Testonia',
+      country_code: 'TS',
+      country_flag: '',
+      circuit_short_name: 'Testring',
+      date_start: '2026-07-03T09:00:00Z',
+      date_end: '2026-07-05T16:00:00Z',
+      year: 2026,
+    },
+    previous_completed_session: {
+      session: {
+        session_key: 99,
+        session_name: 'Race',
+        session_type: 'Race',
+        meeting_key: 1,
+        date_start: '2026-07-05T14:00:00Z',
+        date_end: '2026-07-05T16:00:00Z',
+        gmt_offset: '',
+      },
+      availability: {
+        schedule: 'available',
+        live_transport: 'unknown',
+        live_session: 'inactive',
+        archive: 'available',
+        local_analysis: localAnalysis,
+        freshness: 'fresh',
+        limitations: [],
+      },
+    },
+    championship_round: 1,
+    total_championship_rounds: 1,
+  }
+}
+
+/** Just-finished archive-only Race + older already-ready Practice default. */
+function archiveOnlySettlingContext(previousAnalysis: string): WeekendContext {
+  return {
+    ...weekendContext(previousAnalysis),
+    default_analysis_session: {
+      session: {
+        session_key: 10,
+        session_name: 'Practice 1',
+        session_type: 'Practice',
+        meeting_key: 1,
+        date_start: '2026-07-04T12:00:00Z',
+        date_end: '2026-07-04T13:00:00Z',
+        gmt_offset: '',
+      },
+      availability: {
+        schedule: 'available',
+        live_transport: 'unknown',
+        live_session: 'inactive',
+        archive: 'available',
+        local_analysis: 'complete',
+        freshness: 'fresh',
+        limitations: [],
+      },
+    },
+  }
+}
+
+function renderPage(
+  response: LiveStateResponse,
+  context?: WeekendContext,
+  options: { setWeekendContext?: boolean } = {},
+) {
+  const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
   mockFetchLiveState.mockResolvedValue(response)
   mockFetchLiveTrackOutline.mockResolvedValue({
     circuit_key: 1,
     points: [],
     bounds: { minX: 0, maxX: 1, minY: 0, maxY: 1 },
   })
-
+  // Allow callers to pre-configure the weekend-context mock (e.g. pending→complete
+  // polling) without this helper overwriting the chain.
+  if (options.setWeekendContext !== false) {
+    mockFetchWeekendContext.mockResolvedValue(
+      context ?? { temporal_state: 'no_season', championship_round: 0, total_championship_rounds: 0 },
+    )
+  }
   return render(
     <QueryClientProvider client={queryClient}>
       <LiveTimingPage />
@@ -112,7 +181,7 @@ function renderPage(response: LiveStateResponse) {
   )
 }
 
-describe('LiveTimingPage archive mode', () => {
+describe('LiveTimingPage', () => {
   beforeEach(() => {
     vi.clearAllMocks()
     Object.defineProperty(window, 'EventSource', {
@@ -122,45 +191,365 @@ describe('LiveTimingPage archive mode', () => {
     })
   })
 
-  it('keeps archived snapshots behind the View Last Session action', async () => {
-    renderPage({
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('renders the live timing tower for an active session', async () => {
+    renderPage({ is_live: true, data: raceSnapshot })
+    expect(await screen.findByText('Timing Tower')).toBeInTheDocument()
+    expect(screen.getByTestId('live-page')).toHaveAttribute('data-phase', 'live')
+    expect(screen.getByTestId('live-session-flag')).toHaveTextContent('LIVE SESSION')
+    expect(screen.getByTestId('live-feed-health')).toBeInTheDocument()
+    expect(screen.getAllByText('VER').length).toBeGreaterThan(0)
+  })
+
+  it('enters the settling handoff (not archive) when the session ends cleanly', async () => {
+    renderPage(
+      {
         is_live: false,
         data: null,
-      last_snapshot: archivedSnapshot,
-      last_positions: {
-        '1': { x: 10, y: 20, z: 0, status: 'OnTrack' },
+        last_snapshot: { ...raceSnapshot, SessionStatus: 'Finished' },
+        last_snapshot_at: '2026-07-05T16:02:00Z',
       },
-      last_snapshot_at: '2026-07-04T14:00:00Z',
+      weekendContext('pending'),
+    )
+
+    const settling = await screen.findByTestId('live-settling')
+    expect(settling).toBeInTheDocument()
+    expect(screen.getByTestId('live-page')).toHaveAttribute('data-phase', 'settling')
+    // Just-finished previous_completed_session drives the primary action target.
+    await waitFor(() =>
+      expect(screen.getByTestId('live-handoff-analysis')).toHaveAttribute(
+        'href',
+        '/race-hub?session_key=99',
+      ),
+    )
+    // The timing tower is not shown while settling — it is a handoff surface.
+    expect(screen.queryByText('Timing Tower')).not.toBeInTheDocument()
   })
 
-    expect(await screen.findByTestId('live-empty')).toHaveTextContent('No live session active')
+  it('settles against archive-only previous, not an older ready default_analysis_session', async () => {
+    vi.useFakeTimers({ shouldAdvanceTime: true })
+    mockFetchWeekendContext
+      .mockResolvedValueOnce(archiveOnlySettlingContext('pending'))
+      .mockResolvedValue(archiveOnlySettlingContext('complete'))
+
+    renderPage(
+      {
+        is_live: false,
+        data: null,
+        last_snapshot: { ...raceSnapshot, SessionStatus: 'Finished' },
+        last_snapshot_at: '2026-07-05T16:02:00Z',
+      },
+      undefined,
+      { setWeekendContext: false },
+    )
+
+    const action = await screen.findByTestId('live-handoff-analysis')
+    expect(action).toHaveAttribute('href', '/race-hub?session_key=99')
+    expect(action).toHaveAttribute('data-ready', 'false')
+    expect(action).toHaveTextContent('Open Race analysis')
+    expect(action).not.toHaveTextContent('Practice 1')
+
+    // Older default is already complete — polling must continue for previous.
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(WEEKEND_CONTEXT_POLL_MS + 500)
+    })
+
+    await waitFor(() =>
+      expect(screen.getByTestId('live-handoff-analysis')).toHaveAttribute('data-ready', 'true'),
+    )
+    expect(screen.getByTestId('live-handoff-analysis')).toHaveAttribute(
+      'href',
+      '/race-hub?session_key=99',
+    )
+    expect(mockFetchWeekendContext.mock.calls.length).toBeGreaterThan(1)
+  })
+
+  it('flips settling → analysis-ready when polling sees ingestion complete', async () => {
+    vi.useFakeTimers({ shouldAdvanceTime: true })
+    // First fetch: pending. Subsequent polls: complete.
+    mockFetchWeekendContext
+      .mockResolvedValueOnce(weekendContext('pending'))
+      .mockResolvedValue(weekendContext('complete'))
+
+    renderPage(
+      {
+        is_live: false,
+        data: null,
+        last_snapshot: { ...raceSnapshot, SessionStatus: 'Finished' },
+        last_snapshot_at: '2026-07-05T16:02:00Z',
+      },
+      undefined,
+      { setWeekendContext: false },
+    )
+
+    const action = await screen.findByTestId('live-handoff-analysis')
+    expect(action).toHaveAttribute('data-ready', 'false')
+    expect(action).toHaveTextContent(/analysis will fill in as data ingests/i)
+
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(WEEKEND_CONTEXT_POLL_MS + 500)
+    })
+
+    await waitFor(() =>
+      expect(screen.getByTestId('live-handoff-analysis')).toHaveAttribute('data-ready', 'true'),
+    )
+    expect(screen.getByTestId('live-handoff-analysis')).toHaveTextContent(
+      /full timing, strategy & story ready/i,
+    )
+  })
+
+  it('retains the last snapshot with a disconnected warning (not settling) on a feed drop', async () => {
+    // is_live=false but the retained snapshot has a NON-terminal SessionStatus:
+    // the FIA feed dropped while the session was still active.
+    renderPage(
+      {
+        is_live: false,
+        data: null,
+        last_snapshot: { ...raceSnapshot, SessionStatus: 'Started' },
+        last_snapshot_at: '2026-07-05T15:30:00Z',
+      },
+      weekendContext('pending'),
+    )
+
+    expect(await screen.findByTestId('live-disconnected-strip')).toHaveTextContent(
+      /showing the last live data/i,
+    )
+    expect(screen.getByTestId('live-page')).toHaveAttribute('data-phase', 'disconnected')
+    // The retained live tower stays visible; we never fell into settling/archive.
+    expect(screen.getByText('Timing Tower')).toBeInTheDocument()
+    expect(screen.queryByTestId('live-settling')).not.toBeInTheDocument()
+    expect(screen.queryByTestId('live-archive-strip')).not.toBeInTheDocument()
+    // SSE may still be open (MockEventSource opens) — health must not say healthy.
+    await waitFor(() =>
+      expect(screen.getByTestId('live-feed-health')).toHaveTextContent(/reconnecting/i),
+    )
+    expect(screen.getByTestId('live-feed-health')).not.toHaveTextContent(/feed healthy/i)
+  })
+
+  it('keeps the settled snapshot behind an explicit read-only archive action', async () => {
+    renderPage(
+      {
+        is_live: false,
+        data: null,
+        last_snapshot: { ...raceSnapshot, SessionStatus: 'Finished' },
+        last_positions: { '1': { x: 10, y: 20, z: 0, status: 'OnTrack' } },
+        last_snapshot_at: '2026-07-05T16:02:00Z',
+      },
+      weekendContext('complete'),
+    )
+
+    // Settling first — the tower is hidden until the user opens the archive.
+    await screen.findByTestId('live-settling')
     expect(screen.queryByText('Timing Tower')).not.toBeInTheDocument()
 
-    fireEvent.click(screen.getByRole('button', { name: /view last session/i }))
+    fireEvent.click(screen.getByTestId('live-handoff-archive'))
 
-    await waitFor(() => {
-      expect(screen.getByTestId('live-archive-strip')).toHaveTextContent('Archived snapshot')
-    })
+    await waitFor(() =>
+      expect(screen.getByTestId('live-archive-strip')).toHaveTextContent(/read-only/i),
+    )
     expect(screen.getByText('Timing Tower')).toBeInTheDocument()
-    expect(screen.getAllByText('VER').length).toBeGreaterThan(0)
+    // Archive presents its read-only, timestamped chrome — never LIVE.
     expect(screen.getByText('archive')).toBeInTheDocument()
+    expect(screen.queryByText('LIVE SESSION')).not.toBeInTheDocument()
   })
 
-  it('does not show the archive action when no snapshot is retained', async () => {
-    renderPage({ is_live: false, data: null })
+  it('shows inactive handoff when nothing is live or retained', async () => {
+    renderPage(
+      { is_live: false, data: null },
+      {
+        temporal_state: 'between_weekends',
+        next_session: {
+          session: {
+            session_key: 21,
+            session_name: 'Practice 1',
+            session_type: 'Practice 1',
+            meeting_key: 2,
+            date_start: '2026-07-17T09:00:00Z',
+            date_end: '2026-07-17T10:00:00Z',
+            gmt_offset: '',
+          },
+          availability: {
+            schedule: 'available',
+            live_transport: 'unknown',
+            live_session: 'inactive',
+            archive: 'unavailable',
+            local_analysis: 'not_applicable',
+            freshness: 'fresh',
+            limitations: [],
+          },
+        },
+        championship_round: 2,
+        total_championship_rounds: 24,
+      },
+    )
 
-    expect(await screen.findByTestId('live-empty')).toHaveTextContent('No live session active')
-    expect(screen.queryByRole('button', { name: /view last session/i })).not.toBeInTheDocument()
+    expect(await screen.findByTestId('live-inactive')).toBeInTheDocument()
+    expect(screen.getByTestId('live-page')).toHaveAttribute('data-phase', 'inactive')
+    await waitFor(() =>
+      expect(screen.getByTestId('live-handoff-next')).toHaveTextContent('Practice 1'),
+    )
   })
 
-  it('temporarily omits the track map while live GPS is unavailable', async () => {
-    renderPage({
+  it('clears fatal initial error once SSE supplies a live snapshot', async () => {
+    type Listener = (event: { data: string }) => void
+    class RecoveringEventSource {
+      onopen: (() => void) | null = null
+      onerror: (() => void) | null = null
+      private listeners = new Map<string, Listener[]>()
+      static latest: RecoveringEventSource | null = null
+      constructor() {
+        RecoveringEventSource.latest = this
+        setTimeout(() => this.onopen?.(), 0)
+      }
+      addEventListener(type: string, listener: Listener) {
+        const list = this.listeners.get(type) ?? []
+        list.push(listener)
+        this.listeners.set(type, list)
+      }
+      emit(type: string, data: unknown) {
+        for (const listener of this.listeners.get(type) ?? []) {
+          listener({ data: JSON.stringify(data) })
+        }
+      }
+      close() {}
+    }
+
+    Object.defineProperty(window, 'EventSource', {
+      value: RecoveringEventSource,
+      writable: true,
+      configurable: true,
+    })
+
+    mockFetchLiveState.mockRejectedValue(new Error('API 503: live state unavailable'))
+    mockFetchLiveTrackOutline.mockResolvedValue({
+      circuit_key: 1,
+      points: [],
+      bounds: { minX: 0, maxX: 1, minY: 0, maxY: 1 },
+    })
+    mockFetchWeekendContext.mockResolvedValue({
+      temporal_state: 'no_season',
+      championship_round: 0,
+      total_championship_rounds: 0,
+    })
+
+    render(
+      <QueryClientProvider
+        client={new QueryClient({ defaultOptions: { queries: { retry: false } } })}
+      >
+        <LiveTimingPage />
+      </QueryClientProvider>,
+    )
+
+    expect(await screen.findByTestId('live-initial-error')).toBeInTheDocument()
+    expect(screen.getByText(/Live timing unavailable/i)).toBeInTheDocument()
+
+    await act(async () => {
+      RecoveringEventSource.latest?.emit('snapshot', {
         is_live: true,
-      data: { ...archivedSnapshot, SessionStatus: 'Started' },
+        data: raceSnapshot,
+      })
     })
 
-    expect(await screen.findByText('Timing Tower')).toBeInTheDocument()
-    expect(screen.queryByText('Track Map')).not.toBeInTheDocument()
-    expect(mockFetchLiveTrackOutline).not.toHaveBeenCalled()
+    await waitFor(() => expect(screen.getByText('Timing Tower')).toBeInTheDocument())
+    expect(screen.queryByTestId('live-initial-error')).not.toBeInTheDocument()
+    expect(screen.getByTestId('live-page')).toHaveAttribute('data-phase', 'live')
+    expect(screen.queryByText(/Live timing unavailable/i)).not.toBeInTheDocument()
+  })
+
+  it('clears fatal initial error when SSE reports authoritative inactive null state', async () => {
+    type Listener = (event: { data: string }) => void
+    class InactiveEventSource {
+      onopen: (() => void) | null = null
+      onerror: (() => void) | null = null
+      private listeners = new Map<string, Listener[]>()
+      static latest: InactiveEventSource | null = null
+      constructor() {
+        InactiveEventSource.latest = this
+        setTimeout(() => this.onopen?.(), 0)
+      }
+      addEventListener(type: string, listener: Listener) {
+        const list = this.listeners.get(type) ?? []
+        list.push(listener)
+        this.listeners.set(type, list)
+      }
+      emit(type: string, data: unknown) {
+        for (const listener of this.listeners.get(type) ?? []) {
+          listener({ data: JSON.stringify(data) })
+        }
+      }
+      close() {}
+    }
+
+    Object.defineProperty(window, 'EventSource', {
+      value: InactiveEventSource,
+      writable: true,
+      configurable: true,
+    })
+
+    mockFetchLiveState.mockRejectedValue(new Error('API 503: live state unavailable'))
+    mockFetchLiveTrackOutline.mockResolvedValue({
+      circuit_key: 1,
+      points: [],
+      bounds: { minX: 0, maxX: 1, minY: 0, maxY: 1 },
+    })
+    mockFetchWeekendContext.mockResolvedValue({
+      temporal_state: 'between_weekends',
+      championship_round: 5,
+      total_championship_rounds: 24,
+      season: 2026,
+    })
+
+    render(
+      <QueryClientProvider
+        client={new QueryClient({ defaultOptions: { queries: { retry: false } } })}
+      >
+        <LiveTimingPage />
+      </QueryClientProvider>,
+    )
+
+    expect(await screen.findByTestId('live-initial-error')).toBeInTheDocument()
+
+    await act(async () => {
+      InactiveEventSource.latest?.emit('snapshot', {
+        is_live: false,
+        data: null,
+        last_snapshot: null,
+      })
+    })
+
+    await waitFor(() => expect(screen.getByTestId('live-inactive')).toBeInTheDocument())
+    expect(screen.queryByTestId('live-initial-error')).not.toBeInTheDocument()
+    expect(screen.queryByText(/Live timing unavailable/i)).not.toBeInTheDocument()
+    expect(screen.getByTestId('live-page')).toHaveAttribute('data-phase', 'inactive')
+    expect(screen.queryByText('Timing Tower')).not.toBeInTheDocument()
+  })
+
+  it('keeps bounded initial error + Retry when no stream data arrives', async () => {
+    mockFetchLiveState.mockRejectedValue(new Error('API 503: live state unavailable'))
+    mockFetchLiveTrackOutline.mockResolvedValue({
+      circuit_key: 1,
+      points: [],
+      bounds: { minX: 0, maxX: 1, minY: 0, maxY: 1 },
+    })
+    mockFetchWeekendContext.mockResolvedValue({
+      temporal_state: 'no_season',
+      championship_round: 0,
+      total_championship_rounds: 0,
+    })
+
+    render(
+      <QueryClientProvider
+        client={new QueryClient({ defaultOptions: { queries: { retry: false } } })}
+      >
+        <LiveTimingPage />
+      </QueryClientProvider>,
+    )
+
+    expect(await screen.findByTestId('live-initial-error')).toBeInTheDocument()
+    expect(screen.getByRole('button', { name: 'Retry' })).toBeEnabled()
+    expect(screen.queryByText('Timing Tower')).not.toBeInTheDocument()
   })
 })

frontend/src/test/LocalDataNavigator.test.tsx

@@ -125,7 +125,7 @@ describe('LocalDataNavigator', () => {
 
     expect(await screen.findByTestId('local-nav')).toBeInTheDocument()
     await waitFor(() => {
-      expect(mockFetchLocalMeetings).toHaveBeenCalledWith(2025)
+      expect(mockFetchLocalMeetings).toHaveBeenCalledWith(2025, expect.any(AbortSignal))
     })
     expect(screen.getByText('Monaco')).toBeInTheDocument()
   })

frontend/src/test/Nav.test.tsx

@@ -0,0 +1,67 @@
+import { describe, it, expect } from 'vitest'
+import { render, screen, waitFor, within } from '@testing-library/react'
+import {
+  Outlet,
+  RouterProvider,
+  createRouter,
+  createRootRoute,
+  createRoute,
+  createMemoryHistory,
+} from '@tanstack/react-router'
+import { Nav } from '../components/Nav'
+
+function renderNav() {
+  const rootRoute = createRootRoute({
+    component: () => (
+      <>
+        <Nav />
+        <Outlet />
+      </>
+    ),
+  })
+  const stub = (p: string, id: string) =>
+    createRoute({ getParentRoute: () => rootRoute, path: p, component: () => <div data-testid={id} /> })
+  const router = createRouter({
+    routeTree: rootRoute.addChildren([
+      stub('/', 'home'),
+      stub('/championship', 'championship'),
+      stub('/briefing', 'briefing'),
+      stub('/explore', 'explore'),
+      stub('/admin', 'admin'),
+    ]),
+    history: createMemoryHistory({ initialEntries: ['/'] }),
+  })
+  return render(<RouterProvider router={router} />)
+}
+
+const DESTINATIONS = ['Weekend', 'Championship', 'Briefing', 'Explore']
+
+describe('Nav — one primary navigation system per breakpoint', () => {
+  it('exposes exactly two Primary landmarks (one per breakpoint), never more', async () => {
+    renderNav()
+    await waitFor(() => expect(screen.getAllByRole('navigation', { name: 'Primary' })).toHaveLength(2))
+  })
+
+  it('every Primary landmark contains all four destinations', async () => {
+    renderNav()
+    await waitFor(() => expect(screen.getAllByRole('navigation', { name: 'Primary' }).length).toBe(2))
+    const primaries = screen.getAllByRole('navigation', { name: 'Primary' })
+    for (const nav of primaries) {
+      for (const label of DESTINATIONS) {
+        expect(within(nav).getByRole('link', { name: new RegExp(`^${label}$`) })).toBeInTheDocument()
+      }
+    }
+  })
+
+  it('keeps Admin out of every Primary landmark (operator utility only)', async () => {
+    renderNav()
+    await waitFor(() => expect(screen.getAllByRole('navigation', { name: 'Primary' }).length).toBe(2))
+    const primaries = screen.getAllByRole('navigation', { name: 'Primary' })
+    for (const nav of primaries) {
+      expect(within(nav).queryByRole('link', { name: /Admin/i })).not.toBeInTheDocument()
+    }
+    // Admin lives in the operator utilities toolbar.
+    const toolbar = screen.getByRole('toolbar', { name: 'Operator utilities' })
+    expect(within(toolbar).getByRole('link', { name: /Admin/i })).toBeInTheDocument()
+  })
+})

frontend/src/test/RaceHubPage.test.tsx

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
 import { render, screen, waitFor, fireEvent } from '@testing-library/react'
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
 import {
@@ -9,21 +9,38 @@ import {
   createRoute,
 } from '@tanstack/react-router'
 import { RaceHubPage } from '../pages/RaceHubPage'
-import type { DatasetInfo, Meeting, RaceHub, Session, Weekend } from '../types'
+import type {
+  DatasetInfo,
+  Meeting,
+  RaceHub,
+  Session,
+  Weekend,
+  WeekendContext,
+} from '../types'
 
 vi.mock('../api', () => ({
   fetchRaceHub: vi.fn(),
   fetchSeasons: vi.fn(),
   fetchLocalMeetings: vi.fn(),
   fetchWeekend: vi.fn(),
+  fetchWeekendContext: vi.fn(),
 }))
 
-import { fetchRaceHub, fetchSeasons, fetchLocalMeetings, fetchWeekend } from '../api'
+import {
+  fetchRaceHub,
+  fetchSeasons,
+  fetchLocalMeetings,
+  fetchWeekend,
+  fetchWeekendContext,
+} from '../api'
 
 const mockFetchRaceHub = vi.mocked(fetchRaceHub)
 const mockFetchSeasons = vi.mocked(fetchSeasons)
 const mockFetchLocalMeetings = vi.mocked(fetchLocalMeetings)
 const mockFetchWeekend = vi.mocked(fetchWeekend)
+const mockFetchWeekendContext = vi.mocked(fetchWeekendContext)
+
+const NOW = new Date('2025-06-01T00:00:00Z')
 
 const meeting: Meeting = {
   meeting_key: 1229,
@@ -59,6 +76,16 @@ const qualSession: Session = {
   gmt_offset: '02:00:00',
 }
 
+const futureSession: Session = {
+  session_key: 9600,
+  session_name: 'Race',
+  session_type: 'Race',
+  meeting_key: 1300,
+  date_start: '2099-05-25T13:00:00+00:00',
+  date_end: '2099-05-25T15:00:00+00:00',
+  gmt_offset: '02:00:00',
+}
+
 const fullDatasets: Record<string, DatasetInfo> = {
   meeting: { status: 'available', source: 'local', count: 1 },
   session: { status: 'available', source: 'local', count: 1 },
@@ -169,6 +196,41 @@ const weekend: Weekend = {
   ],
 }
 
+const weekendContext: WeekendContext = {
+  season: 2025,
+  temporal_state: 'post_weekend',
+  focus_meeting: meeting,
+  previous_meeting: meeting,
+  default_analysis_session: {
+    session: raceSession,
+    meeting,
+    availability: {
+      schedule: 'available',
+      live_transport: 'unknown',
+      live_session: 'inactive',
+      archive: 'unavailable',
+      local_analysis: 'complete',
+      freshness: 'fresh',
+      limitations: [],
+    },
+  },
+  previous_completed_session: {
+    session: raceSession,
+    meeting,
+    availability: {
+      schedule: 'available',
+      live_transport: 'unknown',
+      live_session: 'inactive',
+      archive: 'unavailable',
+      local_analysis: 'complete',
+      freshness: 'fresh',
+      limitations: [],
+    },
+  },
+  championship_round: 8,
+  total_championship_rounds: 24,
+}
+
 function renderRaceHub(sessionKey: number) {
   const queryClient = new QueryClient({
     defaultOptions: { queries: { retry: false } },
@@ -181,6 +243,19 @@ function renderRaceHub(sessionKey: number) {
       </QueryClientProvider>
     ),
   })
+  const weekendRoute = createRoute({
+    getParentRoute: () => rootRoute,
+    path: '/',
+    validateSearch: (search: Record<string, unknown>) => {
+      const meetingKey = Number(search.meeting_key)
+      const sk = Number(search.session_key)
+      return {
+        ...(Number.isFinite(meetingKey) && meetingKey > 0 ? { meeting_key: meetingKey } : {}),
+        ...(Number.isFinite(sk) && sk > 0 ? { session_key: sk } : {}),
+      }
+    },
+    component: () => <div data-testid="weekend-stub" />,
+  })
   const raceHubRoute = createRoute({
     getParentRoute: () => rootRoute,
     path: '/race-hub',
@@ -194,11 +269,10 @@ function renderRaceHub(sessionKey: number) {
     },
   })
   const router = createRouter({
-    routeTree: rootRoute.addChildren([raceHubRoute]),
+    routeTree: rootRoute.addChildren([weekendRoute, raceHubRoute]),
     history: undefined,
   })
 
-  // Navigate to the URL before mounting
   router.navigate({ to: '/race-hub', search: sessionKey ? { session_key: sessionKey } : {} })
   return render(<RouterProvider router={router} />)
 }
@@ -206,10 +280,17 @@ function renderRaceHub(sessionKey: number) {
 describe('RaceHubPage', () => {
   beforeEach(() => {
     vi.clearAllMocks()
+    vi.useFakeTimers({ shouldAdvanceTime: true })
+    vi.setSystemTime(NOW)
     mockFetchSeasons.mockResolvedValue([2025])
     mockFetchLocalMeetings.mockResolvedValue([meeting])
     mockFetchWeekend.mockResolvedValue(weekend)
     mockFetchRaceHub.mockResolvedValue(raceHub)
+    mockFetchWeekendContext.mockResolvedValue(weekendContext)
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
   })
 
   it('renders the workspace identity band, session rail, and overview for a known session', async () => {
@@ -224,9 +305,9 @@ describe('RaceHubPage', () => {
     )
     expect(screen.getByTestId('rh-session-9471')).toBeInTheDocument()
 
-    // Overview is default
     expect(screen.getByTestId('rh-overview')).toBeInTheDocument()
     expect(screen.getByText('Winner')).toBeInTheDocument()
+    expect(screen.queryByText('Local Coverage')).not.toBeInTheDocument()
   })
 
   it('exposes Race Story sub-controls for classification, grid, and positions', async () => {
@@ -236,17 +317,43 @@ describe('RaceHubPage', () => {
     fireEvent.click(screen.getByRole('tab', { name: 'Race Story' }))
 
     expect(screen.getByText('VER')).toBeInTheDocument()
-    
   })
 
-  it('keeps Data Status accessible and free of inline CLI guidance', async () => {
+  it('keeps Diagnostics accessible behind a secondary action, free of inline CLI guidance', async () => {
     renderRaceHub(9472)
     await waitFor(() => expect(screen.getByTestId('race-hub')).toBeInTheDocument())
 
-    fireEvent.click(screen.getByRole('tab', { name: 'Data Status' }))
+    fireEvent.click(screen.getByRole('tab', { name: 'Diagnostics' }))
 
     expect(screen.getByTestId('rh-data-status')).toBeInTheDocument()
     expect(screen.queryByText(/ingest-session/i)).not.toBeInTheDocument()
+
+    expect(screen.queryByTestId('rh-dataset-strip')).not.toBeInTheDocument()
+    fireEvent.click(screen.getByTestId('rh-diagnostics-toggle'))
+    expect(screen.getByTestId('rh-dataset-strip')).toBeInTheDocument()
+  })
+
+  it('does not render the raw dataset strip before fan-facing content', async () => {
+    renderRaceHub(9472)
+    await waitFor(() => expect(screen.getByTestId('race-hub')).toBeInTheDocument())
+
+    expect(screen.getByTestId('rh-overview')).toBeInTheDocument()
+    expect(screen.queryByTestId('rh-dataset-strip')).not.toBeInTheDocument()
+  })
+
+  it('groups analysis navigation into Story, Analysis, and Data & Context', async () => {
+    renderRaceHub(9472)
+    await waitFor(() => expect(screen.getByTestId('race-hub')).toBeInTheDocument())
+
+    expect(screen.getByTestId('rh-tabgroup-story')).toBeInTheDocument()
+    expect(screen.getByTestId('rh-tabgroup-analysis')).toBeInTheDocument()
+    expect(screen.getByTestId('rh-tabgroup-context')).toBeInTheDocument()
+    expect(screen.getByRole('tab', { name: 'Overview' })).toBeInTheDocument()
+    expect(screen.getByRole('tab', { name: 'Strategy' })).toBeInTheDocument()
+    expect(screen.getByRole('tab', { name: 'Compare' })).toBeInTheDocument()
+    expect(screen.getByRole('tab', { name: 'Lap Data' })).toBeInTheDocument()
+    expect(screen.getByRole('tab', { name: 'Race Control' })).toBeInTheDocument()
+    expect(screen.getByRole('tab', { name: 'Diagnostics' })).toBeInTheDocument()
   })
 
   it('toggles the inline weekend switcher', async () => {
@@ -256,4 +363,214 @@ describe('RaceHubPage', () => {
     fireEvent.click(screen.getByTestId('rh-switch-weekend'))
     expect(await screen.findByTestId('rh-switcher')).toBeInTheDocument()
   })
+
+  it('resolves bare /race-hub through canonical Weekend Context default analysis', async () => {
+    mockFetchWeekendContext.mockResolvedValue({
+      ...weekendContext,
+      default_analysis_session: {
+        session: qualSession,
+        meeting,
+        availability: {
+          schedule: 'available',
+          live_transport: 'unknown',
+          live_session: 'inactive',
+          archive: 'unavailable',
+          local_analysis: 'complete',
+          freshness: 'fresh',
+          limitations: [],
+        },
+      },
+    })
+
+    renderRaceHub(0)
+
+    await waitFor(() => expect(mockFetchRaceHub).toHaveBeenCalledWith(9471, expect.any(AbortSignal)))
+    expect(mockFetchRaceHub).not.toHaveBeenCalledWith(9600, expect.anything())
+    expect(mockFetchRaceHub).not.toHaveBeenCalledWith(9600)
+  })
+
+  it('shows no-analysis fallback when Weekend Context has no default analysis', async () => {
+    mockFetchWeekendContext.mockResolvedValue({
+      ...weekendContext,
+      default_analysis_session: undefined,
+      previous_completed_session: undefined,
+    })
+
+    renderRaceHub(0)
+
+    await waitFor(() => expect(screen.getByTestId('race-hub-no-analysis')).toBeInTheDocument())
+    expect(mockFetchRaceHub).not.toHaveBeenCalled()
+  })
+
+  it('renders a pre-session view instead of empty analysis for a future session', async () => {
+    mockFetchRaceHub.mockResolvedValue({
+      ...raceHub,
+      session_key: 9600,
+      source: 'none',
+      session: futureSession,
+      meeting: { ...meeting, meeting_key: 1300 },
+      results: [],
+      starting_grid: [],
+      datasets: {},
+    })
+    mockFetchWeekend.mockResolvedValue({
+      source: 'none',
+      meeting_key: 1300,
+      meeting: { ...meeting, meeting_key: 1300 },
+      sessions: [{ session: futureSession, source: 'none', datasets: {} }],
+    })
+
+    renderRaceHub(9600)
+
+    await waitFor(() => expect(screen.getByTestId('race-hub')).toBeInTheDocument())
+    expect(await screen.findByTestId('rh-presession')).toBeInTheDocument()
+    expect(screen.queryByTestId('rh-overview')).not.toBeInTheDocument()
+    expect(screen.queryByText('Winner')).not.toBeInTheDocument()
+  })
+
+  it('renders a preparing view for a settling session with no local analysis', async () => {
+    mockFetchWeekend.mockResolvedValue({
+      ...weekend,
+      sessions: [
+        { session: raceSession, source: 'none', datasets: {} },
+      ],
+    })
+    mockFetchWeekendContext.mockResolvedValue({
+      ...weekendContext,
+      temporal_state: 'session_settling',
+      default_analysis_session: undefined,
+      previous_completed_session: {
+        session: raceSession,
+        meeting,
+        availability: {
+          schedule: 'available',
+          live_transport: 'unknown',
+          live_session: 'inactive',
+          archive: 'unavailable',
+          local_analysis: 'pending',
+          freshness: 'fresh',
+          limitations: [],
+        },
+      },
+    })
+    mockFetchRaceHub.mockResolvedValue({
+      ...raceHub,
+      source: 'none',
+      results: [],
+      starting_grid: [],
+      datasets: {},
+    })
+
+    renderRaceHub(9472)
+
+    await waitFor(() => expect(screen.getByTestId('rh-preparing')).toBeInTheDocument())
+    expect(screen.queryByTestId('rh-overview')).not.toBeInTheDocument()
+  })
+
+  it('renders unavailable distinctly from request errors', async () => {
+    mockFetchWeekend.mockResolvedValue({
+      ...weekend,
+      sessions: [{ session: raceSession, source: 'none', datasets: {} }],
+    })
+    mockFetchWeekendContext.mockResolvedValue({
+      ...weekendContext,
+      previous_completed_session: {
+        session: raceSession,
+        meeting,
+        availability: {
+          schedule: 'available',
+          live_transport: 'unknown',
+          live_session: 'inactive',
+          archive: 'unavailable',
+          local_analysis: 'unavailable',
+          freshness: 'stale',
+          limitations: ['analysis_blocked'],
+        },
+      },
+      default_analysis_session: {
+        session: raceSession,
+        meeting,
+        availability: {
+          schedule: 'available',
+          live_transport: 'unknown',
+          live_session: 'inactive',
+          archive: 'unavailable',
+          local_analysis: 'unavailable',
+          freshness: 'stale',
+          limitations: ['analysis_blocked'],
+        },
+      },
+    })
+    mockFetchRaceHub.mockResolvedValue({
+      ...raceHub,
+      source: 'none',
+      results: [],
+      datasets: {},
+    })
+
+    renderRaceHub(9472)
+
+    await waitFor(() => expect(screen.getByTestId('rh-unavailable')).toBeInTheDocument())
+    expect(screen.queryByTestId('race-hub-error')).not.toBeInTheDocument()
+  })
+
+  it('labels a completed but partial session as Partial and keeps analysis', async () => {
+    mockFetchWeekend.mockResolvedValue({
+      ...weekend,
+      sessions: [
+        { session: qualSession, source: 'local', datasets: fullDatasets },
+        { session: raceSession, source: 'partial', datasets: { drivers: fullDatasets.drivers } },
+      ],
+    })
+    mockFetchWeekendContext.mockResolvedValue({
+      ...weekendContext,
+      default_analysis_session: {
+        session: raceSession,
+        meeting,
+        availability: {
+          schedule: 'available',
+          live_transport: 'unknown',
+          live_session: 'inactive',
+          archive: 'unavailable',
+          local_analysis: 'partial',
+          freshness: 'fresh',
+          limitations: [],
+        },
+      },
+    })
+
+    renderRaceHub(9472)
+
+    await waitFor(() => expect(screen.getByTestId('rh-active-state')).toBeInTheDocument())
+    expect(screen.getByTestId('rh-active-state')).toHaveTextContent('Partial')
+    expect(screen.getByTestId('rh-partial-banner')).toBeInTheDocument()
+    expect(screen.getByTestId('rh-overview')).toBeInTheDocument()
+  })
+
+  it('offers retry and back-to-Weekend on an error', async () => {
+    mockFetchRaceHub.mockRejectedValue(new Error('boom'))
+
+    renderRaceHub(9472)
+
+    await waitFor(() => expect(screen.getByTestId('race-hub-error')).toBeInTheDocument())
+    expect(screen.getByTestId('rh-retry')).toBeInTheDocument()
+    const back = screen.getByTestId('rh-back-weekend')
+    expect(back).toHaveAttribute('href', expect.stringMatching(/meeting_key=1229/))
+    expect(back).toHaveAttribute('href', expect.stringMatching(/session_key=9472/))
+    expect(back.getAttribute('href')).toMatch(/^\//)
+
+    mockFetchRaceHub.mockResolvedValue(raceHub)
+    fireEvent.click(screen.getByTestId('rh-retry'))
+    await waitFor(() => expect(screen.getByTestId('race-hub')).toBeInTheDocument())
+  })
+
+  it('exposes a Back to Weekend link that carries meeting and session context', async () => {
+    renderRaceHub(9472)
+
+    await waitFor(() => expect(screen.getByTestId('race-hub')).toBeInTheDocument())
+    const back = screen.getByRole('link', { name: 'Back to Weekend' })
+    expect(back).toHaveAttribute('data-testid', 'rh-back-weekend')
+    expect(back).toHaveAttribute('href', expect.stringMatching(/meeting_key=1229/))
+    expect(back).toHaveAttribute('href', expect.stringMatching(/session_key=9472/))
+  })
 })

frontend/src/test/RacePreviewPage.test.tsx

@@ -1,8 +1,10 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { render, screen, waitFor } from '@testing-library/react'
+import { render, screen, waitFor, fireEvent } from '@testing-library/react'
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
 import { RouterProvider, createRouter, createRootRoute, createRoute } from '@tanstack/react-router'
+import { rememberResponseAvailability } from '../lib/fetch'
 import { RacePreviewPage } from '../pages/RacePreviewPage'
+import { ApiError } from '../lib/fetch'
 import type { ChampHubDriver, ChampionshipHub, EnrichedGrid, EnrichedResult, Meeting, Session, TrackOutline } from '../types'
 
 vi.mock('../api', () => ({
@@ -109,6 +111,7 @@ const hubDriver = (over: Partial<ChampHubDriver>): ChampHubDriver => ({
   poles: 4,
   form: [25],
   cumulative: [200],
+  round_positions: [1],
   teammate_wins: 9,
   teammate_losses: 1,
   ...over,
@@ -173,16 +176,22 @@ const outline: TrackOutline = {
   bounds: { minX: 0, maxX: 1, minY: 0, maxY: 1 },
 }
 
-function renderPage() {
+function renderPage(props?: {
+  meeting?: Meeting
+  season?: number
+  embedded?: boolean
+  shellAvailability?: 'local' | 'partial' | 'stale' | 'archive' | 'limited' | 'missing' | null
+}) {
   const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+  const Page = () => <RacePreviewPage {...props} />
   const rootRoute = createRootRoute({
     component: () => (
       <QueryClientProvider client={queryClient}>
-        <RacePreviewPage />
+        <Page />
       </QueryClientProvider>
     ),
   })
-  const indexRoute = createRoute({ getParentRoute: () => rootRoute, path: '/', component: RacePreviewPage })
+  const indexRoute = createRoute({ getParentRoute: () => rootRoute, path: '/', component: Page })
   const router = createRouter({ routeTree: rootRoute.addChildren([indexRoute]) })
   return render(<RouterProvider router={router} />)
 }
@@ -273,4 +282,145 @@ describe('RacePreviewPage', () => {
       expect(screen.getByTestId('preview-last-year-card')).toHaveTextContent('First time on the calendar')
     })
   })
+
+  it('uses canonical meeting identity when embedded and skips seasons/meetings selection', async () => {
+    mockFetchSessions.mockImplementation(async (meetingKey: number) => {
+      if (meetingKey === 100) return sessions
+      if (meetingKey === 90) return [priorRaceSession]
+      return []
+    })
+    mockFetchMeetings.mockImplementation(async (year: number) => {
+      if (year === 2098) return [priorMeeting]
+      return []
+    })
+
+    renderPage({ meeting: upcomingMeeting, season: 2099, embedded: true, shellAvailability: 'partial' })
+
+    await waitFor(() => expect(screen.getByTestId('preview-page')).toBeInTheDocument())
+    expect(screen.getByTestId('preview-page')).toHaveAttribute('data-meeting-key', '100')
+    expect(screen.getByTestId('preview-page')).toHaveAttribute('data-embedded', 'true')
+    expect(mockFetchSeasons).not.toHaveBeenCalled()
+    // Current-year meetings selection is skipped; prior-year lookup may still run.
+    expect(mockFetchMeetings).not.toHaveBeenCalledWith(2099, expect.anything(), expect.anything())
+    expect(mockFetchSessions).toHaveBeenCalledWith(100, 'auto', expect.anything())
+    expect(screen.queryByTestId('preview-header')).not.toBeInTheDocument()
+  })
+
+  it('dedupes an equivalent shell notice but shows distinct Preview freshness', async () => {
+    mockFetchSessions.mockImplementation(async (meetingKey: number) => {
+      if (meetingKey === 100) return sessions
+      if (meetingKey === 90) return [priorRaceSession]
+      return []
+    })
+    mockFetchMeetings.mockImplementation(async (year: number) => {
+      if (year === 2098) return [priorMeeting]
+      return []
+    })
+
+    const staleHub = { ...hub }
+    rememberResponseAvailability(staleHub, { source: 'openf1', freshness: 'stale' })
+    mockFetchChampionshipHub.mockResolvedValue(staleHub)
+
+    const distinct = renderPage({
+      meeting: upcomingMeeting,
+      season: 2099,
+      embedded: true,
+      shellAvailability: 'partial',
+    })
+    await waitFor(() => expect(screen.getByTestId('preview-data-notice')).toHaveTextContent(/Stale/i))
+    distinct.unmount()
+
+    const partialHub = { ...hub }
+    rememberResponseAvailability(partialHub, { source: 'openf1', freshness: 'partial' })
+    mockFetchChampionshipHub.mockResolvedValue(partialHub)
+
+    renderPage({
+      meeting: upcomingMeeting,
+      season: 2099,
+      embedded: true,
+      shellAvailability: 'partial',
+    })
+    await waitFor(() => expect(screen.getByTestId('preview-page')).toBeInTheDocument())
+    expect(screen.queryByTestId('preview-data-notice')).not.toBeInTheDocument()
+  })
+
+  it('preserves Stale/Partial over routine Championship Local from conflicting sources', async () => {
+    mockFetchSessions.mockImplementation(async (meetingKey: number) => {
+      if (meetingKey === 100) {
+        const payload = [...sessions]
+        rememberResponseAvailability(payload, { source: 'openf1', freshness: 'stale' })
+        return payload
+      }
+      if (meetingKey === 90) return [priorRaceSession]
+      return []
+    })
+    mockFetchMeetings.mockImplementation(async (year: number) => {
+      if (year === 2098) return [priorMeeting]
+      return []
+    })
+
+    const localHub = { ...hub }
+    rememberResponseAvailability(localHub, { source: 'local', freshness: 'local' })
+    mockFetchChampionshipHub.mockResolvedValue(localHub)
+
+    renderPage({ meeting: upcomingMeeting, season: 2099 })
+
+    await waitFor(() => expect(screen.getByTestId('preview-data-notice')).toHaveTextContent(/Stale/i))
+    expect(screen.getByTestId('preview-title-fight-card')).toBeInTheDocument()
+    expect(screen.getByTestId('preview-schedule')).toHaveTextContent('FP1')
+  })
+
+  it('shows sanitized sessions failure with Retry that refetches once', async () => {
+    let sessionCalls = 0
+    mockFetchSessions.mockImplementation(async (meetingKey: number) => {
+      if (meetingKey !== 100) return [priorRaceSession]
+      sessionCalls += 1
+      if (sessionCalls === 1) {
+        throw new ApiError('http', 'API 500: sessions boom', { status: 500 })
+      }
+      return sessions
+    })
+    mockFetchMeetings.mockImplementation(async (year: number) => {
+      if (year === 2098) return [priorMeeting]
+      return []
+    })
+
+    renderPage({ meeting: upcomingMeeting, season: 2099, embedded: true })
+
+    await waitFor(() => expect(screen.getByTestId('preview-sessions-error')).toBeInTheDocument())
+    expect(screen.getByTestId('preview-sessions-error')).not.toHaveTextContent(/API 500|sessions boom/i)
+    expect(screen.getByTestId('preview-page')).toBeInTheDocument()
+
+    const retry = screen.getByTestId('preview-sessions-retry')
+    fireEvent.click(retry)
+    fireEvent.click(retry)
+
+    await waitFor(() => expect(screen.getByTestId('preview-schedule')).toHaveTextContent('FP1'))
+    expect(sessionCalls).toBe(2)
+    expect(screen.queryByTestId('preview-sessions-error')).not.toBeInTheDocument()
+  })
+
+  it('sanitizes raw HTTP errors and offers a guarded keyboard Retry', async () => {
+    mockFetchSeasons.mockRejectedValue(
+      new ApiError('http', 'API 500: Internal Server Error', { status: 500 }),
+    )
+
+    renderPage()
+
+    await waitFor(() => expect(screen.getByTestId('preview-error')).toBeInTheDocument())
+    expect(screen.getByTestId('preview-error')).not.toHaveTextContent(/API 500|Internal Server Error/i)
+    const retry = screen.getByRole('button', { name: 'Retry' })
+    expect(retry).toBeEnabled()
+
+    mockFetchSeasons.mockResolvedValue([2099])
+    mockFetchMeetings.mockResolvedValue([upcomingMeeting])
+    mockFetchSessions.mockResolvedValue(sessions)
+
+    fireEvent.click(retry)
+    fireEvent.click(retry)
+
+    await waitFor(() => expect(screen.getByTestId('preview-page')).toBeInTheDocument())
+    // Guarded: one in-flight refetch despite double click while fetching.
+    expect(mockFetchSeasons.mock.calls.length).toBeGreaterThanOrEqual(2)
+  })
 })

frontend/src/test/RaceStoryCanvas.test.tsx

@@ -2,7 +2,7 @@ import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
 import { fireEvent, render, screen, waitFor } from '@testing-library/react'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { RaceStoryCanvas } from '../components/RaceStoryCanvas'
-import type { RaceHub, ReplayFramesResponse, TrackOutline } from '../types'
+import type { Chapter, RaceHub, ReplayFramesResponse, TrackOutline } from '../types'
 
 vi.mock('../api', () => ({
   fetchReplayFrames: vi.fn(),
@@ -28,9 +28,35 @@ const replay: ReplayFramesResponse = {
   session_key: 99,
   interval_ms: 5000,
   start_time: '2025-05-25T13:00:00Z',
-  frames: [{ t: 0, cars: { '1': { x: 10, y: 20 } } }],
+  frames: [
+    { t: 0, cars: { '1': { x: 10, y: 20 } } },
+    { t: 5000, cars: { '1': { x: 50, y: 50 } } },
+  ],
 }
 
+const chapters: Chapter[] = [
+  {
+    kind: 'start',
+    title: 'Start',
+    headline: 'Lights out',
+    start_lap: 1,
+    end_lap: 1,
+    start_time: '2025-05-25T13:00:00Z',
+    end_time: '2025-05-25T13:01:00Z',
+    driver_numbers: [],
+  },
+  {
+    kind: 'safety_car',
+    title: 'Safety Car',
+    headline: 'Incident brings out the Safety Car',
+    start_lap: 2,
+    end_lap: 2,
+    start_time: '2025-05-25T13:05:00Z',
+    end_time: '2025-05-25T13:05:00Z',
+    driver_numbers: [],
+  },
+]
+
 const raceHub: RaceHub = {
   source: 'local',
   session_key: 99,
@@ -103,14 +129,14 @@ const raceHub: RaceHub = {
   race_control: [],
   weather: [],
   laps: [],
-  chapters: [],
+  chapters,
 }
 
-function renderCanvas() {
+function renderCanvas(overrides: Partial<RaceHub> = {}) {
   const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
   return render(
     <QueryClientProvider client={queryClient}>
-      <RaceStoryCanvas data={raceHub} />
+      <RaceStoryCanvas data={{ ...raceHub, ...overrides }} />
     </QueryClientProvider>,
   )
 }
@@ -122,14 +148,153 @@ describe('RaceStoryCanvas replay map', () => {
     mockFetchTrackOutline.mockResolvedValue(outline)
   })
 
-  it('fetches replay frames lazily when the map panel opens', async () => {
+  it('probes replay frames on mount and opens the map when data is available', async () => {
     renderCanvas()
 
-    expect(mockFetchReplayFrames).not.toHaveBeenCalled()
-    fireEvent.click(screen.getByRole('button', { name: 'Map' }))
-
     await waitFor(() => expect(mockFetchReplayFrames).toHaveBeenCalledWith(99, 5000))
     expect(mockFetchTrackOutline).toHaveBeenCalledWith(1, 2025)
+
+    const mapToggle = await screen.findByTestId('replay-map-toggle')
+    fireEvent.click(mapToggle)
+
     expect(await screen.findByTestId('replay-track-map')).toBeInTheDocument()
+    expect(screen.getByTestId('replay-map-slot')).toBeInTheDocument()
+  })
+
+  it('hides the map toggle when replay frames are unavailable', async () => {
+    mockFetchReplayFrames.mockResolvedValue({ ...replay, frames: [] })
+    renderCanvas()
+
+    await waitFor(() => expect(mockFetchReplayFrames).toHaveBeenCalled())
+    await waitFor(() => expect(screen.queryByTestId('replay-map-toggle')).not.toBeInTheDocument())
+  })
+
+  it('uses full-width chart layout when the map is closed', async () => {
+    renderCanvas()
+
+    await waitFor(() => expect(mockFetchReplayFrames).toHaveBeenCalled())
+    const chart = screen.getByTestId('position-chart')
+    expect(chart).toHaveClass('rs-chart-container--full')
+    expect(screen.queryByTestId('replay-map-slot')).not.toBeInTheDocument()
+    expect(document.querySelector('.rs-replay-shell--split')).not.toBeInTheDocument()
+  })
+
+  it('uses lap timing rather than pre-race position samples for the chart scale', () => {
+    const laps = Array.from({ length: 20 }, (_, index) => ({
+      session_key: 99,
+      driver_number: 1,
+      meeting_key: 1,
+      lap_number: index + 1,
+      date_start: `2025-05-25T13:${String(index).padStart(2, '0')}:00Z`,
+      lap_duration: 60,
+      is_pit_out_lap: false,
+    }))
+
+    renderCanvas({
+      results: [{ ...raceHub.results[0], number_of_laps: 20 }],
+      laps,
+      positions: [
+        { session_key: 99, driver_number: 1, meeting_key: 1, date: '2025-05-25T12:00:00Z', position: 1 },
+        { session_key: 99, driver_number: 1, meeting_key: 1, date: '2025-05-25T13:20:00Z', position: 1 },
+      ],
+    })
+
+    // L10 is the end of the tenth 60s lap, exactly halfway through the race.
+    const lapTenLabel = screen.getByText('L10')
+    expect(lapTenLabel.previousElementSibling).toHaveAttribute('x1', '316')
+    // The pre-race position is retained as the starting grid at the left edge.
+    expect(document.querySelector('.rs-driver-line')).toHaveAttribute('points', '40,8 592,8 592,8')
+  })
+
+  it('maps cursor positions from rendered pixels to the SVG viewBox', () => {
+    renderCanvas()
+
+    const svg = document.querySelector('.rs-position-chart-svg')!
+    vi.spyOn(svg, 'getBoundingClientRect').mockReturnValue({
+      x: 0,
+      y: 0,
+      width: 1280,
+      height: 360,
+      top: 0,
+      right: 1280,
+      bottom: 360,
+      left: 0,
+      toJSON: () => ({}),
+    })
+
+    const pointerMove = new Event('pointermove', { bubbles: true })
+    Object.defineProperty(pointerMove, 'clientX', { value: 640 })
+    fireEvent(screen.getByTestId('position-chart-interaction'), pointerMove)
+
+    // 640px is the middle of a 1280px rendered chart, which is x=320 in its 640-unit viewBox.
+    expect(document.querySelector('.rs-playhead')).toHaveAttribute('x1', '320')
+  })
+
+  it('syncs active chapter highlight when a chapter card is clicked', async () => {
+    renderCanvas()
+
+    fireEvent.click(screen.getByTestId('chapter-card-1'))
+    await waitFor(() => expect(screen.getByTestId('chapter-card-1')).toHaveClass('active'))
+    expect(screen.getByTestId('chapter-card-0')).not.toHaveClass('active')
+  })
+
+  it('highlights out-of-window chapters after click (clamped scrub + selection)', async () => {
+    // Position samples start at 13:05; start chapter ends at 13:01 — outside the window.
+    renderCanvas({
+      positions: [
+        { session_key: 99, driver_number: 1, meeting_key: 1, date: '2025-05-25T13:05:00Z', position: 1 },
+        { session_key: 99, driver_number: 1, meeting_key: 1, date: '2025-05-25T13:10:00Z', position: 1 },
+      ],
+      chapters: [
+        {
+          kind: 'start',
+          title: 'Start',
+          headline: 'Lights out before samples',
+          start_lap: 1,
+          end_lap: 1,
+          start_time: '2025-05-25T13:00:00Z',
+          end_time: '2025-05-25T13:01:00Z',
+          driver_numbers: [],
+        },
+        {
+          kind: 'finish',
+          title: 'Finish',
+          headline: 'Flag after samples',
+          start_lap: 78,
+          end_lap: 78,
+          start_time: '2025-05-25T13:20:00Z',
+          end_time: '2025-05-25T13:21:00Z',
+          driver_numbers: [],
+        },
+      ],
+    })
+
+    fireEvent.click(screen.getByTestId('chapter-card-0'))
+    await waitFor(() => expect(screen.getByTestId('chapter-card-0')).toHaveClass('active'))
+    expect(screen.getByTestId('chapter-card-1')).not.toHaveClass('active')
+
+    fireEvent.click(screen.getByTestId('chapter-card-1'))
+    await waitFor(() => expect(screen.getByTestId('chapter-card-1')).toHaveClass('active'))
+    expect(screen.getByTestId('chapter-card-0')).not.toHaveClass('active')
+  })
+
+  it('exposes the final running order outcome region with winner position', () => {
+    renderCanvas()
+
+    const outcome = screen.getByTestId('race-story-outcome')
+    expect(outcome).toHaveAttribute('aria-label', 'Final running order')
+    expect(outcome).toHaveTextContent('VER')
+    expect(outcome.querySelector('.rs-pos-col')).toHaveTextContent('1')
+  })
+
+  it('renders the empty-state card when positions are unavailable', () => {
+    renderCanvas({
+      datasets: { positions: { status: 'missing', source: 'local', count: 0 } },
+      positions: [],
+      chapters: [],
+    })
+
+    expect(screen.getByTestId('race-story-no-positions')).toBeInTheDocument()
+    expect(screen.getByText('Lap-by-lap positions not available')).toBeInTheDocument()
   })
 })

frontend/src/test/ReplayTrackMap.test.tsx

@@ -44,9 +44,10 @@ const results: EnrichedResult[] = [
 ]
 
 describe('ReplayTrackMap', () => {
-  it('renders an empty state when replay frames are missing', () => {
+  it('renders an empty-state card when replay frames are missing', () => {
     render(<ReplayTrackMap outline={outline} replay={{ ...replay, frames: [] }} tMs={0} drivers={[]} results={results} />)
-    expect(screen.getByTestId('replay-track-map')).toHaveTextContent(/historical GPS unavailable/i)
+    expect(screen.getByTestId('replay-map-no-frames')).toBeInTheDocument()
+    expect(screen.getByText('Historical GPS unavailable')).toBeInTheDocument()
   })
 
   it('renders car labels from result metadata', () => {

frontend/src/test/RivalryCompare.test.tsx

@@ -0,0 +1,114 @@
+import { describe, it, expect } from 'vitest'
+import { render, screen, fireEvent } from '@testing-library/react'
+import { RivalryCompare } from '../components/RivalryCompare'
+import type { ChampHubDriver, ChampionshipHub } from '../types'
+
+function driver(over: Partial<ChampHubDriver>): ChampHubDriver {
+  return {
+    driver_number: 1,
+    name_acronym: 'VER',
+    full_name: 'Max Verstappen',
+    team_name: 'Red Bull',
+    team_colour: '3671c6',
+    points: 100,
+    position: 1,
+    wins: 2,
+    podiums: 3,
+    poles: 1,
+    form: [25, 18, 25],
+    cumulative: [25, 43, 68],
+    round_positions: [1, 2, 1],
+    teammate_wins: 3,
+    teammate_losses: 0,
+    ...over,
+  }
+}
+
+function makeHub(drivers: ChampHubDriver[]): ChampionshipHub {
+  return {
+    season: 2025,
+    round: 3,
+    total_rounds: 10,
+    rounds_left: 7,
+    last_race: 'Japan GP',
+    round_labels: ['R1', 'R2', 'R3'],
+    drivers,
+    teams: [],
+  }
+}
+
+const hub = makeHub([
+  driver({}),
+  driver({
+    driver_number: 4,
+    name_acronym: 'NOR',
+    full_name: 'Lando Norris',
+    team_name: 'McLaren',
+    team_colour: 'ff8000',
+    points: 90,
+    position: 2,
+    cumulative: [18, 43, 61],
+    round_positions: [2, 1, 2],
+  }),
+  driver({
+    driver_number: 16,
+    name_acronym: 'LEC',
+    full_name: 'Charles Leclerc',
+    team_name: 'Ferrari',
+    team_colour: 'e8002d',
+    points: 50,
+    position: 3,
+    cumulative: [15, 28, 40],
+    round_positions: [3, 0, 3],
+  }),
+])
+
+describe('RivalryCompare', () => {
+  it('defaults to the top two drivers and shows the H2H score', () => {
+    render(<RivalryCompare hub={hub} />)
+
+    expect(screen.getByTestId('champ-view-rivalry')).toBeInTheDocument()
+    expect(screen.getByTestId('rivalry-pick-a')).toHaveValue('1')
+    expect(screen.getByTestId('rivalry-pick-b')).toHaveValue('4')
+    // VER wins R1 and R3, NOR wins R2.
+    expect(screen.getByTestId('rivalry-h2h-num')).toHaveTextContent('2–1')
+    expect(screen.getByText('3 rounds counted', { exact: false })).toBeInTheDocument()
+    expect(screen.getByTestId('rivalry-points-race')).toBeInTheDocument()
+    expect(screen.getByTestId('rivalry-gap')).toBeInTheDocument()
+    // Last gap: 68 − 61 = +7 → VER ahead.
+    expect(screen.getByText('VER leads by 7 pts', { exact: false })).toBeInTheDocument()
+  })
+
+  it('recomputes when a different driver is picked and skips missing rounds', () => {
+    render(<RivalryCompare hub={hub} />)
+
+    fireEvent.change(screen.getByTestId('rivalry-pick-b'), { target: { value: '16' } })
+
+    // VER vs LEC: R2 skipped (LEC has no position), VER wins R1 and R3.
+    expect(screen.getByTestId('rivalry-h2h-num')).toHaveTextContent('2–0')
+    expect(screen.getByText('2 rounds counted · 1 skipped', { exact: false })).toBeInTheDocument()
+  })
+
+  it('shows an empty state with fewer than two drivers', () => {
+    render(<RivalryCompare hub={makeHub([driver({})])} />)
+    expect(screen.getByTestId('champ-view-rivalry')).toHaveTextContent('at least two drivers')
+  })
+
+  it('shows an empty message when no rounds are completed', () => {
+    const empty = makeHub([
+      driver({ cumulative: [], round_positions: [], form: [] }),
+      driver({
+        driver_number: 4,
+        name_acronym: 'NOR',
+        cumulative: [],
+        round_positions: [],
+        form: [],
+      }),
+    ])
+    empty.round = 0
+    empty.round_labels = []
+
+    render(<RivalryCompare hub={empty} />)
+    expect(screen.getByTestId('champ-view-rivalry')).toHaveTextContent('No completed rounds yet')
+  })
+})

frontend/src/test/TabBar.test.tsx

@@ -3,7 +3,7 @@ import { render, screen, fireEvent } from '@testing-library/react'
 import { TabBar } from '../components/TabBar'
 
 describe('TabBar', () => {
-  it('renders all Race Hub workspace tabs', () => {
+  it('renders all Race Hub workspace tabs grouped into a hierarchy', () => {
     render(<TabBar active="overview" onChange={() => {}} />)
     expect(screen.getByRole('tab', { name: 'Overview' })).toBeInTheDocument()
     expect(screen.getByRole('tab', { name: 'Race Story' })).toBeInTheDocument()
@@ -12,7 +12,11 @@ describe('TabBar', () => {
     expect(screen.getByRole('tab', { name: 'Lap Data' })).toBeInTheDocument()
     expect(screen.getByRole('tab', { name: 'Conditions' })).toBeInTheDocument()
     expect(screen.getByRole('tab', { name: 'Race Control' })).toBeInTheDocument()
-    expect(screen.getByRole('tab', { name: 'Data Status' })).toBeInTheDocument()
+    expect(screen.getByRole('tab', { name: 'Diagnostics' })).toBeInTheDocument()
+
+    expect(screen.getByTestId('rh-tabgroup-story')).toBeInTheDocument()
+    expect(screen.getByTestId('rh-tabgroup-analysis')).toBeInTheDocument()
+    expect(screen.getByTestId('rh-tabgroup-context')).toBeInTheDocument()
   })
 
   it('marks the active tab with aria-selected', () => {

frontend/src/test/WeekendPage.test.tsx

@@ -0,0 +1,651 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { render, screen, waitFor, fireEvent } from '@testing-library/react'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import {
+  Outlet,
+  RouterProvider,
+  createRouter,
+  createRootRoute,
+  createRoute,
+  createMemoryHistory,
+} from '@tanstack/react-router'
+import { WeekendPage } from '../pages/WeekendPage'
+import type {
+  ChampionshipHub,
+  ContextAvailability,
+  ContextSession,
+  Meeting,
+  RaceHub,
+  Session,
+  TemporalState,
+  WeekendContext,
+} from '../types'
+import { parseWeekendSearch } from '../lib/routeSearch'
+
+vi.mock('../api', () => ({
+  fetchWeekendContext: vi.fn(),
+  fetchChampionshipHub: vi.fn(),
+  fetchNews: vi.fn(),
+  fetchRaceHub: vi.fn(),
+  fetchWeekend: vi.fn(),
+  // Consumed transitively by RacePreviewPage (folded into PreSessionView):
+  fetchSeasons: vi.fn(),
+  fetchMeetings: vi.fn(),
+  fetchSessions: vi.fn(),
+  fetchResults: vi.fn(),
+  fetchStartingGrid: vi.fn(),
+  fetchTrackOutline: vi.fn(),
+}))
+
+import {
+  fetchWeekendContext,
+  fetchChampionshipHub,
+  fetchNews,
+  fetchRaceHub,
+  fetchWeekend,
+  fetchSeasons,
+  fetchMeetings,
+  fetchSessions,
+  fetchResults,
+  fetchStartingGrid,
+  fetchTrackOutline,
+} from '../api'
+import { rememberResponseAvailability } from '../lib/fetch'
+
+const mockContext = vi.mocked(fetchWeekendContext)
+const mockHub = vi.mocked(fetchChampionshipHub)
+const mockNews = vi.mocked(fetchNews)
+const mockRaceHub = vi.mocked(fetchRaceHub)
+const mockWeekend = vi.mocked(fetchWeekend)
+const mockSeasons = vi.mocked(fetchSeasons)
+const mockMeetings = vi.mocked(fetchMeetings)
+const mockSessions = vi.mocked(fetchSessions)
+const mockResults = vi.mocked(fetchResults)
+const mockGrid = vi.mocked(fetchStartingGrid)
+const mockTrack = vi.mocked(fetchTrackOutline)
+
+function availability(overrides: Partial<ContextAvailability> = {}): ContextAvailability {
+  return {
+    schedule: 'available',
+    live_transport: 'unknown',
+    live_session: 'inactive',
+    archive: 'unavailable',
+    local_analysis: 'complete',
+    freshness: 'fresh',
+    limitations: [],
+    ...overrides,
+  }
+}
+
+function meeting(overrides: Partial<Meeting> = {}): Meeting {
+  return {
+    meeting_key: 1,
+    meeting_name: 'British Grand Prix',
+    meeting_official_name: 'FORMULA 1 BRITISH GRAND PRIX',
+    location: 'Silverstone',
+    country_name: 'United Kingdom',
+    country_code: 'GBR',
+    country_flag: '',
+    circuit_key: 2,
+    circuit_short_name: 'Silverstone',
+    date_start: '2026-07-03T09:00:00Z',
+    date_end: '2026-07-05T16:00:00Z',
+    year: 2026,
+    ...overrides,
+  }
+}
+
+function session(overrides: Partial<Session> = {}): Session {
+  return {
+    session_key: 11,
+    session_name: 'Race',
+    session_type: 'Race',
+    meeting_key: 1,
+    date_start: '2026-07-05T14:00:00Z',
+    date_end: '2026-07-05T16:00:00Z',
+    gmt_offset: '',
+    ...overrides,
+  }
+}
+
+function ctxSession(overrides: Partial<ContextSession> = {}): ContextSession {
+  return {
+    session: session(),
+    meeting: meeting(),
+    availability: availability(),
+    ...overrides,
+  }
+}
+
+function context(overrides: Partial<WeekendContext> = {}): WeekendContext {
+  return {
+    season: 2026,
+    temporal_state: 'between_weekends',
+    championship_round: 5,
+    total_championship_rounds: 24,
+    ...overrides,
+  }
+}
+
+const hub: ChampionshipHub = {
+  season: 2026,
+  round: 5,
+  total_rounds: 24,
+  rounds_left: 19,
+  last_race: 'British GP',
+  round_labels: [],
+  drivers: [
+    { driver_number: 1, name_acronym: 'VER', full_name: 'Max', team_name: 'RB', team_colour: '3671c6', points: 120, position: 1, wins: 4, podiums: 5, poles: 3, form: [], cumulative: [95, 120], teammate_wins: 0, teammate_losses: 0, round_positions: [] },
+  ],
+  teams: [],
+}
+
+const raceHub = {
+  session_key: 11,
+  results: [
+    { driver_number: 1, position: 1, name_acronym: 'VER', full_name: 'Max', team_name: 'RB', team_colour: '3671c6', dnf: false, dns: false, dsq: false, duration: 5400, gap_to_leader: null },
+  ],
+} as unknown as RaceHub
+
+function renderAt(path: string) {
+  const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+
+  const rootRoute = createRootRoute({
+    component: () => (
+      <QueryClientProvider client={queryClient}>
+        <Outlet />
+      </QueryClientProvider>
+    ),
+  })
+  const homeRoute = createRoute({
+    getParentRoute: () => rootRoute,
+    path: '/',
+    validateSearch: (s: Record<string, unknown>) => parseWeekendSearch(s),
+    component: function HomeRoute() {
+      const { meeting_key, session_key } = homeRoute.useSearch()
+      return <WeekendPage focusMeetingKey={meeting_key} focusSessionKey={session_key} />
+    },
+  })
+  const previewRoute = createRoute({
+    getParentRoute: () => rootRoute,
+    path: '/preview',
+    component: () => <WeekendPage preview />,
+  })
+  const raceHubRoute = createRoute({
+    getParentRoute: () => rootRoute,
+    path: '/race-hub',
+    validateSearch: (s: Record<string, unknown>) => {
+      const sk = Number(s.session_key)
+      return Number.isFinite(sk) && sk > 0 ? { session_key: sk } : {}
+    },
+    component: () => <div data-testid="race-hub-stub" />,
+  })
+  const stub = (p: string, id: string) =>
+    createRoute({ getParentRoute: () => rootRoute, path: p, component: () => <div data-testid={id} /> })
+
+  const router = createRouter({
+    routeTree: rootRoute.addChildren([
+      homeRoute,
+      previewRoute,
+      raceHubRoute,
+      stub('/live', 'live-stub'),
+      stub('/explore', 'explore-stub'),
+      stub('/championship', 'championship-stub'),
+      stub('/briefing', 'briefing-stub'),
+    ]),
+    history: createMemoryHistory({ initialEntries: [path] }),
+  })
+  return render(<RouterProvider router={router} />)
+}
+
+describe('WeekendPage canonical contract rendering', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.setSystemTime(new Date('2026-07-08T12:00:00Z'))
+    mockHub.mockResolvedValue(hub)
+    mockNews.mockResolvedValue([])
+    mockRaceHub.mockResolvedValue(raceHub)
+    mockWeekend.mockResolvedValue({
+      source: 'local',
+      meeting_key: 1,
+      meeting: meeting(),
+      sessions: [
+        {
+          session: session({ session_key: 11, session_name: 'Race' }),
+          source: 'local',
+          datasets: {},
+        },
+      ],
+      default_session_key: 11,
+    })
+    mockSeasons.mockResolvedValue([2026])
+    mockMeetings.mockResolvedValue([meeting()])
+    mockSessions.mockResolvedValue([session()])
+    mockResults.mockResolvedValue([])
+    mockGrid.mockResolvedValue([])
+    mockTrack.mockResolvedValue(null)
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('shows the loading surface before the canonical context resolves', async () => {
+    mockContext.mockReturnValue(new Promise(() => {}))
+    renderAt('/')
+    await waitFor(() => expect(screen.getByTestId('weekend-loading')).toBeInTheDocument())
+  })
+
+  it('shows an explicit error surface when the canonical endpoint fails', async () => {
+    mockContext.mockRejectedValue(new Error('API 500: boom'))
+    renderAt('/')
+    await waitFor(() => expect(screen.getByTestId('weekend-error')).toBeInTheDocument())
+    // Sanitized — never leak raw HTTP status/body into the Weekend surface.
+    expect(screen.getByTestId('weekend-error')).not.toHaveTextContent(/API 500|boom/i)
+    expect(screen.getByRole('button', { name: 'Retry' })).toBeInTheDocument()
+  })
+
+  it('retries the canonical read and recovers into a temporal state', async () => {
+    let calls = 0
+    mockContext.mockImplementation(async () => {
+      calls += 1
+      if (calls === 1) throw new Error('API 503: unavailable')
+      return context({ temporal_state: 'between_weekends' })
+    })
+    renderAt('/')
+    await waitFor(() => expect(screen.getByTestId('weekend-error')).toBeInTheDocument())
+    const retry = screen.getByRole('button', { name: 'Retry' })
+    fireEvent.click(retry)
+    await waitFor(() => expect(screen.getByTestId('weekend-between-races')).toBeInTheDocument())
+    expect(calls).toBe(2)
+    expect(screen.getByTestId('weekend-page')).toHaveAttribute(
+      'data-temporal-state',
+      'between_weekends',
+    )
+  })
+
+  it('failed canonical read creates zero seasons/meetings/weekend/live-state fanout', async () => {
+    mockContext.mockRejectedValue(new Error('API 503: unavailable'))
+    renderAt('/')
+    await waitFor(() => expect(screen.getByTestId('weekend-error')).toBeInTheDocument())
+    expect(mockSeasons).not.toHaveBeenCalled()
+    expect(mockMeetings).not.toHaveBeenCalled()
+    expect(mockWeekend).not.toHaveBeenCalled()
+    expect(mockHub).not.toHaveBeenCalled()
+    expect(mockNews).not.toHaveBeenCalled()
+  })
+
+  const stateCases: Array<[TemporalState, string]> = [
+    ['between_weekends', 'weekend-between-races'],
+    ['post_weekend', 'weekend-between-races'],
+    ['season_complete', 'weekend-between-races'],
+    ['pre_session', 'weekend-pre-session'],
+    ['between_sessions', 'weekend-between-sessions'],
+    ['session_settling', 'weekend-between-sessions'],
+    ['session_live', 'weekend-live'],
+  ]
+
+  it.each(stateCases)('renders a designed surface for canonical temporal_state %s', async (temporal, testid) => {
+    mockContext.mockResolvedValue(
+      context({
+        temporal_state: temporal,
+        previous_completed_session: ctxSession({ session: session({ session_key: 11, session_name: 'Race' }) }),
+        default_analysis_session: ctxSession({ session: session({ session_key: 11 }) }),
+        next_meeting: meeting({ meeting_key: 2, meeting_name: 'Hungarian Grand Prix', date_start: '2026-07-24T09:00:00Z' }),
+        next_session: ctxSession({ session: session({ session_key: 21, session_name: 'Practice 1', date_start: '2026-07-24T09:00:00Z' }) }),
+        active_session: temporal === 'session_live'
+          ? ctxSession({ session: session({ session_key: 12, session_name: 'Race' }), availability: availability({ live_session: 'active' }) })
+          : undefined,
+        focus_meeting: meeting(),
+      }),
+    )
+    renderAt('/')
+    await waitFor(() => expect(screen.getByTestId('weekend-page')).toHaveAttribute('data-temporal-state', temporal))
+    expect(screen.getByTestId(testid)).toBeInTheDocument()
+  })
+
+  it('renders the limited surface for no_season and never falls through to it for a valid payload', async () => {
+    mockContext.mockResolvedValue(context({ temporal_state: 'no_season', championship_round: 0, total_championship_rounds: 0 }))
+    renderAt('/')
+    await waitFor(() => expect(screen.getByTestId('weekend-limited')).toBeInTheDocument())
+  })
+
+  it('between-races pairs the completed analysis CTA with the next-event countdown and championship impact', async () => {
+    mockContext.mockResolvedValue(
+      context({
+        previous_completed_session: ctxSession({ session: session({ session_key: 11, session_name: 'Race' }) }),
+        default_analysis_session: ctxSession({ session: session({ session_key: 11 }) }),
+        next_meeting: meeting({ meeting_key: 2, meeting_name: 'Hungarian Grand Prix', date_start: '2026-07-24T09:00:00Z' }),
+        next_session: ctxSession({ session: session({ session_key: 21, session_name: 'Practice 1', date_start: '2026-07-24T09:00:00Z' }) }),
+      }),
+    )
+    renderAt('/')
+    await waitFor(() => expect(screen.getByTestId('wk-last-event')).toBeInTheDocument())
+    expect(screen.getByTestId('wk-next-event')).toBeInTheDocument()
+    const story = screen.getByTestId('wk-explore-race-story')
+    expect(story).toHaveAttribute('href', expect.stringContaining('session_key=11'))
+    expect(screen.getByTestId('wk-prepare')).toHaveAttribute('href', '/preview')
+    await waitFor(() => expect(screen.getByTestId('wk-champ-impact')).toBeInTheDocument())
+    expect(screen.getByTestId('wk-season-nav')).toHaveTextContent('Round 5 of 24')
+  })
+
+  it('does not fan out to season/meeting/OpenF1/live queries when the canonical context succeeds', async () => {
+    mockContext.mockResolvedValue(context({ temporal_state: 'between_weekends' }))
+    renderAt('/')
+    await waitFor(() => expect(screen.getByTestId('weekend-between-races')).toBeInTheDocument())
+    // Only supplementary championship + news reads are allowed; no season /
+    // meetings / sessions / live fan-out from the Weekend home hook.
+    expect(mockSeasons).not.toHaveBeenCalled()
+    expect(mockSessions).not.toHaveBeenCalled()
+    // fetchMeetings may still be reached only through the folded preview surface,
+    // which is not mounted in the between-races state.
+    expect(mockMeetings).not.toHaveBeenCalled()
+  })
+
+  it('supplementary reads stay dormant while the canonical context is pending', async () => {
+    mockContext.mockReturnValue(new Promise(() => {}))
+    renderAt('/')
+    await waitFor(() => expect(screen.getByTestId('weekend-loading')).toBeInTheDocument())
+    expect(mockHub).not.toHaveBeenCalled()
+    expect(mockNews).not.toHaveBeenCalled()
+  })
+
+  it('the /preview alias renders the preparation surface instead of looping back', async () => {
+    mockContext.mockResolvedValue(
+      context({
+        temporal_state: 'between_weekends',
+        next_meeting: meeting({ meeting_key: 2, meeting_name: 'Hungarian Grand Prix', date_start: '2026-07-24T09:00:00Z' }),
+        next_session: ctxSession({ session: session({ session_key: 21, session_name: 'Practice 1', date_start: '2026-07-24T09:00:00Z' }) }),
+      }),
+    )
+    renderAt('/preview')
+    await waitFor(() => expect(screen.getByTestId('weekend-pre-session')).toBeInTheDocument())
+    expect(screen.getByTestId('weekend-page')).toHaveAttribute('data-preview', 'true')
+    // The between-races surface must NOT be what /preview renders.
+    expect(screen.queryByTestId('weekend-between-races')).not.toBeInTheDocument()
+  })
+
+  it('pre_session embeds Preview with canonical meeting identity (no seasons/meetings re-resolve)', async () => {
+    const next = meeting({
+      meeting_key: 2,
+      meeting_name: 'Hungarian Grand Prix',
+      date_start: '2026-07-24T09:00:00Z',
+    })
+    mockContext.mockResolvedValue(
+      context({
+        temporal_state: 'pre_session',
+        next_meeting: next,
+        focus_meeting: next,
+        next_session: ctxSession({
+          session: session({
+            session_key: 21,
+            session_name: 'Practice 1',
+            meeting_key: 2,
+            date_start: '2026-07-24T09:00:00Z',
+          }),
+          meeting: next,
+          availability: availability({ freshness: 'partial', local_analysis: 'partial' }),
+        }),
+      }),
+    )
+    mockSessions.mockResolvedValue([
+      session({
+        session_key: 21,
+        session_name: 'Practice 1',
+        meeting_key: 2,
+        date_start: '2026-07-24T09:00:00Z',
+      }),
+    ])
+
+    renderAt('/')
+    await waitFor(() => expect(screen.getByTestId('weekend-pre-session')).toBeInTheDocument())
+    expect(screen.getByTestId('wk-pre-head')).toHaveTextContent('Hungarian Grand Prix')
+    expect(screen.getByTestId('weekend-data-notice')).toHaveTextContent(/Partial/i)
+
+    await waitFor(() => expect(screen.getByTestId('preview-page')).toBeInTheDocument())
+    expect(screen.getByTestId('preview-page')).toHaveAttribute('data-meeting-key', '2')
+    expect(screen.getByTestId('preview-page')).toHaveAttribute('data-embedded', 'true')
+    // Single shell notice — Preview must not stack a second freshness banner.
+    expect(screen.getByTestId('weekend-data-notice')).toHaveTextContent(/Partial/i)
+    expect(screen.queryByTestId('preview-data-notice')).not.toBeInTheDocument()
+    // Canonical identity was passed — Preview must not fan out to seasons /
+    // current-season meetings selection. Prior-year lookup for "Last year here"
+    // remains an intentional supplement.
+    expect(mockSeasons).not.toHaveBeenCalled()
+    expect(mockMeetings).not.toHaveBeenCalledWith(2026, expect.anything(), expect.anything())
+    expect(mockSessions).toHaveBeenCalledWith(2, 'auto', expect.anything())
+  })
+
+  it('preview supplement failure keeps the Weekend shell usable with sanitized Retry', async () => {
+    const next = meeting({
+      meeting_key: 2,
+      meeting_name: 'Hungarian Grand Prix',
+      date_start: '2026-07-24T09:00:00Z',
+    })
+    mockContext.mockResolvedValue(
+      context({
+        temporal_state: 'pre_session',
+        next_meeting: next,
+        focus_meeting: next,
+        next_session: ctxSession({
+          session: session({ session_key: 21, session_name: 'Practice 1', meeting_key: 2 }),
+          meeting: next,
+        }),
+      }),
+    )
+    let sessionCalls = 0
+    mockSessions.mockImplementation(async (meetingKey: number) => {
+      if (meetingKey !== 2) return []
+      sessionCalls += 1
+      if (sessionCalls === 1) throw new Error('API 500: sessions boom')
+      return [
+        session({
+          session_key: 21,
+          session_name: 'Practice 1',
+          meeting_key: 2,
+          date_start: '2026-07-24T09:00:00Z',
+        }),
+      ]
+    })
+
+    renderAt('/')
+    await waitFor(() => expect(screen.getByTestId('wk-pre-head')).toBeInTheDocument())
+    expect(screen.getByTestId('wk-pre-head')).toHaveTextContent('Hungarian Grand Prix')
+    await waitFor(() => expect(screen.getByTestId('preview-sessions-error')).toBeInTheDocument())
+    expect(screen.queryByText(/API 500|sessions boom/i)).not.toBeInTheDocument()
+
+    fireEvent.click(screen.getByTestId('preview-sessions-retry'))
+    await waitFor(() => expect(screen.getByTestId('preview-schedule')).toHaveTextContent('Practice 1'))
+    expect(sessionCalls).toBe(2)
+    expect(screen.queryByTestId('preview-sessions-error')).not.toBeInTheDocument()
+  })
+
+  it('Limited Retry refetches failed championship/news supplements once', async () => {
+    mockContext.mockResolvedValue(context({ temporal_state: 'between_weekends' }))
+    let hubCalls = 0
+    let newsCalls = 0
+    mockHub.mockImplementation(async () => {
+      hubCalls += 1
+      if (hubCalls === 1) throw new Error('API 503: hub')
+      return hub
+    })
+    mockNews.mockImplementation(async () => {
+      newsCalls += 1
+      if (newsCalls === 1) throw new Error('API 503: news')
+      return []
+    })
+
+    renderAt('/')
+    await waitFor(() => expect(screen.getByTestId('weekend-data-notice')).toHaveTextContent(/Limited/i))
+    const retry = screen.getByTestId('weekend-data-notice').querySelector('button')!
+    expect(retry).toBeEnabled()
+    fireEvent.click(retry)
+    fireEvent.click(retry)
+
+    await waitFor(() => expect(screen.queryByTestId('weekend-data-notice')).not.toBeInTheDocument())
+    expect(hubCalls).toBe(2)
+    expect(newsCalls).toBe(2)
+    // Canonical context is not the failed resource — only one initial fetch.
+    expect(mockContext).toHaveBeenCalledTimes(1)
+  })
+
+  it('Limited Retry exposes disabled Retrying… aria-busy while deferred supplements recover', async () => {
+    mockContext.mockResolvedValue(context({ temporal_state: 'between_weekends' }))
+    let hubCalls = 0
+    let newsCalls = 0
+    let resolveHub!: (value: ChampionshipHub) => void
+    let resolveNews!: (value: []) => void
+    mockHub.mockImplementation(
+      () =>
+        new Promise<ChampionshipHub>((resolve, reject) => {
+          hubCalls += 1
+          if (hubCalls === 1) {
+            reject(new Error('API 503: hub'))
+            return
+          }
+          resolveHub = resolve
+        }),
+    )
+    mockNews.mockImplementation(
+      () =>
+        new Promise<[]>((resolve, reject) => {
+          newsCalls += 1
+          if (newsCalls === 1) {
+            reject(new Error('API 503: news'))
+            return
+          }
+          resolveNews = resolve
+        }),
+    )
+
+    renderAt('/')
+    await waitFor(() => expect(screen.getByTestId('weekend-data-notice')).toHaveTextContent(/Limited/i))
+    expect(mockContext).toHaveBeenCalledTimes(1)
+
+    fireEvent.click(screen.getByRole('button', { name: 'Retry' }))
+    await waitFor(() => expect(screen.getByRole('button', { name: 'Retrying…' })).toBeDisabled())
+    expect(screen.getByRole('button', { name: 'Retrying…' })).toHaveAttribute('aria-busy', 'true')
+    // Double-click while pending must not issue extra supplement or context requests.
+    fireEvent.click(screen.getByRole('button', { name: 'Retrying…' }))
+    expect(hubCalls).toBe(2)
+    expect(newsCalls).toBe(2)
+    expect(mockContext).toHaveBeenCalledTimes(1)
+
+    resolveHub(hub)
+    resolveNews([])
+    await waitFor(() => expect(screen.queryByTestId('weekend-data-notice')).not.toBeInTheDocument())
+    expect(hubCalls).toBe(2)
+    expect(newsCalls).toBe(2)
+    expect(mockContext).toHaveBeenCalledTimes(1)
+  })
+
+  it('between-sessions header local/local suppresses Archive from terminal previous', async () => {
+    const focus = meeting({
+      meeting_key: 2,
+      meeting_name: 'Belgian Grand Prix',
+      date_start: '2026-07-10T09:00:00Z',
+    })
+    const previous = meeting({
+      meeting_key: 1,
+      meeting_name: 'British Grand Prix',
+      circuit_short_name: 'Silverstone',
+      date_start: '2026-07-05T09:00:00Z',
+    })
+    const payload = context({
+      temporal_state: 'between_sessions',
+      focus_meeting: focus,
+      next_meeting: focus,
+      previous_meeting: previous,
+      next_session: ctxSession({
+        session: session({
+          session_key: 21,
+          session_name: 'Practice 1',
+          meeting_key: 2,
+          date_start: '2026-07-10T09:00:00Z',
+        }),
+        meeting: focus,
+        availability: availability({ source: 'local', freshness: 'local' }),
+      }),
+      previous_completed_session: ctxSession({
+        session: session({
+          session_key: 99,
+          session_name: 'Race',
+          session_type: 'Race',
+          meeting_key: 1,
+          date_start: '2026-07-05T14:00:00Z',
+        }),
+        meeting: previous,
+        availability: availability({ source: 'fia', freshness: 'archive', archive: 'available' }),
+      }),
+    })
+    rememberResponseAvailability(payload, { source: 'local', freshness: 'local' })
+    mockContext.mockResolvedValue(payload)
+
+    renderAt('/')
+    await waitFor(() => expect(screen.getByTestId('weekend-between-sessions')).toBeInTheDocument())
+    expect(screen.queryByTestId('weekend-data-notice')).not.toBeInTheDocument()
+    expect(screen.queryByText(/archived snapshot/i)).not.toBeInTheDocument()
+  })
+
+  it('pre_session keeps shell Partial while disclosing distinct Preview stale', async () => {
+    const next = meeting({
+      meeting_key: 2,
+      meeting_name: 'Hungarian Grand Prix',
+      date_start: '2026-07-24T09:00:00Z',
+    })
+    mockContext.mockResolvedValue(
+      context({
+        temporal_state: 'pre_session',
+        next_meeting: next,
+        focus_meeting: next,
+        next_session: ctxSession({
+          session: session({
+            session_key: 21,
+            session_name: 'Practice 1',
+            meeting_key: 2,
+            date_start: '2026-07-24T09:00:00Z',
+          }),
+          meeting: next,
+          availability: availability({ freshness: 'partial', local_analysis: 'partial' }),
+        }),
+      }),
+    )
+    mockSessions.mockResolvedValue([
+      session({
+        session_key: 21,
+        session_name: 'Practice 1',
+        meeting_key: 2,
+        date_start: '2026-07-24T09:00:00Z',
+      }),
+    ])
+    rememberResponseAvailability(hub, { source: 'openf1', freshness: 'stale' })
+    mockHub.mockResolvedValue(hub)
+
+    renderAt('/')
+    await waitFor(() => expect(screen.getByTestId('weekend-data-notice')).toHaveTextContent(/Partial/i))
+    await waitFor(() => expect(screen.getByTestId('preview-data-notice')).toHaveTextContent(/Stale/i))
+  })
+
+  it('restores Race Hub meeting/session focus from the Weekend URL search contract', async () => {
+    mockContext.mockResolvedValue(
+      context({
+        temporal_state: 'season_complete',
+        previous_completed_session: ctxSession({ session: session({ session_key: 11, session_name: 'Race' }) }),
+        default_analysis_session: ctxSession({ session: session({ session_key: 11 }) }),
+      }),
+    )
+    renderAt('/?meeting_key=1&session_key=11')
+    await waitFor(() => expect(screen.getByTestId('wk-focus-context')).toBeInTheDocument())
+    expect(screen.getByTestId('weekend-page')).toHaveAttribute('data-meeting-key', '1')
+    expect(screen.getByTestId('weekend-page')).toHaveAttribute('data-session-key', '11')
+    await waitFor(() =>
+      expect(screen.getByTestId('wk-focus-meeting')).toHaveTextContent('British Grand Prix'),
+    )
+    await waitFor(() =>
+      expect(screen.getByTestId('wk-focus-session')).toHaveTextContent('Race'),
+    )
+    const continueAnalysis = screen.getByRole('link', { name: /Continue analysis/i })
+    expect(continueAnalysis).toHaveAttribute('href', expect.stringContaining('session_key=11'))
+    expect(mockWeekend).toHaveBeenCalledWith(1)
+  })
+})

frontend/src/test/availability.test.ts

@@ -0,0 +1,344 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest'
+import { QueryClient, QueryObserver } from '@tanstack/react-query'
+import {
+  apiFetch,
+  availabilityAwareStructuralSharing,
+  clearApiFetchInflight,
+  DATA_FRESHNESS_HEADER,
+  DATA_SOURCE_HEADER,
+  getResponseAvailability,
+  rememberResponseAvailability,
+} from '../lib/fetch'
+import {
+  aggregateNotices,
+  noticeFromFreshness,
+  noticeFromResponse,
+  shouldShowEmbeddedNotice,
+  weekendContextNotice,
+} from '../lib/availability'
+import type { WeekendContext } from '../types'
+
+describe('response availability metadata', () => {
+  beforeEach(() => {
+    clearApiFetchInflight()
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+    clearApiFetchInflight()
+  })
+
+  it('captures CORS-readable source/freshness headers without changing the payload shape', async () => {
+    const body = { season: 2026, drivers: [{ points: 1 }] }
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async () =>
+        new Response(JSON.stringify(body), {
+          status: 200,
+          headers: {
+            'Content-Type': 'application/json',
+            [DATA_SOURCE_HEADER]: 'openf1',
+            [DATA_FRESHNESS_HEADER]: 'stale',
+          },
+        }),
+      ),
+    )
+
+    const data = await apiFetch<typeof body>('/api/v1/championship/hub')
+    expect(data).toEqual(body)
+    expect(getResponseAvailability(data)).toEqual({ source: 'openf1', freshness: 'stale' })
+  })
+
+  it('preserves metadata through deduped in-flight subscribers', async () => {
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async () =>
+        new Response(JSON.stringify({ ok: true }), {
+          status: 200,
+          headers: {
+            'Content-Type': 'application/json',
+            [DATA_SOURCE_HEADER]: 'local',
+            [DATA_FRESHNESS_HEADER]: 'partial',
+          },
+        }),
+      ),
+    )
+
+    const a = apiFetch<{ ok: boolean }>('/api/v1/shared', { dedupeKey: 'meta-shared' })
+    const b = apiFetch<{ ok: boolean }>('/api/v1/shared', { dedupeKey: 'meta-shared' })
+    const [ra, rb] = await Promise.all([a, b])
+    expect(ra).toBe(rb)
+    expect(getResponseAvailability(ra)).toEqual({ source: 'local', freshness: 'partial' })
+  })
+
+  it('maps only reported freshness values and never invents stale', () => {
+    expect(noticeFromFreshness('stale')).toBe('stale')
+    expect(noticeFromFreshness('partial')).toBe('partial')
+    expect(noticeFromFreshness('local')).toBe('local')
+    expect(noticeFromFreshness('limited')).toBe('limited')
+    expect(noticeFromFreshness('archive')).toBe('archive')
+    expect(noticeFromFreshness('fresh')).toBeNull()
+    expect(noticeFromFreshness('live')).toBeNull()
+    expect(noticeFromFreshness(undefined)).toBeNull()
+    expect(noticeFromFreshness('local', { includeLocal: false })).toBeNull()
+  })
+
+  it('reads notice from WeakMap metadata attached to a successful payload', () => {
+    const hub = { season: 2025, drivers: [] as unknown[] }
+    rememberResponseAvailability(hub, { source: 'openf1', freshness: 'stale' })
+    expect(noticeFromResponse(hub)).toBe('stale')
+  })
+
+  it('dedupes only equivalent embedded Preview notices', () => {
+    expect(shouldShowEmbeddedNotice('stale', 'partial')).toBe(true)
+    expect(shouldShowEmbeddedNotice('partial', 'partial')).toBe(false)
+    expect(shouldShowEmbeddedNotice('stale', null)).toBe(true)
+    expect(shouldShowEmbeddedNotice(null, 'partial')).toBe(false)
+  })
+
+  it('aggregates conflicting sources by severity so Local cannot mask worse truth', () => {
+    expect(aggregateNotices(['local', 'stale'])).toBe('stale')
+    expect(aggregateNotices(['local', 'partial'])).toBe('partial')
+    expect(aggregateNotices(['local', 'limited'])).toBe('limited')
+    expect(aggregateNotices(['local', 'archive'])).toBe('archive')
+    expect(aggregateNotices(['stale', 'partial', 'local'])).toBe('partial')
+    expect(aggregateNotices(['stale', 'stale', null])).toBe('stale')
+    expect(aggregateNotices([null, undefined])).toBeNull()
+  })
+
+  it('derives Weekend Context notices from typed session freshness, skipping routine local', () => {
+    const context: WeekendContext = {
+      season: 2026,
+      temporal_state: 'pre_session',
+      championship_round: 1,
+      total_championship_rounds: 24,
+      focus_meeting: {
+        meeting_key: 2,
+        meeting_name: 'Belgian Grand Prix',
+        meeting_official_name: '',
+        location: 'Spa',
+        country_name: 'Belgium',
+        country_code: 'BEL',
+        country_flag: '',
+        circuit_key: 7,
+        circuit_short_name: 'Spa',
+        date_start: '2026-07-24T09:00:00Z',
+        date_end: '2026-07-26T16:00:00Z',
+        year: 2026,
+      },
+      next_session: {
+        session: {
+          session_key: 21,
+          session_name: 'FP1',
+          session_type: 'Practice',
+          meeting_key: 2,
+          date_start: '2026-07-24T09:00:00Z',
+          date_end: '2026-07-24T10:00:00Z',
+          gmt_offset: '',
+        },
+        meeting: {
+          meeting_key: 2,
+          meeting_name: 'Belgian Grand Prix',
+          meeting_official_name: '',
+          location: 'Spa',
+          country_name: 'Belgium',
+          country_code: 'BEL',
+          country_flag: '',
+          circuit_key: 7,
+          circuit_short_name: 'Spa',
+          date_start: '2026-07-24T09:00:00Z',
+          date_end: '2026-07-26T16:00:00Z',
+          year: 2026,
+        },
+        availability: {
+          source: 'local',
+          schedule: 'available',
+          live_transport: 'unknown',
+          live_session: 'inactive',
+          archive: 'unavailable',
+          local_analysis: 'partial',
+          freshness: 'partial',
+          limitations: [],
+        },
+      },
+    }
+    expect(weekendContextNotice(context)).toBe('partial')
+
+    const localOnly: WeekendContext = {
+      ...context,
+      next_session: {
+        ...context.next_session!,
+        availability: {
+          ...context.next_session!.availability,
+          local_analysis: 'pending',
+          freshness: 'local',
+        },
+      },
+    }
+    expect(weekendContextNotice(localOnly)).toBeNull()
+  })
+
+  it('authoritative Weekend header local/local does not fall through to previous archive', () => {
+    const focusMeeting = {
+      meeting_key: 2,
+      meeting_name: 'Belgian Grand Prix',
+      meeting_official_name: '',
+      location: 'Spa',
+      country_name: 'Belgium',
+      country_code: 'BEL',
+      country_flag: '',
+      circuit_key: 7,
+      circuit_short_name: 'Spa',
+      date_start: '2026-07-10T09:00:00Z',
+      date_end: '2026-07-12T16:00:00Z',
+      year: 2026,
+    }
+    const previousMeeting = {
+      ...focusMeeting,
+      meeting_key: 1,
+      meeting_name: 'British Grand Prix',
+      circuit_short_name: 'Silverstone',
+      location: 'Silverstone',
+      country_name: 'United Kingdom',
+      country_code: 'GBR',
+    }
+    const context: WeekendContext = {
+      season: 2026,
+      temporal_state: 'between_sessions',
+      championship_round: 12,
+      total_championship_rounds: 24,
+      focus_meeting: focusMeeting,
+      next_session: {
+        session: {
+          session_key: 21,
+          session_name: 'Practice 1',
+          session_type: 'Practice',
+          meeting_key: 2,
+          date_start: '2026-07-10T09:00:00Z',
+          date_end: '2026-07-10T10:00:00Z',
+          gmt_offset: '',
+        },
+        meeting: focusMeeting,
+        availability: {
+          source: 'local',
+          schedule: 'available',
+          live_transport: 'unknown',
+          live_session: 'inactive',
+          archive: 'unavailable',
+          local_analysis: 'pending',
+          freshness: 'local',
+          limitations: [],
+        },
+      },
+      previous_completed_session: {
+        session: {
+          session_key: 99,
+          session_name: 'Race',
+          session_type: 'Race',
+          meeting_key: 1,
+          date_start: '2026-07-05T14:00:00Z',
+          date_end: '2026-07-05T16:00:00Z',
+          gmt_offset: '',
+        },
+        meeting: previousMeeting,
+        availability: {
+          source: 'fia',
+          schedule: 'available',
+          live_transport: 'unknown',
+          live_session: 'inactive',
+          archive: 'available',
+          local_analysis: 'complete',
+          freshness: 'archive',
+          limitations: [],
+        },
+      },
+    }
+
+    rememberResponseAvailability(context, { source: 'local', freshness: 'local' })
+    expect(weekendContextNotice(context)).toBeNull()
+
+    // Without an authoritative header, typed focus (upcoming local) still suppresses Local.
+    const noHeader: WeekendContext = { ...context }
+    expect(weekendContextNotice(noHeader)).toBeNull()
+  })
+
+  it('updates metadata when structural sharing reuses an equal JSON object', () => {
+    const body = { season: 2026, drivers: [{ points: 1 }] }
+    const first = structuredClone(body)
+    const second = structuredClone(body)
+    rememberResponseAvailability(first, { source: 'openf1', freshness: 'stale' })
+    rememberResponseAvailability(second, { source: 'openf1', freshness: 'fresh' })
+
+    const shared = availabilityAwareStructuralSharing(first, second)
+    expect(shared).toBe(first)
+    expect(getResponseAvailability(shared)).toEqual({ source: 'openf1', freshness: 'fresh' })
+    expect(noticeFromResponse(shared)).toBeNull()
+
+    const third = structuredClone(body)
+    rememberResponseAvailability(third, { source: 'openf1', freshness: 'partial' })
+    const sharedAgain = availabilityAwareStructuralSharing(shared, third)
+    expect(sharedAgain).toBe(first)
+    expect(noticeFromResponse(sharedAgain)).toBe('partial')
+  })
+
+  it('QueryObserver stale→fresh and fresh→partial refetches update metadata and notices', async () => {
+    const body = { season: 2026, drivers: [{ points: 42 }] }
+    const sequence: Array<'stale' | 'fresh' | 'partial'> = ['stale', 'fresh', 'partial']
+    let call = 0
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async () => {
+        const freshness = sequence[Math.min(call, sequence.length - 1)]
+        call += 1
+        return new Response(JSON.stringify(body), {
+          status: 200,
+          headers: {
+            'Content-Type': 'application/json',
+            [DATA_SOURCE_HEADER]: 'openf1',
+            [DATA_FRESHNESS_HEADER]: freshness,
+          },
+        })
+      }),
+    )
+
+    const client = new QueryClient({
+      defaultOptions: {
+        queries: {
+          retry: false,
+          structuralSharing: availabilityAwareStructuralSharing,
+        },
+      },
+    })
+    const observer = new QueryObserver(client, {
+      queryKey: ['availability-observer'],
+      queryFn: () => apiFetch<typeof body>('/api/v1/championship/hub'),
+      staleTime: 0,
+    })
+
+    const notices: Array<string | null> = []
+    const unsub = observer.subscribe((result) => {
+      if (result.data) notices.push(noticeFromResponse(result.data))
+    })
+
+    await observer.refetch()
+    expect(noticeFromResponse(observer.getCurrentResult().data)).toBe('stale')
+    expect(notices[notices.length - 1]).toBe('stale')
+
+    await observer.refetch()
+    expect(observer.getCurrentResult().data).toEqual(body)
+    expect(getResponseAvailability(observer.getCurrentResult().data!)).toEqual({
+      source: 'openf1',
+      freshness: 'fresh',
+    })
+    expect(noticeFromResponse(observer.getCurrentResult().data)).toBeNull()
+    expect(notices[notices.length - 1]).toBeNull()
+
+    await observer.refetch()
+    expect(noticeFromResponse(observer.getCurrentResult().data)).toBe('partial')
+    expect(notices[notices.length - 1]).toBe('partial')
+    expect(call).toBe(3)
+
+    unsub()
+    client.clear()
+  })
+})

frontend/src/test/chapters.test.ts

@@ -1,10 +1,13 @@
 import { describe, expect, it } from 'vitest'
 import {
   activeChapterIndex,
+  chapterBandFill,
   chapterKindLabel,
   chapterLapRange,
   chapterStartScrub,
   chapterTourDurations,
+  deCollideYPositions,
+  decimatedPositionLabels,
 } from '../lib/chapters'
 import type { Chapter } from '../types'
 
@@ -57,7 +60,65 @@ describe('chapters lib', () => {
     expect(activeChapterIndex(sampleChapters, scrub, tMin, tRange)).toBe(1)
   })
 
+  it('activates chapters whose timestamps clamp outside the position window', () => {
+    // Position samples only cover 13:05–13:10; chapters sit before/after that window.
+    const tMin = new Date('2025-05-25T13:05:00Z').getTime()
+    const tMax = new Date('2025-05-25T13:10:00Z').getTime()
+    const tRange = tMax - tMin
+    const outOfWindow: Chapter[] = [
+      {
+        kind: 'start',
+        title: 'Start',
+        headline: 'Lights out',
+        start_lap: 1,
+        end_lap: 1,
+        start_time: '2025-05-25T13:00:00Z',
+        end_time: '2025-05-25T13:01:00Z',
+        driver_numbers: [],
+      },
+      {
+        kind: 'finish',
+        title: 'Finish',
+        headline: 'Chequered flag',
+        start_lap: 78,
+        end_lap: 78,
+        start_time: '2025-05-25T13:20:00Z',
+        end_time: '2025-05-25T13:21:00Z',
+        driver_numbers: [],
+      },
+    ]
+
+    expect(chapterStartScrub(outOfWindow[0], tMin, tRange)).toBe(0)
+    expect(chapterStartScrub(outOfWindow[1], tMin, tRange)).toBe(1)
+    expect(activeChapterIndex(outOfWindow, 0, tMin, tRange)).toBe(0)
+    expect(activeChapterIndex(outOfWindow, 1, tMin, tRange)).toBe(1)
+    expect(activeChapterIndex(outOfWindow, 0.5, tMin, tRange)).toBeNull()
+  })
+
   it('splits 90s evenly across chapters', () => {
     expect(chapterTourDurations(sampleChapters)).toEqual([45_000, 45_000])
   })
+
+  it('decimates position axis labels', () => {
+    expect(decimatedPositionLabels(22)).toEqual([1, 5, 10, 15, 20, 22])
+  })
+
+  it('returns chapter band fills by kind', () => {
+    expect(chapterBandFill('safety_car')).toContain('rgba')
+    expect(chapterBandFill('virtual_safety_car')).toContain('rgba')
+  })
+
+  it('de-collides overlapping label y positions', () => {
+    const adjusted = deCollideYPositions(
+      [
+        { key: 'a', y: 10 },
+        { key: 'b', y: 12 },
+        { key: 'c', y: 30 },
+      ],
+      12,
+    )
+    expect(adjusted.get('a')).toBe(10)
+    expect(adjusted.get('b')).toBe(22)
+    expect(adjusted.get('c')).toBe(34)
+  })
 })

frontend/src/test/digest.test.ts

@@ -51,6 +51,7 @@ const driver = (over: Partial<ChampHubDriver>): ChampHubDriver => ({
   cumulative: [25, 43, 68, 100],
   teammate_wins: 4,
   teammate_losses: 1,
+  round_positions: [],
   ...over,
 })
 

frontend/src/test/fetch.test.ts

@@ -0,0 +1,291 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  ApiError,
+  apiFetch,
+  clearApiFetchInflight,
+  DEFAULT_FETCH_TIMEOUT_MS,
+  isTimeoutError,
+  userFacingError,
+} from '../lib/fetch'
+
+describe('apiFetch', () => {
+  beforeEach(() => {
+    clearApiFetchInflight()
+    vi.useFakeTimers()
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+    vi.unstubAllGlobals()
+    clearApiFetchInflight()
+  })
+
+  it('resolves JSON within the timeout boundary', async () => {
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async () =>
+        new Response(JSON.stringify({ ok: true }), {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        }),
+      ),
+    )
+
+    await expect(apiFetch<{ ok: boolean }>('/api/v1/ping')).resolves.toEqual({ ok: true })
+  })
+
+  it('times out and leaves no hanging promise after the deadline', async () => {
+    vi.stubGlobal(
+      'fetch',
+      vi.fn((_url: string, init?: RequestInit) => {
+        return new Promise<Response>((_resolve, reject) => {
+          const signal = init?.signal
+          if (!signal) return
+          signal.addEventListener('abort', () => {
+            reject(new DOMException('Aborted', 'AbortError'))
+          })
+        })
+      }),
+    )
+
+    const pending = apiFetch('/api/v1/slow', { timeoutMs: 1000 })
+    const assertion = expect(pending).rejects.toSatisfy(
+      (err: unknown) => isTimeoutError(err) && userFacingError(err).includes('too long'),
+    )
+
+    await vi.advanceTimersByTimeAsync(1000)
+    await assertion
+  })
+
+  it('propagates caller abort as an ApiError', async () => {
+    vi.stubGlobal(
+      'fetch',
+      vi.fn((_url: string, init?: RequestInit) => {
+        return new Promise<Response>((_resolve, reject) => {
+          init?.signal?.addEventListener('abort', () => {
+            reject(new DOMException('Aborted', 'AbortError'))
+          })
+        })
+      }),
+    )
+
+    const controller = new AbortController()
+    const pending = apiFetch('/api/v1/abort-me', {
+      signal: controller.signal,
+      timeoutMs: 30_000,
+    })
+    const assertion = expect(pending).rejects.toMatchObject({ kind: 'abort' })
+    controller.abort()
+    await assertion
+  })
+
+  it('deduplicates concurrent in-flight requests for the same key', async () => {
+    let starts = 0
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async () => {
+        starts += 1
+        await new Promise((r) => setTimeout(r, 50))
+        return new Response(JSON.stringify({ n: starts }), {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        })
+      }),
+    )
+
+    const a = apiFetch<{ n: number }>('/api/v1/shared', { dedupeKey: 'shared' })
+    const b = apiFetch<{ n: number }>('/api/v1/shared', { dedupeKey: 'shared' })
+    await vi.advanceTimersByTimeAsync(50)
+    const [ra, rb] = await Promise.all([a, b])
+    expect(starts).toBe(1)
+    expect(ra).toEqual(rb)
+  })
+
+  it('does not poison a second caller when the first aborts the same dedupe key', async () => {
+    let starts = 0
+    vi.stubGlobal(
+      'fetch',
+      vi.fn((_url: string, init?: RequestInit) => {
+        starts += 1
+        return new Promise<Response>((resolve, reject) => {
+          const timer = setTimeout(() => {
+            resolve(
+              new Response(JSON.stringify({ ok: true, starts }), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+              }),
+            )
+          }, 100)
+          init?.signal?.addEventListener(
+            'abort',
+            () => {
+              clearTimeout(timer)
+              reject(new DOMException('Aborted', 'AbortError'))
+            },
+            { once: true },
+          )
+        })
+      }),
+    )
+
+    const first = new AbortController()
+    const second = new AbortController()
+    const a = apiFetch<{ ok: boolean }>('/api/v1/shared', {
+      dedupeKey: 'shared-abort-safe',
+      signal: first.signal,
+      timeoutMs: 30_000,
+    })
+    const b = apiFetch<{ ok: boolean }>('/api/v1/shared', {
+      dedupeKey: 'shared-abort-safe',
+      signal: second.signal,
+      timeoutMs: 30_000,
+    })
+
+    first.abort()
+    await expect(a).rejects.toMatchObject({ kind: 'abort' })
+
+    await vi.advanceTimersByTimeAsync(100)
+    await expect(b).resolves.toEqual({ ok: true, starts: 1 })
+    expect(starts).toBe(1)
+  })
+
+  it('cancels the shared request only after the last subscriber aborts', async () => {
+    let aborted = false
+    vi.stubGlobal(
+      'fetch',
+      vi.fn((_url: string, init?: RequestInit) => {
+        return new Promise<Response>((_resolve, reject) => {
+          init?.signal?.addEventListener(
+            'abort',
+            () => {
+              aborted = true
+              reject(new DOMException('Aborted', 'AbortError'))
+            },
+            { once: true },
+          )
+        })
+      }),
+    )
+
+    const first = new AbortController()
+    const second = new AbortController()
+    const a = apiFetch('/api/v1/shared', {
+      dedupeKey: 'shared-last-abort',
+      signal: first.signal,
+      timeoutMs: 30_000,
+    })
+    const b = apiFetch('/api/v1/shared', {
+      dedupeKey: 'shared-last-abort',
+      signal: second.signal,
+      timeoutMs: 30_000,
+    })
+
+    first.abort()
+    await expect(a).rejects.toMatchObject({ kind: 'abort' })
+    expect(aborted).toBe(false)
+
+    second.abort()
+    await expect(b).rejects.toMatchObject({ kind: 'abort' })
+    expect(aborted).toBe(true)
+  })
+
+  it('survives a Strict Mode style remount: aborted first consumer, fresh second consumer', async () => {
+    let starts = 0
+    vi.stubGlobal(
+      'fetch',
+      vi.fn((_url: string, init?: RequestInit) => {
+        starts += 1
+        return new Promise<Response>((resolve, reject) => {
+          const timer = setTimeout(() => {
+            resolve(
+              new Response(JSON.stringify({ starts }), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+              }),
+            )
+          }, 50)
+          init?.signal?.addEventListener(
+            'abort',
+            () => {
+              clearTimeout(timer)
+              reject(new DOMException('Aborted', 'AbortError'))
+            },
+            { once: true },
+          )
+        })
+      }),
+    )
+
+    // Mount #1
+    const first = new AbortController()
+    const pendingFirst = apiFetch<{ starts: number }>('/api/v1/seasons', {
+      dedupeKey: 'seasons',
+      signal: first.signal,
+      timeoutMs: 30_000,
+    })
+
+    // Strict Mode unmount cancels the first subscription (sole subscriber → shared abort)
+    first.abort()
+    await expect(pendingFirst).rejects.toMatchObject({ kind: 'abort' })
+
+    // Remount starts a fresh consumer — must not inherit the aborted request
+    const second = new AbortController()
+    const pendingSecond = apiFetch<{ starts: number }>('/api/v1/seasons', {
+      dedupeKey: 'seasons',
+      signal: second.signal,
+      timeoutMs: 30_000,
+    })
+
+    await vi.advanceTimersByTimeAsync(50)
+    await expect(pendingSecond).resolves.toEqual({ starts: 2 })
+    expect(starts).toBe(2)
+  })
+
+  it('allows an explicit retry after the prior request settles', async () => {
+    let starts = 0
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async () => {
+        starts += 1
+        return new Response(JSON.stringify({ starts }), {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        })
+      }),
+    )
+
+    await expect(apiFetch('/api/v1/retry', { dedupeKey: 'retry-once' })).resolves.toEqual({
+      starts: 1,
+    })
+    await expect(apiFetch('/api/v1/retry', { dedupeKey: 'retry-once' })).resolves.toEqual({
+      starts: 2,
+    })
+    expect(starts).toBe(2)
+  })
+
+  it('maps HTTP errors without raw status jargon in userFacingError', async () => {
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async () =>
+        new Response(JSON.stringify({ error: 'upstream failed', stale: true }), {
+          status: 502,
+          headers: { 'Content-Type': 'application/json' },
+        }),
+      ),
+    )
+
+    try {
+      await apiFetch('/api/v1/fail')
+      expect.unreachable('should throw')
+    } catch (err) {
+      expect(err).toBeInstanceOf(ApiError)
+      expect((err as ApiError).stale).toBe(true)
+      expect(userFacingError(err)).not.toMatch(/502|API /)
+      expect(userFacingError(err)).toMatch(/cached|Retry/i)
+    }
+  })
+
+  it('uses the default primary-route timeout', () => {
+    expect(DEFAULT_FETCH_TIMEOUT_MS).toBe(15_000)
+  })
+})

frontend/src/test/h2h.test.ts

@@ -18,6 +18,7 @@ function driver(over: Partial<ChampHubDriver>): ChampHubDriver {
     cumulative: [],
     teammate_wins: 9,
     teammate_losses: 1,
+    round_positions: [],
     ...over,
   }
 }

frontend/src/test/liveState.test.ts

@@ -0,0 +1,183 @@
+import { describe, expect, it } from 'vitest'
+import {
+  allowsLiveInterpretations,
+  deriveLivePhase,
+  effectiveFeedHealth,
+  isReadOnlyPhase,
+  rendersSnapshot,
+  terminalSessionStatus,
+  type LiveStateInputs,
+} from '../lib/liveState'
+
+const base: LiveStateInputs = {
+  transport: 'connecting',
+  isLive: false,
+  hasActiveSnapshot: false,
+  hasArchive: false,
+  archiveMode: false,
+  sessionEndedCleanly: false,
+  wasLive: false,
+  stateLoaded: false,
+}
+
+describe('terminalSessionStatus', () => {
+  it('recognizes genuine session-end statuses', () => {
+    for (const s of ['Finished', 'Finalised', 'Finalized', 'ENDED', 'Aborted']) {
+      expect(terminalSessionStatus(s)).toBe(true)
+    }
+  })
+
+  it('treats still-running / unknown statuses as non-terminal', () => {
+    for (const s of ['Started', 'Resumed', 'Inactive', '', undefined, null]) {
+      expect(terminalSessionStatus(s)).toBe(false)
+    }
+  })
+})
+
+describe('deriveLivePhase transitions', () => {
+  it('connecting: cold start with the feed still opening', () => {
+    expect(deriveLivePhase({ ...base, transport: 'connecting' })).toBe('connecting')
+  })
+
+  it('connecting → live once a session snapshot arrives', () => {
+    expect(
+      deriveLivePhase({
+        ...base,
+        transport: 'connected',
+        isLive: true,
+        hasActiveSnapshot: true,
+      }),
+    ).toBe('live')
+  })
+
+  it('live → disconnected when the SSE transport drops mid-session', () => {
+    expect(
+      deriveLivePhase({
+        ...base,
+        transport: 'disconnected',
+        isLive: true,
+        hasActiveSnapshot: true,
+        wasLive: true,
+      }),
+    ).toBe('disconnected')
+  })
+
+  it('live → settling when the session ends with a terminal status', () => {
+    // Feed reports is_live=false, transport healthy, retained snapshot carries a
+    // terminal SessionStatus → the session genuinely finished.
+    expect(
+      deriveLivePhase({
+        ...base,
+        transport: 'connected',
+        isLive: false,
+        hasArchive: true,
+        sessionEndedCleanly: true,
+        wasLive: true,
+      }),
+    ).toBe('settling')
+  })
+
+  it('live → disconnected (NOT settling) when the FIA feed drops but status is non-terminal', () => {
+    // This is the P0 case: server deactivate() moved a still-active snapshot to
+    // last_snapshot with is_live=false but a non-terminal SessionStatus. The
+    // browser transport is healthy. We must warn + retain, never settle/archive.
+    expect(
+      deriveLivePhase({
+        ...base,
+        transport: 'connected',
+        isLive: false,
+        hasArchive: true,
+        sessionEndedCleanly: false,
+        wasLive: true,
+      }),
+    ).toBe('disconnected')
+  })
+
+  it('a retained non-terminal snapshot on cold load is disconnected, not settling', () => {
+    expect(
+      deriveLivePhase({
+        ...base,
+        transport: 'connected',
+        isLive: false,
+        hasArchive: true,
+        sessionEndedCleanly: false,
+        wasLive: false,
+      }),
+    ).toBe('disconnected')
+  })
+
+  it('settling → archive when the user explicitly opens the read-only snapshot', () => {
+    expect(
+      deriveLivePhase({
+        ...base,
+        transport: 'connected',
+        isLive: false,
+        hasArchive: true,
+        sessionEndedCleanly: true,
+        archiveMode: true,
+      }),
+    ).toBe('archive')
+  })
+
+  it('archive mode wins over an active session (user-chosen read-only view)', () => {
+    expect(
+      deriveLivePhase({
+        ...base,
+        transport: 'connected',
+        isLive: true,
+        hasActiveSnapshot: true,
+        hasArchive: true,
+        archiveMode: true,
+      }),
+    ).toBe('archive')
+  })
+
+  it('inactive when there is no session and nothing retained', () => {
+    expect(deriveLivePhase({ ...base, transport: 'connected', stateLoaded: true })).toBe('inactive')
+  })
+
+  it('leaves connecting for inactive once the initial state resolves, even mid-handshake', () => {
+    // connecting → inactive: the SSE transport handshake is still pending
+    // (transport === "connecting") but the initial live-state query resolved as
+    // idle, so we must not spin on "connecting…" forever.
+    expect(deriveLivePhase({ ...base, transport: 'connecting', stateLoaded: true })).toBe('inactive')
+  })
+})
+
+describe('phase capability helpers', () => {
+  it('renders the snapshot surface only for live/disconnected/archive', () => {
+    expect(rendersSnapshot('live')).toBe(true)
+    expect(rendersSnapshot('disconnected')).toBe(true)
+    expect(rendersSnapshot('archive')).toBe(true)
+    expect(rendersSnapshot('settling')).toBe(false)
+    expect(rendersSnapshot('inactive')).toBe(false)
+    expect(rendersSnapshot('connecting')).toBe(false)
+  })
+
+  it('allows live-only interpretations only while the session is moving', () => {
+    expect(allowsLiveInterpretations('live')).toBe(true)
+    expect(allowsLiveInterpretations('disconnected')).toBe(true)
+    // A frozen archive frame must never present live-only interpretations.
+    expect(allowsLiveInterpretations('archive')).toBe(false)
+    expect(allowsLiveInterpretations('settling')).toBe(false)
+  })
+
+  it('marks archive as the read-only phase', () => {
+    expect(isReadOnlyPhase('archive')).toBe(true)
+    expect(isReadOnlyPhase('live')).toBe(false)
+    expect(isReadOnlyPhase('disconnected')).toBe(false)
+  })
+})
+
+describe('effectiveFeedHealth', () => {
+  it('downgrades a still-open SSE to reconnecting while phase is disconnected', () => {
+    expect(effectiveFeedHealth('connected', 'disconnected')).toBe('disconnected')
+    expect(effectiveFeedHealth('connecting', 'disconnected')).toBe('disconnected')
+  })
+
+  it('preserves transport when the session phase is live or settling', () => {
+    expect(effectiveFeedHealth('connected', 'live')).toBe('connected')
+    expect(effectiveFeedHealth('connected', 'settling')).toBe('connected')
+    expect(effectiveFeedHealth('error', 'disconnected')).toBe('error')
+  })
+})

frontend/src/test/preview.test.ts

@@ -54,6 +54,7 @@ const hubDriver = (over: Partial<ChampHubDriver>): ChampHubDriver => ({
   poles: 4,
   form: [25],
   cumulative: [200],
+  round_positions: [1],
   teammate_wins: 9,
   teammate_losses: 1,
   ...over,

frontend/src/test/replayMap.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest'
+import { isReplayMapAvailable } from '../lib/replayMap'
+import type { ReplayFramesResponse, TrackOutline } from '../types'
+
+const outline: TrackOutline = {
+  circuit_key: 1,
+  bounds: { minX: 0, maxX: 100, minY: 0, maxY: 100 },
+  points: [{ x: 0, y: 0 }],
+}
+
+const replay: ReplayFramesResponse = {
+  session_key: 1,
+  interval_ms: 5000,
+  start_time: '2025-05-25T13:00:00Z',
+  frames: [
+    { t: 0, cars: {} },
+    { t: 5000, cars: {} },
+  ],
+}
+
+describe('isReplayMapAvailable', () => {
+  it('returns true when frames and outline are present', () => {
+    expect(isReplayMapAvailable(replay, outline, false)).toBe(true)
+  })
+
+  it('returns false when frames are sparse', () => {
+    expect(isReplayMapAvailable({ ...replay, frames: [{ t: 0, cars: {} }] }, outline, false)).toBe(false)
+  })
+
+  it('returns false on query error', () => {
+    expect(isReplayMapAvailable(replay, outline, true)).toBe(false)
+  })
+})

frontend/src/test/rivalry.test.ts

@@ -0,0 +1,71 @@
+import { describe, it, expect } from 'vitest'
+import { gapSeries, h2hTally, lastRounds } from '../lib/rivalry'
+
+describe('gapSeries', () => {
+  it('computes per-round a − b', () => {
+    expect(gapSeries([25, 43, 68], [18, 36, 54])).toEqual([7, 7, 14])
+  })
+
+  it('handles negative gaps (b ahead)', () => {
+    expect(gapSeries([10, 20], [18, 36])).toEqual([-8, -16])
+  })
+
+  it('truncates to the shorter series', () => {
+    expect(gapSeries([25, 43, 68], [18])).toEqual([7])
+    expect(gapSeries([], [18, 36])).toEqual([])
+  })
+})
+
+describe('h2hTally', () => {
+  it('tallies lower-position wins per round', () => {
+    const t = h2hTally([1, 2, 1], [2, 1, 3], ['R1', 'R2', 'R3'])
+    expect(t.a).toBe(2)
+    expect(t.b).toBe(1)
+    expect(t.skipped).toBe(0)
+    expect(t.rounds.map((r) => r.winner)).toEqual(['a', 'b', 'a'])
+    expect(t.rounds[0]).toEqual({ round: 1, label: 'R1', posA: 1, posB: 2, winner: 'a' })
+  })
+
+  it('skips rounds where either driver has no position', () => {
+    // R2: a missing (0). R3: b missing (0). Only R1 and R4 count.
+    const t = h2hTally([1, 0, 5, 3], [4, 2, 0, 1], ['R1', 'R2', 'R3', 'R4'])
+    expect(t.a).toBe(1)
+    expect(t.b).toBe(1)
+    expect(t.skipped).toBe(2)
+    expect(t.rounds.map((r) => r.round)).toEqual([1, 4])
+  })
+
+  it('handles arrays of different lengths (missing tail = skipped)', () => {
+    const t = h2hTally([1, 2, 3], [2], ['R1', 'R2', 'R3'])
+    expect(t.a).toBe(1)
+    expect(t.b).toBe(0)
+    expect(t.skipped).toBe(2)
+  })
+
+  it('skips equal positions defensively and falls back on labels', () => {
+    const t = h2hTally([2, 1], [2, 3], ['R1'])
+    expect(t.a).toBe(1)
+    expect(t.b).toBe(0)
+    expect(t.skipped).toBe(1)
+    expect(t.rounds[0].label).toBe('R2')
+  })
+
+  it('returns an empty tally for empty inputs', () => {
+    const t = h2hTally([], [], [])
+    expect(t).toEqual({ a: 0, b: 0, rounds: [], skipped: 0 })
+  })
+})
+
+describe('lastRounds', () => {
+  it('returns the last n counted rounds in order', () => {
+    const t = h2hTally([1, 1, 1, 2, 1, 1, 2], [2, 2, 2, 1, 2, 2, 1], [])
+    const last = lastRounds(t, 5)
+    expect(last).toHaveLength(5)
+    expect(last.map((r) => r.round)).toEqual([3, 4, 5, 6, 7])
+  })
+
+  it('returns fewer when the tally has fewer counted rounds', () => {
+    const t = h2hTally([1, 0], [2, 0], [])
+    expect(lastRounds(t, 5)).toHaveLength(1)
+  })
+})

frontend/src/test/route-resilience.test.tsx

@@ -0,0 +1,102 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { render, screen, waitFor, fireEvent } from '@testing-library/react'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { RouterProvider, createRouter, createRootRoute, createRoute } from '@tanstack/react-router'
+import { DriverProfilePage } from '../pages/DriverProfilePage'
+import { ApiError } from '../lib/fetch'
+import type { DriverSummary } from '../types'
+
+vi.mock('../api', () => ({
+  fetchSeasons: vi.fn(),
+  fetchDriverSummary: vi.fn(),
+}))
+
+import { fetchSeasons, fetchDriverSummary } from '../api'
+
+const mockFetchSeasons = vi.mocked(fetchSeasons)
+const mockFetchSummary = vi.mocked(fetchDriverSummary)
+
+const summary: DriverSummary = {
+  season: 2025,
+  driver_number: 1,
+  name_acronym: 'VER',
+  full_name: 'Max Verstappen',
+  team_name: 'Red Bull',
+  team_colour: '3671c6',
+  headshot_url: '',
+  points: 50,
+  position: 1,
+  wins: 2,
+  podiums: 2,
+  poles: 1,
+  form: [25, 25],
+  cumulative: [25, 50],
+  round_labels: ['R1', 'R2'],
+  rounds: [],
+  source: 'local',
+  enrichment: 'limited',
+}
+
+function renderPage(props: { driverNumber: number; year?: number }) {
+  const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+  const rootRoute = createRootRoute({
+    component: () => (
+      <QueryClientProvider client={queryClient}>
+        <DriverProfilePage driverNumber={props.driverNumber} year={props.year} />
+      </QueryClientProvider>
+    ),
+  })
+  const indexRoute = createRoute({
+    getParentRoute: () => rootRoute,
+    path: '/',
+    component: () => null,
+  })
+  const router = createRouter({ routeTree: rootRoute.addChildren([indexRoute]) })
+  return render(<RouterProvider router={router} />)
+}
+
+describe('DriverProfilePage resilience', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockFetchSeasons.mockResolvedValue([2025])
+  })
+
+  it('leaves loading after a timeout error and offers retry', async () => {
+    mockFetchSummary.mockRejectedValue(
+      new ApiError('timeout', 'Request timed out', {
+        userMessage: 'This request took too long. Check your connection, then retry.',
+      }),
+    )
+
+    renderPage({ driverNumber: 1, year: 2025 })
+
+    await waitFor(() => {
+      expect(screen.getByTestId('driver-profile-error')).toBeInTheDocument()
+    })
+    expect(screen.queryByTestId('driver-profile-loading')).not.toBeInTheDocument()
+    expect(screen.getByRole('button', { name: 'Retry' })).toBeInTheDocument()
+    expect(screen.getByTestId('driver-profile-error')).toHaveTextContent(/took too long/i)
+  })
+
+  it('dedupes concurrent retries via a single refetch gate', async () => {
+    let calls = 0
+    mockFetchSummary.mockImplementation(async () => {
+      calls += 1
+      if (calls === 1) {
+        throw new ApiError('http', 'boom', { status: 500 })
+      }
+      return summary
+    })
+
+    renderPage({ driverNumber: 1, year: 2025 })
+    await waitFor(() => expect(screen.getByTestId('driver-profile-error')).toBeInTheDocument())
+
+    const retry = screen.getByRole('button', { name: 'Retry' })
+    fireEvent.click(retry)
+    fireEvent.click(retry)
+
+    await waitFor(() => expect(screen.getByTestId('driver-profile')).toBeInTheDocument())
+    expect(calls).toBe(2)
+    expect(screen.getByTestId('driver-profile-limited')).toBeInTheDocument()
+  })
+})

frontend/src/test/routeSearch.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'vitest'
+import { parseRaceHubSearch, parseWeekendSearch, weekendFocusSearch } from '../lib/routeSearch'
+
+describe('routeSearch', () => {
+  it('parses positive weekend meeting/session keys and drops invalid values', () => {
+    expect(parseWeekendSearch({ meeting_key: '1229', session_key: '9000' })).toEqual({
+      meeting_key: 1229,
+      session_key: 9000,
+    })
+    expect(parseWeekendSearch({ meeting_key: '0', session_key: '-1', foo: 'bar' })).toEqual({})
+    expect(parseWeekendSearch({})).toEqual({})
+  })
+
+  it('parses race-hub session keys', () => {
+    expect(parseRaceHubSearch({ session_key: '9472' })).toEqual({ session_key: 9472 })
+    expect(parseRaceHubSearch({ session_key: 'nope' })).toEqual({})
+  })
+
+  it('builds Weekend focus search for Race Hub returns', () => {
+    expect(weekendFocusSearch(1229, 9000)).toEqual({ meeting_key: 1229, session_key: 9000 })
+    expect(weekendFocusSearch(null, 9000)).toEqual({ session_key: 9000 })
+    expect(weekendFocusSearch(1229, undefined)).toEqual({ meeting_key: 1229 })
+  })
+})

frontend/src/test/sessionState.test.ts

@@ -0,0 +1,146 @@
+import { describe, it, expect } from 'vitest'
+import {
+  resolveSessionState,
+  sessionState,
+  sessionStateLabel,
+} from '../lib/sessionState'
+import type {
+  ContextAvailability,
+  ContextSession,
+  DatasetInfo,
+  Session,
+  WeekendContext,
+  WeekendSession,
+} from '../types'
+
+const NOW = new Date('2025-06-01T00:00:00Z')
+
+function mk(
+  overrides: Partial<Session>,
+  source: WeekendSession['source'],
+  datasets: Record<string, DatasetInfo> = {},
+): WeekendSession {
+  return {
+    session: {
+      session_key: 1,
+      session_name: 'Race',
+      session_type: 'Race',
+      meeting_key: 1,
+      date_start: '2025-05-25T13:00:00+00:00',
+      date_end: '2025-05-25T15:00:00+00:00',
+      gmt_offset: '00:00:00',
+      ...overrides,
+    },
+    source,
+    datasets,
+  }
+}
+
+const FULL: Record<string, DatasetInfo> = Object.fromEntries(
+  [
+    'meeting',
+    'session',
+    'drivers',
+    'results',
+    'starting_grid',
+    'stints',
+    'pit_stops',
+    'positions',
+    'race_control',
+    'weather',
+    'laps',
+  ].map((k) => [k, { status: 'available', source: 'local', count: 1 }]),
+)
+
+function availability(overrides: Partial<ContextAvailability> = {}): ContextAvailability {
+  return {
+    schedule: 'available',
+    live_transport: 'unknown',
+    live_session: 'inactive',
+    archive: 'unavailable',
+    local_analysis: 'complete',
+    freshness: 'fresh',
+    limitations: [],
+    ...overrides,
+  }
+}
+
+function contextSession(
+  session: Session,
+  avail: Partial<ContextAvailability> = {},
+): ContextSession {
+  return { session, availability: availability(avail) }
+}
+
+function context(overrides: Partial<WeekendContext> = {}): WeekendContext {
+  return {
+    temporal_state: 'post_weekend',
+    championship_round: 1,
+    total_championship_rounds: 1,
+    ...overrides,
+  }
+}
+
+describe('sessionState', () => {
+  it('marks a future session as upcoming', () => {
+    const s = mk({ date_start: '2099-05-25T13:00:00+00:00', date_end: '2099-05-25T15:00:00+00:00' }, 'none')
+    expect(sessionState(s, NOW)).toBe('upcoming')
+  })
+
+  it('does not mark Live from schedule alone', () => {
+    const start = new Date(NOW.getTime() - 60_000).toISOString()
+    const end = new Date(NOW.getTime() + 60_000).toISOString()
+    const s = mk({ date_start: start, date_end: end }, 'none')
+    expect(sessionState(s, NOW)).toBe('preparing')
+  })
+
+  it('marks Live only when Weekend Context active identity matches', () => {
+    const start = new Date(NOW.getTime() - 60_000).toISOString()
+    const end = new Date(NOW.getTime() + 60_000).toISOString()
+    const s = mk({ session_key: 42, date_start: start, date_end: end }, 'none')
+    const ctx = context({
+      temporal_state: 'session_live',
+      active_session: contextSession(s.session, { live_session: 'active' }),
+    })
+    expect(resolveSessionState({ weekendSession: s, context: ctx, now: NOW })).toBe('live')
+  })
+
+  it('marks a finished session with full local data as ready', () => {
+    const s = mk({}, 'local', FULL)
+    expect(sessionState(s, NOW)).toBe('ready')
+  })
+
+  it('marks a finished session with no data as preparing', () => {
+    const s = mk({}, 'none', {})
+    expect(sessionState(s, NOW)).toBe('preparing')
+  })
+
+  it('marks a finished session with partial data as partial', () => {
+    const s = mk({}, 'partial', { drivers: { status: 'available', source: 'local', count: 20 } })
+    expect(sessionState(s, NOW)).toBe('partial')
+  })
+
+  it('marks unavailable from context availability', () => {
+    const s = mk({ session_key: 7 }, 'none')
+    const ctx = context({
+      previous_completed_session: contextSession(s.session, {
+        local_analysis: 'unavailable',
+      }),
+    })
+    expect(resolveSessionState({ weekendSession: s, context: ctx, now: NOW })).toBe(
+      'unavailable',
+    )
+  })
+
+  it('marks a cancelled session as cancelled', () => {
+    const s = mk({}, 'cancelled')
+    expect(sessionState(s, NOW)).toBe('cancelled')
+  })
+
+  it('uses user language labels rather than coverage counts', () => {
+    expect(sessionStateLabel('ready')).toBe('Ready')
+    expect(sessionStateLabel('upcoming')).toBe('Upcoming')
+    expect(sessionStateLabel('partial')).toBe('Partial')
+    expect(sessionStateLabel('unavailable')).toBe('Unavailable')
+  })
+})

frontend/src/test/simulator.test.ts

@@ -29,6 +29,7 @@ function driver(over: Partial<ChampHubDriver>): ChampHubDriver {
     poles: 0,
     form: [],
     cumulative: [],
+    round_positions: [],
     teammate_wins: 0,
     teammate_losses: 0,
     ...over,

frontend/src/test/weekendContext.test.ts

@@ -0,0 +1,223 @@
+import { describe, it, expect } from 'vitest'
+import {
+  analysisSessionKey,
+  briefingItems,
+  championshipImpact,
+  hasLocalAnalysis,
+  meetingIdentity,
+  podiumFromResults,
+  resolveViewState,
+} from '../lib/weekendContext'
+import type {
+  ChampionshipHub,
+  ContextAvailability,
+  ContextSession,
+  EnrichedResult,
+  Meeting,
+  NewsItem,
+  Session,
+  TemporalState,
+  WeekendContext,
+} from '../types'
+
+function availability(overrides: Partial<ContextAvailability> = {}): ContextAvailability {
+  return {
+    schedule: 'available',
+    live_transport: 'unknown',
+    live_session: 'inactive',
+    archive: 'unavailable',
+    local_analysis: 'complete',
+    freshness: 'fresh',
+    limitations: [],
+    ...overrides,
+  }
+}
+
+function meeting(overrides: Partial<Meeting> = {}): Meeting {
+  return {
+    meeting_key: 1,
+    meeting_name: 'British Grand Prix',
+    meeting_official_name: 'FORMULA 1 BRITISH GRAND PRIX',
+    location: 'Silverstone',
+    country_name: 'United Kingdom',
+    country_code: 'GBR',
+    country_flag: '',
+    circuit_key: 2,
+    circuit_short_name: 'Silverstone',
+    date_start: '2026-07-03T09:00:00Z',
+    date_end: '2026-07-05T16:00:00Z',
+    year: 2026,
+    ...overrides,
+  }
+}
+
+function session(overrides: Partial<Session> = {}): Session {
+  return {
+    session_key: 11,
+    session_name: 'Race',
+    session_type: 'Race',
+    meeting_key: 1,
+    date_start: '2026-07-05T14:00:00Z',
+    date_end: '2026-07-05T16:00:00Z',
+    gmt_offset: '',
+    ...overrides,
+  }
+}
+
+function ctxSession(overrides: Partial<ContextSession> = {}): ContextSession {
+  return {
+    session: session(),
+    meeting: meeting(),
+    availability: availability(),
+    ...overrides,
+  }
+}
+
+function context(overrides: Partial<WeekendContext> = {}): WeekendContext {
+  return {
+    season: 2026,
+    temporal_state: 'between_weekends',
+    championship_round: 1,
+    total_championship_rounds: 24,
+    ...overrides,
+  }
+}
+
+describe('resolveViewState', () => {
+  const cases: Array<[TemporalState, string]> = [
+    ['no_season', 'no_season'],
+    ['between_weekends', 'between_weekends'],
+    ['pre_session', 'pre_session'],
+    ['session_live', 'session_live'],
+    ['session_settling', 'session_settling'],
+    ['between_sessions', 'between_sessions'],
+    ['post_weekend', 'post_weekend'],
+    ['season_complete', 'season_complete'],
+  ]
+
+  it.each(cases)('maps canonical temporal_state %s to view %s', (temporal, expected) => {
+    expect(resolveViewState(context({ temporal_state: temporal }))).toBe(expected)
+  })
+
+  it('treats an unknown/absent temporal_state as no_season rather than inventing a state', () => {
+    expect(resolveViewState(context({ temporal_state: 'garbage' as TemporalState }))).toBe('no_season')
+  })
+})
+
+describe('analysisSessionKey', () => {
+  it('prefers the default analysis session', () => {
+    const ctx = context({
+      default_analysis_session: ctxSession({ session: session({ session_key: 32 }) }),
+      previous_completed_session: ctxSession({ session: session({ session_key: 11 }) }),
+    })
+    expect(analysisSessionKey(ctx)).toBe(32)
+  })
+
+  it('falls back to the previous completed session', () => {
+    const ctx = context({
+      previous_completed_session: ctxSession({ session: session({ session_key: 11 }) }),
+    })
+    expect(analysisSessionKey(ctx)).toBe(11)
+  })
+
+  it('returns undefined when there is no analysable session', () => {
+    expect(analysisSessionKey(context())).toBeUndefined()
+  })
+
+  it('returns undefined for a zero/synthetic session key', () => {
+    const ctx = context({
+      previous_completed_session: ctxSession({ session: session({ session_key: 0 }) }),
+    })
+    expect(analysisSessionKey(ctx)).toBeUndefined()
+  })
+})
+
+describe('hasLocalAnalysis', () => {
+  it('is true for complete or partial local analysis', () => {
+    expect(hasLocalAnalysis(ctxSession({ availability: availability({ local_analysis: 'complete' }) }))).toBe(true)
+    expect(hasLocalAnalysis(ctxSession({ availability: availability({ local_analysis: 'partial' }) }))).toBe(true)
+  })
+
+  it('is false for pending/not_applicable/absent', () => {
+    expect(hasLocalAnalysis(ctxSession({ availability: availability({ local_analysis: 'pending' }) }))).toBe(false)
+    expect(hasLocalAnalysis(ctxSession({ availability: availability({ local_analysis: 'not_applicable' }) }))).toBe(false)
+    expect(hasLocalAnalysis(undefined)).toBe(false)
+  })
+})
+
+describe('meetingIdentity', () => {
+  it('derives a short name and tolerates partial fields', () => {
+    const id = meetingIdentity(meeting({ meeting_name: 'Monaco Grand Prix', circuit_short_name: '', location: 'Monaco' }))
+    expect(id?.short_name).toBe('Monaco')
+    expect(id?.circuit_short_name).toBe('Monaco')
+  })
+
+  it('returns undefined for an absent meeting', () => {
+    expect(meetingIdentity(undefined)).toBeUndefined()
+  })
+
+  it('drops empty date strings', () => {
+    const id = meetingIdentity(meeting({ date_start: '', date_end: '' }))
+    expect(id?.date_start).toBeUndefined()
+    expect(id?.date_end).toBeUndefined()
+  })
+})
+
+describe('championshipImpact', () => {
+  const hub: ChampionshipHub = {
+    season: 2026,
+    round: 2,
+    total_rounds: 24,
+    rounds_left: 22,
+    last_race: 'British GP',
+    round_labels: ['R1', 'R2'],
+    drivers: [
+      { driver_number: 1, name_acronym: 'VER', full_name: 'Max', team_name: 'RB', team_colour: '3671c6', points: 50, position: 1, wins: 2, podiums: 2, poles: 1, form: [], cumulative: [25, 50], teammate_wins: 0, teammate_losses: 0, round_positions: [] },
+      { driver_number: 4, name_acronym: 'NOR', full_name: 'Lando', team_name: 'McL', team_colour: 'ff8000', points: 40, position: 2, wins: 1, podiums: 2, poles: 0, form: [], cumulative: [18, 40], teammate_wins: 0, teammate_losses: 0, round_positions: [] },
+    ],
+    teams: [],
+  }
+
+  it('maps top-3 movers with deltas and a note', () => {
+    const impact = championshipImpact(hub)
+    expect(impact?.leaders).toHaveLength(2)
+    expect(impact?.leaders[0].delta).toBe(25)
+    expect(impact?.note).toContain('British GP')
+  })
+
+  it('returns undefined for an empty hub', () => {
+    expect(championshipImpact(undefined)).toBeUndefined()
+    expect(championshipImpact({ ...hub, drivers: [] })).toBeUndefined()
+  })
+})
+
+describe('briefingItems', () => {
+  it('caps at three items and maps fields', () => {
+    const news: NewsItem[] = Array.from({ length: 5 }, (_, i) => ({
+      source: 'src',
+      title: `Item ${i}`,
+      url: `https://x/${i}`,
+      fetched_at: '2026-07-06T00:00:00Z',
+      category: 'news',
+      og_image_url: 'img',
+    }))
+    const items = briefingItems(news)
+    expect(items).toHaveLength(3)
+    expect(items[0]).toMatchObject({ title: 'Item 0', image_url: 'img' })
+  })
+})
+
+describe('podiumFromResults', () => {
+  it('sorts by position, caps at three, and formats gaps', () => {
+    const results: EnrichedResult[] = [
+      { driver_number: 44, position: 2, name_acronym: 'HAM', full_name: 'Lewis', team_name: 'Ferrari', team_colour: 'e8002d', dnf: false, dns: false, dsq: false, duration: null, gap_to_leader: 5.123 } as EnrichedResult,
+      { driver_number: 1, position: 1, name_acronym: 'VER', full_name: 'Max', team_name: 'RB', team_colour: '3671c6', dnf: false, dns: false, dsq: false, duration: 5400, gap_to_leader: null } as EnrichedResult,
+      { driver_number: 16, position: 3, name_acronym: 'LEC', full_name: 'Charles', team_name: 'Ferrari', team_colour: 'e8002d', dnf: false, dns: false, dsq: false, duration: null, gap_to_leader: '+10.5' } as EnrichedResult,
+      { driver_number: 55, position: 4, name_acronym: 'SAI', full_name: 'Carlos', team_name: 'W', team_colour: 'fff', dnf: false, dns: false, dsq: false, duration: null, gap_to_leader: 20 } as EnrichedResult,
+    ]
+    const podium = podiumFromResults(results)
+    expect(podium.map((p) => p.name_acronym)).toEqual(['VER', 'HAM', 'LEC'])
+    expect(podium[1].gap).toBe('+5.123')
+    expect(podium[2].gap).toBe('+10.5')
+  })
+})

frontend/src/types.ts

@@ -391,6 +391,7 @@ export interface ChampHubDriver {
   poles: number
   form: number[]
   cumulative: number[]
+  round_positions: number[]
   teammate_wins: number
   teammate_losses: number
 }
@@ -445,6 +446,113 @@ export interface DriverSummary {
   cumulative: number[]
   round_labels: string[]
   rounds: DriverSummaryRound[]
+  /** Data origin: local domain DB or OpenF1 fallback. */
+  source?: 'local' | 'openf1'
+  /** Optional remote enrichment status — limited means profile still renders. */
+  enrichment?: 'full' | 'limited' | 'none'
+}
+
+// ── Weekend Context ──
+// Canonical local-first contract for the adaptive Weekend home, served verbatim
+// by /api/v1/weekend-context (backend story #72, internal/query/context.go).
+// The frontend consumes this shape as the single source of truth; view-model
+// derivation lives in lib/weekendContext.ts.
+
+// TemporalState mirrors query.TemporalState exactly (the JSON `temporal_state`).
+export type TemporalState =
+  | 'no_season'
+  | 'between_weekends'
+  | 'pre_session'
+  | 'session_live'
+  | 'session_settling'
+  | 'between_sessions'
+  | 'post_weekend'
+  | 'season_complete'
+
+// ContextAvailability mirrors query.ContextAvailability. Every field is present
+// in a canonical payload except the optional `observed_at`.
+export interface ContextAvailability {
+  /** Domain / FIA provenance: local | mixed | fia (additive; may be absent on older payloads). */
+  source?: string
+  schedule: string
+  live_transport: string
+  live_session: string
+  archive: string
+  local_analysis: string
+  freshness: string
+  observed_at?: string
+  limitations: string[]
+}
+
+// ContextSession mirrors query.ContextSession: a session identity coupled with
+// its meeting and structured availability contract.
+export interface ContextSession {
+  session: Session
+  meeting?: Meeting
+  availability: ContextAvailability
+}
+
+// WeekendContext mirrors query.WeekendContext (the canonical endpoint body).
+export interface WeekendContext {
+  season?: number
+  temporal_state: TemporalState
+  previous_meeting?: Meeting
+  focus_meeting?: Meeting
+  next_meeting?: Meeting
+  previous_completed_session?: ContextSession
+  active_session?: ContextSession
+  next_session?: ContextSession
+  default_analysis_session?: ContextSession
+  championship_round: number
+  total_championship_rounds: number
+}
+
+// ── Weekend view model (client-only) ──
+// The rendered Weekend home layers a small set of non-canonical UI states
+// (loading/error) plus supplementary data (championship movers, briefing) on top
+// of the canonical context. None of these are part of the #72 contract.
+export type WeekendViewState =
+  | 'loading'
+  | 'error'
+  | 'no_season'
+  | 'between_weekends'
+  | 'pre_session'
+  | 'session_live'
+  | 'session_settling'
+  | 'between_sessions'
+  | 'post_weekend'
+  | 'season_complete'
+
+export interface WeekendChampionshipMover {
+  position: number
+  driver_number: number
+  name_acronym: string
+  team_colour: string
+  points: number
+  delta?: number
+}
+
+export interface WeekendChampionshipImpact {
+  leaders: WeekendChampionshipMover[]
+  note?: string
+}
+
+export interface WeekendBriefingItem {
+  category?: string
+  title: string
+  url: string
+  source: string
+  published_at?: string
+  image_url?: string
+}
+
+export interface WeekendPodiumEntry {
+  position: number
+  driver_number: number
+  name_acronym: string
+  team_name: string
+  team_colour: string
+  gap: string
 }
 
 export interface NewsItem {

internal/api/cache.go

@@ -164,8 +164,8 @@ func (c *Cache) Get(key string) ([]byte, bool) {
 	if ttl > 0 {
 		age := time.Since(time.Unix(createdAt, 0))
 		if age > ttl {
-			// Expired — delete and return miss.
-			_, _ = c.db.Exec(`DELETE FROM cache WHERE key = ?`, key)
+			// Expired entries remain stored so get() can use them as a stale
+			// fallback if the live request fails. Prune() owns physical cleanup.
 			atomic.AddInt64(&c.stats.Misses, 1)
 			return nil, false
 		}

internal/api/client.go

@@ -1,6 +1,7 @@
 package api
 
 import (
+	"context"
 	"net/http"
 	"sync"
 	"sync/atomic"
@@ -26,8 +27,12 @@ type requestPacer struct {
 
 // wait blocks until this caller's reserved slot arrives.
 func (p *requestPacer) wait() {
+	_ = p.waitContext(context.Background())
+}
+
+func (p *requestPacer) waitContext(ctx context.Context) error {
 	if p == nil || p.interval <= 0 {
-		return
+		return nil
 	}
 	p.mu.Lock()
 	now := time.Now()
@@ -38,8 +43,18 @@ func (p *requestPacer) wait() {
 	p.next = p.next.Add(p.interval)
 	p.mu.Unlock()
 	if sleep > 0 {
-		time.Sleep(sleep)
+		timer := time.NewTimer(sleep)
+		defer timer.Stop()
+		select {
+		case <-timer.C:
+		case <-ctx.Done():
+			// Keep the unused reservation in the schedule. Blindly reclaiming an
+			// interval can collide with later callers that already reserved their
+			// wake times, releasing two requests simultaneously.
+			return ctx.Err()
 		}
+	}
+	return nil
 }
 
 type OpenF1Client struct {
@@ -56,6 +71,26 @@ type OpenF1Client struct {
 	staleFlag int32
 }
 
+// Scoped returns a lightweight request-scoped view of the client. Network,
+// pacing and cache resources are shared, while the stale fallback indicator is
+// deliberately not shared. Web handlers use this view so a stale fallback in
+// one concurrent HTTP request can never mark an unrelated response as stale.
+//
+// The legacy client-wide stale flag remains available for the TUI, whose loads
+// are intentionally aggregated into one navigation-level notice.
+func (c *OpenF1Client) Scoped() *OpenF1Client {
+	if c == nil {
+		return nil
+	}
+	return &OpenF1Client{
+		url:        c.url,
+		apiKey:     c.apiKey,
+		httpClient: c.httpClient,
+		cache:      c.cache,
+		pacer:      c.pacer,
+	}
+}
+
 func NewOpenF1Client(url string, timeout time.Duration) *OpenF1Client {
 	return &OpenF1Client{
 		url:        url,

internal/api/freshness_test.go

@@ -0,0 +1,123 @@
+package api
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"sync/atomic"
+	"testing"
+	"time"
+)
+
+func expireCacheEntry(t *testing.T, c *OpenF1Client, key string) {
+	t.Helper()
+	if _, err := c.cache.db.Exec(`UPDATE cache SET created_at = ? WHERE key = ?`, time.Now().Add(-48*time.Hour).Unix(), key); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestScopedClientReportsStaleFallbackWithoutMutatingParent(t *testing.T) {
+	year := time.Now().Year()
+	var fail atomic.Bool
+	upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if fail.Load() {
+			http.Error(w, "unavailable", http.StatusServiceUnavailable)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = fmt.Fprintf(w, `[{
+			"meeting_key": 1,
+			"meeting_name": "British Grand Prix",
+			"year": %d
+		}]`, year)
+	}))
+	defer upstream.Close()
+
+	client := NewOpenF1Client(upstream.URL, time.Second)
+	defer client.Close()
+	client.pacer.interval = 0
+	key := fmt.Sprintf("%s/v1/meetings?year=%d", upstream.URL, year)
+	_, _ = client.cache.db.Exec(`DELETE FROM cache WHERE key = ?`, key)
+	defer func() { _, _ = client.cache.db.Exec(`DELETE FROM cache WHERE key = ?`, key) }()
+
+	if _, err := client.GetMeetingsForYear(year); err != nil {
+		t.Fatalf("prime cache: %v", err)
+	}
+	expireCacheEntry(t, client, key)
+	fail.Store(true)
+
+	scoped := client.Scoped()
+	meetings, err := scoped.GetMeetingsForYear(year)
+	if err != nil || len(meetings) != 1 {
+		t.Fatalf("stale fallback = (%+v, %v)", meetings, err)
+	}
+	if !scoped.LastResponseWasStale() {
+		t.Fatal("scoped request did not report its stale fallback")
+	}
+	if client.LastResponseWasStale() {
+		t.Fatal("request-scoped fallback leaked into the parent client")
+	}
+}
+
+func TestScopedClientsDoNotLeakFreshnessAcrossConcurrentRequests(t *testing.T) {
+	year := time.Now().Year()
+	staleStarted := make(chan struct{})
+	releaseStale := make(chan struct{})
+	var failMeetings atomic.Bool
+	upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/v1/meetings":
+			if failMeetings.Load() {
+				close(staleStarted)
+				<-releaseStale
+				http.Error(w, "unavailable", http.StatusServiceUnavailable)
+				return
+			}
+			_, _ = fmt.Fprintf(w, `[{"meeting_key":1,"meeting_name":"British Grand Prix","year":%d}]`, year)
+		case "/v1/sessions":
+			_, _ = w.Write([]byte(`[{"session_key":11,"meeting_key":2,"session_name":"Race"}]`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer upstream.Close()
+
+	client := NewOpenF1Client(upstream.URL, 2*time.Second)
+	defer client.Close()
+	client.pacer.interval = 0
+	meetingKey := fmt.Sprintf("%s/v1/meetings?year=%d", upstream.URL, year)
+	sessionKey := upstream.URL + "/v1/sessions?meeting_key=2"
+	_, _ = client.cache.db.Exec(`DELETE FROM cache WHERE key IN (?, ?)`, meetingKey, sessionKey)
+	defer func() { _, _ = client.cache.db.Exec(`DELETE FROM cache WHERE key IN (?, ?)`, meetingKey, sessionKey) }()
+	if _, err := client.GetMeetingsForYear(year); err != nil {
+		t.Fatal(err)
+	}
+	expireCacheEntry(t, client, meetingKey)
+	failMeetings.Store(true)
+
+	staleClient := client.Scoped()
+	staleDone := make(chan error, 1)
+	go func() {
+		_, err := staleClient.GetMeetingsForYear(year)
+		staleDone <- err
+	}()
+	<-staleStarted
+
+	freshClient := client.Scoped()
+	if _, err := freshClient.GetSessionsForMeeting(2); err != nil {
+		t.Fatalf("fresh concurrent request: %v", err)
+	}
+	if freshClient.LastResponseWasStale() {
+		t.Fatal("fresh request inherited concurrent request's stale state")
+	}
+	close(releaseStale)
+	if err := <-staleDone; err != nil {
+		t.Fatalf("stale request: %v", err)
+	}
+	if !staleClient.LastResponseWasStale() {
+		t.Fatal("stale request lost its own freshness state")
+	}
+	if freshClient.LastResponseWasStale() || client.LastResponseWasStale() {
+		t.Fatal("stale state leaked after concurrent requests completed")
+	}
+}