feat(#76): harvest request-scoped availability and freshness truth

Backend-only re-cut of the #76 availability work onto main, stacked on the
canonical Weekend Context API. Adds request-scoped freshness reporting so
aggregate responses cannot report fresh when a component is stale, plus
local-first driver summary resolution and cache/pacing truth.

The frontend half of #76 is deliberately excluded: it is built on the
Weekend shell that failed owner review, including the full-width Partial
banner treatment. Availability presentation is re-cut with the shell in #89.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

.agents/harnesses.sh

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

@@ -1,32 +0,0 @@
-# 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

@@ -15,7 +15,6 @@ import type {
   Session,
   TrackOutline,
   Weekend,
-  WeekendContext,
 } from './types'
 
 export async function fetchRaceHub(sessionKey: number): Promise<RaceHub> {
@@ -115,19 +114,6 @@ export async function fetchWeekend(meetingKey: number): Promise<Weekend> {
   return res.json()
 }
 
-// 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.
-export async function fetchWeekendContext(): Promise<WeekendContext> {
-  const res = await fetch('/api/v1/weekend-context')
-  if (!res.ok) {
-    throw new Error(`API ${res.status}: ${res.statusText}`)
-  }
-  return res.json()
-}
-
 export async function fetchChampionshipHub(year?: number): Promise<ChampionshipHub> {
   const params = new URLSearchParams({ source: 'auto' })
   if (year) params.set('year', year.toString())

frontend/src/components/Nav.tsx

@@ -1,66 +1,55 @@
 import { Link } from '@tanstack/react-router'
-import { Compass, FileText, Home, Trophy } from 'lucide-react'
+import { useQuery } from '@tanstack/react-query'
+import { fetchLiveState } from '../api'
+import { isLiveSessionActive } from '../lib/live'
 
-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() {
+  const { data: liveState } = useQuery({
+    queryKey: ['live-state'],
+    queryFn: fetchLiveState,
+    staleTime: 5_000,
+    refetchInterval: 30_000,
+  })
+  const liveActive = isLiveSessionActive(liveState)
+
   return (
-    <>
+    <nav className="app-nav">
-      <header className="app-nav">
       <Link to="/" className="nav-logo">
         box<em>-</em>box
       </Link>
-        <nav className="nav-links" aria-label="Primary">
+      <div className="nav-links">
-          {PRIMARY.map(({ to, label, exact }) => (
+        <Link to="/" activeProps={{ className: 'active' }} activeOptions={{ exact: true }}>
-            <Link
+          Command
-              key={to}
-              to={to}
-              activeProps={{ className: 'active' }}
-              activeOptions={exact ? { exact: true } : undefined}
-            >
-              {label}
         </Link>
-          ))}
-        </nav>
-        <div className="nav-utility" role="toolbar" aria-label="Operator utilities">
         <Link
-            to="/admin"
+          to="/live"
-            className="nav-utility-link"
+          className={liveActive ? 'nav-live nav-live-on' : 'nav-live'}
-            activeProps={{ className: 'nav-utility-link active' }}
+          activeProps={{ className: 'active' }}
+          data-testid="nav-live"
+          data-live-active={liveActive ? 'true' : 'false'}
         >
+          {liveActive && <span className="nav-live-dot" aria-hidden="true" />}
+          Live
+          {liveActive && <span className="sr-only"> session active</span>}
+        </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' }}>
           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/live/RaceControlFeed.tsx

@@ -80,7 +80,9 @@ export function RaceControlFeed({ messages, driverInfo }: Props) {
     <section className="live-rc panel-glass">
       <div className="sec-header sticky-header">
         <span className="sec-title">Race Control</span>
-        {messages.length > 0 && <span className="sec-meta">{messages.length} messages</span>}
+        <span className="sec-meta" data-testid="rc-timezone">
+          {messages.length > 0 ? `${messages.length} messages · ` : ''}times UTC
+        </span>
       </div>
       {latest.length === 0 ? (
         <div className="missing-notice">No race control messages in the current live snapshot.</div>
@@ -102,7 +104,7 @@ export function RaceControlFeed({ messages, driverInfo }: Props) {
 
             return (
               <div className={`live-rc-row${flashClass}`} key={key}>
-                <span className="rc-time">{message.Time || '--:--'}</span>
+                <span className="rc-time" title="UTC">{message.Time || '--:--'}</span>
                 {message.Lap > 0 && <span className="rc-lap">L{message.Lap}</span>}
                 {message.Flag
                   ? <span className={`rc-flag ${rcFlagClass(message.Flag)}`}>{message.Flag}</span>

frontend/src/components/live/SessionBanner.tsx

@@ -38,9 +38,11 @@ export function SessionBanner({ isLive, isArchive = false, snapshot, rows, conne
           <div className="live-banner-meta">
             {display.advanceCount && <span>{display.advanceCount} advance</span>}
             {atRiskLabel && <span>{atRiskLabel}</span>}
-            <span>
+            {display.isRace && (
+              <span data-testid="live-lap-counter">
                 L<strong>{snapshot.CurrentLap || '-'}</strong>/<strong>{snapshot.TotalLaps || '-'}</strong>
               </span>
+            )}
             <span className={isLive ? 'live-state live-state-on' : 'live-state'}>{stateLabel}</span>
           </div>
         </div>

frontend/src/components/live/TimingTower.tsx

@@ -1,9 +1,10 @@
-import { useState, Fragment } from 'react'
+import { useState, useMemo, Fragment } from 'react'
 import { teamColor } from '../../utils'
 import { useAutoAnimate } from '@formkit/auto-animate/react'
 import type { LiveSessionMeta, LiveStintData } from '../../types'
 import type { LiveTimingRow } from '../../lib/live'
 import {
+  bestLapGaps,
   driverCode,
   liveSessionDisplay,
   positionDelta,
@@ -62,6 +63,10 @@ export function TimingTower({
   const isQuali = sessionDisplay.isQualifying || !isRace
   const columnCount = 7 + (isRace ? 3 : 0) + (isQuali ? 3 : 0)
 
+  // Practice/qualifying: derive a display-only gap to P1 from valid best laps
+  // when the upstream feed omits GapToLeader. Empty for races (feed is truth).
+  const practiceGaps = useMemo(() => bestLapGaps(isRace ? [] : rows), [isRace, rows])
+
   return (
     <div className="scroll-x">
       <table className="data-table live-tower" style={{ minWidth: 760 }}>
@@ -71,7 +76,7 @@ export function TimingTower({
             {isRace && <th>Δ</th>}
             <th>Driver</th>
             <th>Tyre</th>
-            <th>Last Lap</th>
+            <th className={isRace ? undefined : 'hide-mobile'}>Last Lap</th>
             <th
               className="interactive"
               onClick={() => setGapMode(g => g === 'interval' ? 'leader' : 'interval')}
@@ -81,10 +86,10 @@ export function TimingTower({
               {gapMode === 'interval' && isRace ? 'Interval' : 'Gap to P1'}
             </th>
             {isRace && <th>Trend</th>}
-            {isQuali && <th>S1</th>}
+            {isQuali && <th className="hide-mobile">S1</th>}
-            {isQuali && <th>S2</th>}
+            {isQuali && <th className="hide-mobile">S2</th>}
-            {isQuali && <th>S3</th>}
+            {isQuali && <th className="hide-mobile">S3</th>}
-            <th className="hide-mobile">Best</th>
+            <th className={isRace ? 'hide-mobile' : undefined}>Best</th>
             {isRace && <th className="hide-mobile r">Laps</th>}
             <th className="r"></th>
           </tr>
@@ -102,7 +107,15 @@ export function TimingTower({
               driver.Cutoff
             const showCutoffAfter = row.Position === sessionDisplay.cutoffPosition
 
-            const gapText = gapMode === 'interval' && isRace ? (driver.Interval || driver.GapToLeader) : driver.GapToLeader
+            let gapText: string
+            if (isRace) {
+              gapText = gapMode === 'interval' ? (driver.Interval || driver.GapToLeader) : driver.GapToLeader
+            } else if (driver.GapToLeader) {
+              gapText = driver.GapToLeader
+            } else {
+              const computed = practiceGaps[row.RacingNumber]
+              gapText = computed ? (computed.isLeader ? '—' : computed.gap) : ''
+            }
             const intervalAnnotation =
               gapMode === 'interval' && isRace && row.Position > 1
                 ? intervalMeaning(parseIntervalSeconds(gapText))
@@ -153,7 +166,10 @@ export function TimingTower({
                   <td>
                     <span className={`tyre-badge ${tyreClass(row.Tyre)}`}>{tyreLabel(row.Tyre)}</span>
                   </td>
-                  <td className={driver.LastLapOB ? 'mono lap-ob' : driver.LastLapPB ? 'mono lap-pb' : 'mono'}>
+                  <td className={[
+                    isRace ? '' : 'hide-mobile',
+                    driver.LastLapOB ? 'mono lap-ob' : driver.LastLapPB ? 'mono lap-pb' : 'mono',
+                  ].filter(Boolean).join(' ')}>
                     {driver.LastLapTime || '-'}
                   </td>
                   <td className="mono">
@@ -171,11 +187,14 @@ export function TimingTower({
                     </td>
                   )}
 
-                  {isQuali && <td>{renderSector(0)}</td>}
+                  {isQuali && <td className="hide-mobile">{renderSector(0)}</td>}
-                  {isQuali && <td>{renderSector(1)}</td>}
+                  {isQuali && <td className="hide-mobile">{renderSector(1)}</td>}
-                  {isQuali && <td>{renderSector(2)}</td>}
+                  {isQuali && <td className="hide-mobile">{renderSector(2)}</td>}
 
-                  <td className={`hide-mobile ${driver.BestLapOB ? 'mono lap-ob' : 'mono'}`}>
+                  <td className={[
+                    isRace ? 'hide-mobile' : '',
+                    driver.BestLapOB ? 'mono lap-ob' : 'mono',
+                  ].filter(Boolean).join(' ')}>
                     {driver.BestLapTime || '-'}
                   </td>
                   
@@ -208,6 +227,16 @@ export function TimingTower({
                                  <div className="mono">{driver.NumberOfLaps || 0}</div>
                               </div>
                             )}
+                            {!isRace && driver.Sectors?.some((sec) => sec?.Value) && (
+                              <div data-testid="expanded-sectors">
+                                 <div className="mono" style={{ color: 'var(--text-3)', fontSize: '10px', marginBottom: '4px' }}>SECTORS</div>
+                                 <div className="mono" style={{ display: 'flex', gap: '10px' }}>
+                                    {renderSector(0)}
+                                    {renderSector(1)}
+                                    {renderSector(2)}
+                                 </div>
+                              </div>
+                            )}
                             {driver.SpeedTrap && (
                               <div>
                                  <div className="mono" style={{ color: 'var(--text-3)', fontSize: '10px', marginBottom: '4px' }}>SPEED TRAP</div>

frontend/src/components/live/TyreDegPanel.tsx

@@ -52,7 +52,10 @@ function StintSparkline({ seconds }: { seconds: number[] }) {
 }
 
 export function TyreDegPanel({ rows, sessionType, pinned }: Props) {
-  const [collapsed, setCollapsed] = useState(false)
+  const isRace = isRaceSession(sessionType)
+  // In practice/qualifying deg trends are secondary — collapse by default so
+  // the Timing Tower stays above the fold. Races keep it open.
+  const [collapsed, setCollapsed] = useState(!isRace)
   const [stints, setStints] = useState<StintHistoryMap>({})
 
   // One lap-history update per received snapshot (rows is rebuilt per snapshot).
@@ -61,8 +64,6 @@ export function TyreDegPanel({ rows, sessionType, pinned }: Props) {
     setStints((prev) => recordStintSamples(prev, rows.map(stintInputFromRow)))
   }, [rows])
 
-  const isRace = isRaceSession(sessionType)
-
   const visible = useMemo(
     () =>
       rows.filter(

frontend/src/components/weekend/BetweenRacesView.tsx

@@ -1,152 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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
-  const analysisKey = 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

@@ -1,47 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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'
-
-/**
- * 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.
- */
-export function PreSessionView({ context, now }: { context: WeekendContext; now: Date }) {
-  const meeting = meetingIdentity(context.next_meeting ?? context.focus_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>
-
-      {meeting && (
-        <header className="wk-pre-head" data-testid="wk-pre-head">
-          <div className="wk-event-id">
-            <Flag code={meeting.country_code} flag={meeting.country_flag} />
-            <h1 className="wk-sessions-title">{meeting.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 />
-      </div>
-
-      <ChampionshipRoundStrip
-        round={context.championship_round}
-        total={context.total_championship_rounds}
-      />
-    </div>
-  )
-}

frontend/src/components/weekend/StatusViews.tsx

@@ -1,36 +0,0 @@
-import { Link } from '@tanstack/react-router'
-
-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({ message }: { message?: string }) {
-  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">{message ?? 'Something went wrong loading the weekend context.'}</p>
-    </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/shared.tsx

@@ -1,277 +0,0 @@
-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

@@ -1,89 +0,0 @@
-import { useEffect, useMemo, useState } from 'react'
-import { useQuery } from '@tanstack/react-query'
-import { fetchChampionshipHub, fetchNews, fetchWeekendContext } from '../api'
-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[]
-  now: Date
-}
-
-/**
- * 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: fetchWeekendContext,
-    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: () => fetchChampionshipHub(season),
-    enabled: canonicalReady,
-    staleTime: 60_000,
-  })
-
-  const newsQuery = useQuery({
-    queryKey: ['news', 6],
-    queryFn: () => fetchNews(6),
-    enabled: canonicalReady,
-    staleTime: 60_000,
-  })
-
-  const championship = useMemo(
-    () => championshipImpact(championshipQuery.data),
-    [championshipQuery.data],
-  )
-  const briefing = useMemo(() => briefingItems(newsQuery.data ?? []), [newsQuery.data])
-
-  let loadState: WeekendLoadState = 'loading'
-  if (contextQuery.isError) loadState = 'error'
-  else if (canonicalReady) loadState = 'ready'
-
-  return {
-    context: canonical,
-    loadState,
-    error: contextQuery.error instanceof Error ? contextQuery.error : undefined,
-    championship,
-    briefing,
-    now: nowDate,
-  }
-}

frontend/src/lib/live.ts

@@ -268,6 +268,63 @@ export function driverCode(row: LiveTimingRow): string {
   return row.Info?.Tla || row.RacingNumber
 }
 
+/**
+ * Parse an F1 lap-time string ("1:45.944", "45.944") into total seconds.
+ * Returns null for empty/invalid values so callers never invent a gap.
+ */
+export function parseLapTimeSeconds(value: string | null | undefined): number | null {
+  if (!value) return null
+  const match = value.trim().match(/^(?:(\d+):)?([0-5]?\d(?:\.\d+)?)$/)
+  if (!match) return null
+  const minutes = match[1] ? Number(match[1]) : 0
+  const seconds = Number(match[2])
+  if (!Number.isFinite(minutes) || !Number.isFinite(seconds)) return null
+  return minutes * 60 + seconds
+}
+
+export interface BestLapGap {
+  isLeader: boolean
+  gap: string
+}
+
+/**
+ * Display-only gap-to-P1 for practice/qualifying, derived from each driver's
+ * valid best lap. Only drivers with a parseable best lap get an entry, and the
+ * fastest is flagged as the leader. Never fabricates a gap from a missing or
+ * invalid lap — the upstream interval remains the source of truth for races.
+ */
+export function bestLapGaps(rows: ReadonlyArray<LiveTimingRow>): Record<string, BestLapGap> {
+  let leaderNumber = ''
+  let best = Infinity
+  for (const row of rows) {
+    const seconds = parseLapTimeSeconds(row.Driver.BestLapTime)
+    if (seconds === null) continue
+    if (seconds < best) {
+      best = seconds
+      leaderNumber = row.RacingNumber
+    }
+  }
+
+  const out: Record<string, BestLapGap> = {}
+  if (!Number.isFinite(best)) return out
+  for (const row of rows) {
+    const seconds = parseLapTimeSeconds(row.Driver.BestLapTime)
+    if (seconds === null) continue
+    out[row.RacingNumber] =
+      row.RacingNumber === leaderNumber
+        ? { isLeader: true, gap: '' }
+        : { isLeader: false, gap: `+${(seconds - best).toFixed(3)}` }
+  }
+  return out
+}
+
+/** True when the live feed reports an in-progress session with timing data. */
+export function isLiveSessionActive(
+  state: { is_live?: boolean; data?: unknown } | null | undefined,
+): boolean {
+  return Boolean(state?.is_live && state.data)
+}
+
 export function trackStatusLabel(status: string): string {
   return TRACK_STATUS_LABELS[status] || status || 'UNKNOWN'
 }

frontend/src/lib/weekendContext.ts

@@ -1,181 +0,0 @@
-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/pages/CommandCenterPage.tsx

@@ -0,0 +1,451 @@
+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/ExplorePage.tsx

@@ -1,156 +0,0 @@
-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: fetchSeasons })
-  const season = seasonsQuery.data?.[0] ?? null
-
-  const localMeetingsQuery = useQuery({
-    queryKey: ['meetings', season, 'local'],
-    queryFn: () => fetchLocalMeetings(season!),
-    enabled: season != null,
-  })
-  const seasonMeetingsQuery = useQuery({
-    queryKey: ['season-meetings', season],
-    queryFn: () => fetchSeasonMeetings(season!),
-    enabled: season != null,
-  })
-  const championshipQuery = useQuery({
-    queryKey: ['championship-hub', season],
-    queryFn: () => fetchChampionshipHub(season!),
-    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: () => fetchWeekend(m.meeting_key),
-      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/WeekendPage.tsx

@@ -1,94 +0,0 @@
-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 { 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
-}
-
-function renderState(view: WeekendViewState, args: RenderArgs) {
-  const { context, now, championship, briefing, preview } = 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} />
-  }
-
-  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} />
-    default:
-      return <WeekendLimited season={context.season} />
-  }
-}
-
-export function WeekendPage({ preview = false }: { preview?: boolean }) {
-  const { context, loadState, error, championship, briefing, now } = useWeekendContext()
-
-  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 message={error?.message} />
-      </main>
-    )
-  }
-
-  const view = resolveViewState(context)
-
-  return (
-    <main
-      className="wk-page"
-      data-testid="weekend-page"
-      data-state={view}
-      data-temporal-state={context.temporal_state}
-      data-preview={preview ? 'true' : undefined}
-    >
-      {renderState(view, { context, now, championship, briefing, preview })}
-    </main>
-  )
-}

frontend/src/router.tsx

@@ -1,13 +1,13 @@
 import { createRootRoute, createRoute, createRouter, Outlet } from '@tanstack/react-router'
 import { Nav } from './components/Nav'
-import { WeekendPage } from './pages/WeekendPage'
+import { CommandCenterPage } from './pages/CommandCenterPage'
-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
@@ -26,17 +26,10 @@ const rootRoute = createRootRoute({
   ),
 })
 
-// Weekend is the adaptive home. `/` renders the current temporal state.
+export const commandCenterRoute = createRoute({
-export const weekendRoute = createRoute({
   getParentRoute: () => rootRoute,
   path: '/',
-  component: WeekendPage,
+  component: CommandCenterPage,
-})
-
-export const exploreRoute = createRoute({
-  getParentRoute: () => rootRoute,
-  path: '/explore',
-  component: ExplorePage,
 })
 
 export const raceHubRoute = createRoute({
@@ -97,21 +90,14 @@ 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: function PreviewRoute() {
+  component: RacePreviewPage,
-    return <WeekendPage preview />
-  },
 })
 
 const routeTree = rootRoute.addChildren([
-  weekendRoute,
+  commandCenterRoute,
-  exploreRoute,
   raceHubRoute,
   adminRoute,
   dataLibraryRoute,

frontend/src/styles/app.css

@@ -112,6 +112,30 @@ a { color: inherit; text-decoration: none; }
 .nav-links a:hover { color: var(--text); background: var(--surface-h); }
 .nav-links a.active { color: var(--text); background: var(--surface-2); }
 
+/* Live nav gets a pulsing marker only while a session is on air. */
+.nav-live { display: inline-flex; align-items: center; gap: 6px; }
+.nav-links a.nav-live-on { color: var(--text); font-weight: 600; }
+.nav-live-dot {
+  width: 7px;
+  height: 7px;
+  border-radius: 50%;
+  background: var(--red);
+  box-shadow: 0 0 0 0 rgba(225, 6, 0, 0.4);
+  animation: pulse-live 1.6s infinite;
+}
+
+.sr-only {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  padding: 0;
+  margin: -1px;
+  overflow: hidden;
+  clip: rect(0, 0, 0, 0);
+  white-space: nowrap;
+  border: 0;
+}
+
 .nav-utility {
   margin-left: auto;
   display: flex;
@@ -142,53 +166,6 @@ 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;

frontend/src/styles/weekend.css

@@ -1,378 +0,0 @@
-/* ── Weekend adaptive home ── */
-.wk-page {
-  max-width: 1280px;
-  margin: 0 auto;
-  padding: var(--s6) var(--s6) 64px;
-  width: 100%;
-}
-
-.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-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-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/CommandCenterPage.test.tsx

@@ -0,0 +1,245 @@
+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/LiveComponents.test.tsx

@@ -209,6 +209,32 @@ describe('TimingTower', () => {
     expect(screen.getByText('DRS range')).toBeInTheDocument()
   })
 
+  it('derives a gap to P1 from best laps when the practice feed omits GapToLeader', () => {
+    const practiceRows = [
+      makeRow('1', 1, 'VER', { BestLapTime: '1:45.944', GapToLeader: '' }),
+      makeRow('4', 2, 'NOR', { BestLapTime: '1:46.134', GapToLeader: '' }),
+      makeRow('16', 3, 'LEC', { BestLapTime: '', GapToLeader: '' }),
+    ]
+    render(
+      <TimingTower
+        rows={practiceRows}
+        session={{
+          MeetingName: 'Belgian Grand Prix',
+          CircuitName: 'Spa',
+          SessionType: 'Practice',
+          SessionName: 'Practice 2',
+          Path: '',
+        }}
+      />,
+    )
+    // Leader shows a clear leader marker, not a fabricated gap.
+    expect(screen.getByText('VER').closest('tr')).toHaveTextContent('—')
+    expect(screen.getByText('+0.190')).toBeInTheDocument()
+    // A driver without a valid best lap gets no invented gap.
+    const lecRow = screen.getByText('LEC').closest('tr')!
+    expect(lecRow).not.toHaveTextContent('+')
+  })
+
   it('renders the SQ1 cutoff after P17 and marks rows below as at risk', () => {
     const sprintRows = Array.from({ length: 22 }, (_, index) =>
       makeRow(String(index + 1), index + 1, `D${index + 1}`),

frontend/src/test/LiveTimingPage.test.tsx

@@ -153,6 +153,29 @@ describe('LiveTimingPage archive mode', () => {
     expect(screen.queryByRole('button', { name: /view last session/i })).not.toBeInTheDocument()
   })
 
+  it('renders the live session for a red-flag paused snapshot instead of the inactive empty state', async () => {
+    renderPage({
+      is_live: true,
+      data: {
+        ...archivedSnapshot,
+        SessionStatus: 'Inactive',
+        TrackStatus: '2',
+        Clock: '00:03:27',
+        Session: {
+          MeetingName: 'Belgian Grand Prix',
+          CircuitName: 'Spa-Francorchamps',
+          SessionType: 'Practice',
+          SessionName: 'Practice 2',
+          Path: '',
+        },
+      },
+    })
+
+    expect(await screen.findByText('Timing Tower')).toBeInTheDocument()
+    expect(screen.queryByTestId('live-empty')).not.toBeInTheDocument()
+    expect(screen.queryByTestId('live-archive-strip')).not.toBeInTheDocument()
+  })
+
   it('temporarily omits the track map while live GPS is unavailable', async () => {
     renderPage({
       is_live: true,

frontend/src/test/Nav.test.tsx

@@ -1,67 +0,0 @@
-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/SessionBanner.test.tsx

@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest'
+import { render, screen } from '@testing-library/react'
+import { SessionBanner } from '../components/live/SessionBanner'
+import type { LiveStreamData } from '../types'
+
+function makeSnapshot(sessionType: string, sessionName: string): LiveStreamData {
+  return {
+    Drivers: {},
+    DriverInfo: {},
+    Tyres: {},
+    RCMessages: [],
+    Weather: { AirTemp: 0, TrackTemp: 0, Humidity: 0, WindSpeed: 0, WindDir: 0, Rainfall: false },
+    Session: {
+      MeetingName: 'Belgian Grand Prix',
+      CircuitName: 'Spa-Francorchamps',
+      SessionType: sessionType,
+      SessionName: sessionName,
+      Path: '',
+    },
+    TeamRadio: [],
+    TrackStatus: '1',
+    CurrentLap: 0,
+    TotalLaps: 0,
+    Clock: '00:45:00',
+    ClockRefTime: '',
+    ClockExtrapolating: false,
+    Stints: {},
+  }
+}
+
+describe('SessionBanner', () => {
+  it('never renders a race lap counter for a practice session', () => {
+    render(
+      <SessionBanner
+        isLive
+        snapshot={makeSnapshot('Practice', 'Practice 2')}
+        rows={[]}
+        connection="connected"
+        now={0}
+      />,
+    )
+    expect(screen.queryByTestId('live-lap-counter')).not.toBeInTheDocument()
+    // Session identity and clock stay intact.
+    expect(screen.getByText('Belgian Grand Prix')).toBeInTheDocument()
+    expect(screen.getByTestId('live-clock')).toHaveTextContent('00:45:00')
+  })
+
+  it('shows the lap counter for a race session', () => {
+    const snapshot = { ...makeSnapshot('Race', 'Race'), CurrentLap: 12, TotalLaps: 44 }
+    render(
+      <SessionBanner
+        isLive
+        snapshot={snapshot}
+        rows={[]}
+        connection="connected"
+        now={0}
+      />,
+    )
+    expect(screen.getByTestId('live-lap-counter')).toHaveTextContent('L12/44')
+  })
+})

frontend/src/test/TyreDegPanel.test.tsx

@@ -81,14 +81,20 @@ describe('TyreDegPanel', () => {
     expect(panel).toHaveTextContent('→ ~P2')
   })
 
-  it('hides the rejoin estimate outside race sessions and collapses on toggle', () => {
+  it('collapses by default outside race sessions and hides the rejoin estimate when expanded', () => {
     render(<TyreDegPanel rows={snapshotRows(3, '1:30.000')} sessionType="Qualifying" pinned={[]} />)
     const panel = screen.getByTestId('tyredeg-panel')
-    expect(panel).not.toHaveTextContent('~P')
 
-    expect(screen.getAllByTestId('tyredeg-row')).toHaveLength(2)
+    // Practice/qualifying starts collapsed so the Timing Tower stays above the fold.
-    fireEvent.click(screen.getByRole('button', { name: /tyre deg/i }))
     expect(screen.queryAllByTestId('tyredeg-row')).toHaveLength(0)
+    fireEvent.click(screen.getByRole('button', { name: /tyre deg/i }))
+    expect(screen.getAllByTestId('tyredeg-row')).toHaveLength(2)
+    expect(panel).not.toHaveTextContent('~P')
+  })
+
+  it('starts expanded during a race', () => {
+    render(<TyreDegPanel rows={snapshotRows(3, '1:30.000')} sessionType="Race" pinned={[]} />)
+    expect(screen.getAllByTestId('tyredeg-row')).toHaveLength(2)
   })
 
   it('limits rows to the top ten plus pinned drivers', () => {

frontend/src/test/WeekendPage.test.tsx

@@ -1,309 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { render, screen, waitFor } 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'
-
-vi.mock('../api', () => ({
-  fetchWeekendContext: vi.fn(),
-  fetchChampionshipHub: vi.fn(),
-  fetchNews: vi.fn(),
-  fetchRaceHub: 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,
-  fetchSeasons,
-  fetchMeetings,
-  fetchSessions,
-  fetchResults,
-  fetchStartingGrid,
-  fetchTrackOutline,
-} from '../api'
-
-const mockContext = vi.mocked(fetchWeekendContext)
-const mockHub = vi.mocked(fetchChampionshipHub)
-const mockNews = vi.mocked(fetchNews)
-const mockRaceHub = vi.mocked(fetchRaceHub)
-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: '/', component: () => <WeekendPage /> })
-  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)
-    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())
-    expect(screen.getByTestId('weekend-error')).toHaveTextContent('boom')
-  })
-
-  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()
-  })
-})

frontend/src/test/live.test.ts

@@ -1,12 +1,15 @@
 import { describe, expect, it } from 'vitest'
 import {
+  bestLapGaps,
   compoundClass,
   compoundLetter,
   extrapolateClock,
+  isLiveSessionActive,
   latestRaceControl,
   liveSessionDisplay,
   loadPinnedDrivers,
   mergeVisibleSectors,
+  parseLapTimeSeconds,
   positionDeltaClass,
   parseLiveStateEvent,
   rcFlagClass,
@@ -279,6 +282,43 @@ describe('live qualifying display', () => {
   })
 })
 
+describe('practice/qualifying computed gaps', () => {
+  it('parses lap-time strings into seconds and rejects invalid input', () => {
+    expect(parseLapTimeSeconds('1:45.944')).toBeCloseTo(105.944, 3)
+    expect(parseLapTimeSeconds('45.944')).toBeCloseTo(45.944, 3)
+    expect(parseLapTimeSeconds('')).toBeNull()
+    expect(parseLapTimeSeconds(undefined)).toBeNull()
+    expect(parseLapTimeSeconds('-')).toBeNull()
+    expect(parseLapTimeSeconds('nope')).toBeNull()
+  })
+
+  it('derives a gap to P1 from valid best laps only, flagging the leader', () => {
+    const gaps = bestLapGaps([
+      timingRow('1', 1, { BestLapTime: '1:45.944' }),
+      timingRow('4', 2, { BestLapTime: '1:46.134' }),
+      timingRow('16', 3, { BestLapTime: '' }),
+    ])
+    expect(gaps['1']).toEqual({ isLeader: true, gap: '' })
+    expect(gaps['4']).toEqual({ isLeader: false, gap: '+0.190' })
+    // No valid best lap → no fabricated gap.
+    expect(gaps['16']).toBeUndefined()
+  })
+
+  it('returns no gaps when nobody has set a lap', () => {
+    expect(bestLapGaps([timingRow('1', 1, { BestLapTime: '' })])).toEqual({})
+  })
+})
+
+describe('live session activity', () => {
+  it('is active only when the feed reports a live session with data', () => {
+    expect(isLiveSessionActive({ is_live: true, data: snapshot })).toBe(true)
+    expect(isLiveSessionActive({ is_live: true, data: null })).toBe(false)
+    expect(isLiveSessionActive({ is_live: false, data: snapshot })).toBe(false)
+    expect(isLiveSessionActive(null)).toBe(false)
+    expect(isLiveSessionActive(undefined)).toBe(false)
+  })
+})
+
 describe('visible sector display', () => {
   it('holds S1 and S2 through temporary blanks while a flying lap is active', () => {
     const first = [timingRow('4', 1, {

frontend/src/test/weekendContext.test.ts

@@ -1,223 +0,0 @@
-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

@@ -448,107 +448,6 @@ export interface DriverSummary {
   rounds: DriverSummaryRound[]
 }
 
-// ── 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 {
-  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 {
   source: string
   title: string

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.
+			// Expired entries remain stored so get() can use them as a stale
-			_, _ = c.db.Exec(`DELETE FROM cache WHERE key = ?`, key)
+			// 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,9 +43,19 @@ 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 {
 	url        string
@@ -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")
+	}
+}

internal/api/openf1.go

@@ -2,6 +2,7 @@ package api
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -59,8 +60,14 @@ func retryAfter429(resp *http.Response) time.Duration {
 // Without this, concurrent fan-outs (championship hub, track prefetch) burst
 // past the free-tier limit and callers silently treat 429s as missing data.
 func (c *OpenF1Client) doPaced(req *http.Request) (*http.Response, error) {
+	return c.doPacedContext(req.Context(), req)
+}
+
+func (c *OpenF1Client) doPacedContext(ctx context.Context, req *http.Request) (*http.Response, error) {
 	for attempt := 0; ; attempt++ {
-		c.pacer.wait()
+		if err := c.pacer.waitContext(ctx); err != nil {
+			return nil, err
+		}
 		resp, err := c.httpClient.Do(req)
 		if err != nil {
 			return nil, err
@@ -70,7 +77,14 @@ func (c *OpenF1Client) doPaced(req *http.Request) (*http.Response, error) {
 		}
 		delay := retryAfter429(resp)
 		resp.Body.Close()
-		time.Sleep(delay)
+		timer := time.NewTimer(delay)
+		select {
+		case <-timer.C:
+		case <-ctx.Done():
+			timer.Stop()
+			return nil, ctx.Err()
+		}
+		timer.Stop()
 	}
 }
 
@@ -83,13 +97,23 @@ func (c *OpenF1Client) doPaced(req *http.Request) (*http.Response, error) {
 // entry for this URL, that stale entry is returned instead of propagating the
 // error.  The client's staleFlag is set so the UI can show a disclaimer.
 func (c *OpenF1Client) get(url string) (io.ReadCloser, error) {
+	return c.getContext(context.Background(), url)
+}
+
+// getContext is the cancellable form used by bounded optional web enrichment.
+// A caller cancellation never falls back to stale data: the work is no longer
+// relevant to that response and must stop instead of continuing in background.
+func (c *OpenF1Client) getContext(ctx context.Context, url string) (io.ReadCloser, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, err
+	}
 	// 1. Check the cache for a fresh (non-expired) entry.
 	if cachedData, ok := c.cache.Get(url); ok {
 		return io.NopCloser(bytes.NewReader(cachedData)), nil
 	}
 
 	// 2. Attempt a live network request.
-	req, err := http.NewRequest("GET", url, nil)
+	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
 	if err != nil {
 		// Even a request-construction failure warrants a stale fallback.
 		return c.tryStale(url, err)
@@ -98,8 +122,11 @@ func (c *OpenF1Client) get(url string) (io.ReadCloser, error) {
 		req.Header.Set("Authorization", "Bearer "+c.apiKey)
 	}
 
-	resp, err := c.doPaced(req)
+	resp, err := c.doPacedContext(ctx, req)
 	if err != nil {
+		if ctx.Err() != nil {
+			return nil, ctx.Err()
+		}
 		return c.tryStale(url, err)
 	}
 	defer resp.Body.Close()
@@ -128,6 +155,9 @@ func (c *OpenF1Client) get(url string) (io.ReadCloser, error) {
 	// 3. Success — read the body, store in cache, return.
 	data, err := io.ReadAll(resp.Body)
 	if err != nil {
+		if ctx.Err() != nil {
+			return nil, ctx.Err()
+		}
 		return c.tryStale(url, err)
 	}
 
@@ -245,7 +275,13 @@ func (c *OpenF1Client) GetDriversForSession(sessionKey int) ([]models.Driver, er
 }
 
 func (c *OpenF1Client) GetDriver(sessionKey, driverNumber int) (*models.Driver, error) {
-	body, err := c.get(fmt.Sprintf("%s/v1/drivers?session_key=%d&driver_number=%d", c.url, sessionKey, driverNumber))
+	return c.GetDriverContext(context.Background(), sessionKey, driverNumber)
+}
+
+// GetDriverContext is a cancellable single-driver lookup for optional bounded
+// enrichment. Other public methods retain their existing background semantics.
+func (c *OpenF1Client) GetDriverContext(ctx context.Context, sessionKey, driverNumber int) (*models.Driver, error) {
+	body, err := c.getContext(ctx, fmt.Sprintf("%s/v1/drivers?session_key=%d&driver_number=%d", c.url, sessionKey, driverNumber))
 	if err != nil {
 		return nil, err
 	}

internal/api/pacing_test.go

@@ -1,7 +1,9 @@
 package api
 
 import (
+	"context"
 	"encoding/json"
+	"errors"
 	"io"
 	"net/http"
 	"net/http/httptest"
@@ -49,6 +51,70 @@ func TestRequestPacerNilSafe(t *testing.T) {
 	p.wait() // must not panic
 }
 
+func TestRequestPacerCancellationDoesNotCollideReservedWaiters(t *testing.T) {
+	const interval = 80 * time.Millisecond
+	p := &requestPacer{interval: interval}
+	if err := p.waitContext(context.Background()); err != nil {
+		t.Fatal(err)
+	}
+	p.mu.Lock()
+	initialNext := p.next
+	p.mu.Unlock()
+
+	waitForReservation := func(want time.Time) {
+		t.Helper()
+		deadline := time.Now().Add(250 * time.Millisecond)
+		for time.Now().Before(deadline) {
+			p.mu.Lock()
+			got := p.next
+			p.mu.Unlock()
+			if got.Equal(want) {
+				return
+			}
+			time.Sleep(time.Millisecond)
+		}
+		t.Fatalf("reservation did not reach %v", want)
+	}
+
+	ctxB, cancelB := context.WithCancel(context.Background())
+	bDone := make(chan error, 1)
+	go func() { bDone <- p.waitContext(ctxB) }()
+	waitForReservation(initialNext.Add(interval))
+
+	cDone := make(chan time.Time, 1)
+	go func() {
+		_ = p.waitContext(context.Background())
+		cDone <- time.Now()
+	}()
+	waitForReservation(initialNext.Add(2 * interval))
+
+	cancelStarted := time.Now()
+	cancelB()
+	select {
+	case err := <-bDone:
+		if !errors.Is(err, context.Canceled) {
+			t.Fatalf("B error = %v, want context.Canceled", err)
+		}
+		if elapsed := time.Since(cancelStarted); elapsed > 30*time.Millisecond {
+			t.Fatalf("B cancellation took %v", elapsed)
+		}
+	case <-time.After(50 * time.Millisecond):
+		t.Fatal("B did not return promptly after cancellation")
+	}
+
+	dDone := make(chan time.Time, 1)
+	go func() {
+		_ = p.waitContext(context.Background())
+		dDone <- time.Now()
+	}()
+	waitForReservation(initialNext.Add(3 * interval))
+
+	cAt, dAt := <-cDone, <-dDone
+	if separation := dAt.Sub(cAt); separation < interval/2 {
+		t.Fatalf("C and D collided: wake separation %v, want at least %v", separation, interval/2)
+	}
+}
+
 func TestGetRetriesOn429(t *testing.T) {
 	var calls atomic.Int32
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

internal/live/parser_test.go

@@ -307,6 +307,28 @@ func TestSessionStatusIsActive(t *testing.T) {
 	}
 }
 
+func TestSessionStatusIsTerminal(t *testing.T) {
+	tests := []struct {
+		status string
+		want   bool
+	}{
+		{"Finished", true},
+		{"Finalised", true},
+		{"Finalized", true},
+		{"Ends", true},
+		{"Aborted", true},
+		{"Started", false},
+		{"Resumed", false},
+		{"Inactive", false},
+		{"", false},
+	}
+	for _, tt := range tests {
+		if got := live.SessionStatusIsTerminal(tt.status); got != tt.want {
+			t.Errorf("SessionStatusIsTerminal(%q) = %v, want %v", tt.status, got, tt.want)
+		}
+	}
+}
+
 func TestProcessTopicRaceControlMessages(t *testing.T) {
 	state := live.NewState()
 	data := json.RawMessage(`{

internal/live/types.go

@@ -186,6 +186,19 @@ func SessionStatusIsActive(status string) bool {
 	}
 }
 
+// SessionStatusIsTerminal reports whether a raw F1 live timing SessionStatus
+// value represents a session that has ended and will not resume. A temporarily
+// inactive session (e.g. a red-flag pause reported as "Inactive") is neither
+// active nor terminal.
+func SessionStatusIsTerminal(status string) bool {
+	switch normalizeSessionStatus(status) {
+	case "finished", "finalised", "finalized", "ends", "aborted":
+		return true
+	default:
+		return false
+	}
+}
+
 func normalizeSessionStatus(status string) string {
 	out := make([]rune, 0, len(status))
 	for _, r := range status {

internal/query/context.go

@@ -40,6 +40,7 @@ type LiveEvidence struct {
 
 // ContextAvailability is structured source state for a referenced session.
 type ContextAvailability struct {
+	Source        string   `json:"source"`
 	Schedule      string   `json:"schedule"`
 	LiveTransport string   `json:"live_transport"`
 	LiveSession   string   `json:"live_session"`
@@ -298,21 +299,28 @@ func meetingModelByKey(meetings []store.Meeting, key int) *models.Meeting {
 func sessionRef(c contextCandidate, evidence LiveEvidence, now time.Time) *ContextSession {
 	session := sessionToModel(c.session)
 	meeting := meetingToModel(c.meeting)
-	availability := ContextAvailability{Schedule: "available", LiveSession: "inactive", Archive: "unavailable", Freshness: "fresh", Limitations: []string{}}
+	// Schedule and analysis are domain-store facts. Without an ingestion
+	// timestamp the resolver cannot honestly call them network-fresh, so local
+	// is the baseline freshness vocabulary exposed to clients.
+	availability := ContextAvailability{Source: "local", Schedule: "available", LiveSession: "inactive", Archive: "unavailable", Freshness: "local", Limitations: []string{}}
 	availability.LiveTransport = "unknown"
 	if c.session.SessionKey == 0 {
 		availability.Schedule = "unavailable"
 		availability.Limitations = append(availability.Limitations, "schedule_identity_unmatched")
 	}
 	if evidence.Active && liveMatches(evidence, c.meeting, c.session) {
+		availability.Source = "mixed"
 		availability.LiveTransport = "connected"
 		availability.LiveSession = "active"
+		availability.Freshness = "live"
 		if !evidence.ObservedAt.IsZero() {
 			availability.ObservedAt = evidence.ObservedAt.Format(time.RFC3339)
 		}
 	}
 	if c.archived {
+		availability.Source = "mixed"
 		availability.Archive = "available"
+		availability.Freshness = "archive"
 		if !evidence.ObservedAt.IsZero() {
 			availability.ObservedAt = evidence.ObservedAt.Format(time.RFC3339)
 		}
@@ -326,6 +334,12 @@ func sessionRef(c contextCandidate, evidence LiveEvidence, now time.Time) *Conte
 	} else {
 		availability.LocalAnalysis = "pending"
 	}
+	if availability.LocalAnalysis == "partial" && availability.Freshness == "local" {
+		availability.Freshness = "partial"
+	}
+	if c.session.SessionKey == 0 && availability.LiveSession == "active" {
+		availability.Source = "fia"
+	}
 	return &ContextSession{Session: session, Meeting: &meeting, Availability: availability}
 }
 

internal/query/context_test.go

@@ -160,6 +160,54 @@ func TestResolveWeekendContextPassedTimeDoesNotCompleteSession(t *testing.T) {
 	}
 }
 
+func TestResolveWeekendContextAvailabilityUsesTruthfulSources(t *testing.T) {
+	now, _ := time.Parse(time.RFC3339, "2026-07-05T18:00:00Z")
+	svc := contextService(t, now)
+	addContextMeeting(t, svc, 1, "British Grand Prix", "2026-07-03T00:00:00Z", "2026-07-05T16:00:00Z", false)
+	addContextSession(t, svc, 11, 1, "Race", "2026-07-05T14:00:00Z", "2026-07-05T16:00:00Z", false)
+	// Results without laps/stints/positions are meaningful but incomplete local
+	// analysis, so they must not be labelled universally fresh.
+	completeContextSession(t, svc, 11, 1)
+	addContextMeeting(t, svc, 2, "Belgian Grand Prix", "2026-07-17T00:00:00Z", "2026-07-19T16:00:00Z", false)
+	addContextSession(t, svc, 21, 2, "Practice 1", "2026-07-17T09:00:00Z", "2026-07-17T10:00:00Z", false)
+	addContextSession(t, svc, 22, 2, "Race", "2026-07-19T14:00:00Z", "2026-07-19T16:00:00Z", false)
+
+	local, err := svc.ResolveWeekendContext(LiveEvidence{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := local.PreviousCompletedSession.Availability; got.Source != "local" || got.Freshness != "partial" || got.LocalAnalysis != "partial" {
+		t.Fatalf("partial local availability = %+v", got)
+	}
+	if got := local.NextSession.Availability; got.Source != "local" || got.Freshness != "local" {
+		t.Fatalf("future local availability = %+v", got)
+	}
+
+	liveContext, err := svc.ResolveWeekendContext(LiveEvidence{Active: true, MeetingName: "Belgian Grand Prix", CircuitName: "Belgian Grand Prix", SessionName: "Practice 1", SessionType: "Practice 1", ObservedAt: now})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := liveContext.ActiveSession.Availability; got.Source != "mixed" || got.Freshness != "live" || got.LiveSession != "active" {
+		t.Fatalf("FIA + local availability = %+v", got)
+	}
+
+	archiveContext, err := svc.ResolveWeekendContext(LiveEvidence{Final: true, MeetingName: "British Grand Prix", CircuitName: "British Grand Prix", SessionName: "Race", SessionType: "Race", ObservedAt: now})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := archiveContext.PreviousCompletedSession.Availability; got.Source != "mixed" || got.Freshness != "archive" || got.Archive != "available" {
+		t.Fatalf("FIA archive + local availability = %+v", got)
+	}
+
+	synthetic, err := svc.ResolveWeekendContext(LiveEvidence{Active: true, MeetingName: "Unscheduled Grand Prix", SessionName: "Race", SessionType: "Race", ObservedAt: now})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := synthetic.ActiveSession.Availability; got.Source != "fia" || got.Freshness != "live" || got.Schedule != "unavailable" {
+		t.Fatalf("synthetic FIA availability = %+v", got)
+	}
+}
+
 func TestResolveWeekendContextNeverUsesFutureAnalysis(t *testing.T) {
 	now, _ := time.Parse(time.RFC3339, "2026-07-01T12:00:00Z")
 	svc := contextService(t, now)
@@ -175,6 +223,38 @@ func TestResolveWeekendContextNeverUsesFutureAnalysis(t *testing.T) {
 	}
 }
 
+// Regression for the v0.4.0 release blocker (#90). Production held a run
+// British race (11326) and an unrun Belgian race (11334) two weekends apart.
+// Analysis must resolve to the race that actually happened, even when the
+// later meeting carries preloaded rows.
+func TestResolveWeekendContextPrefersRunRaceOverLaterUnrunRace(t *testing.T) {
+	now, _ := time.Parse(time.RFC3339, "2026-07-13T12:00:00Z")
+	svc := contextService(t, now)
+	addContextMeeting(t, svc, 1289, "British Grand Prix", "2026-07-03T11:30:00Z", "2026-07-05T16:00:00Z", false)
+	addContextSession(t, svc, 11326, 1289, "Race", "2026-07-05T14:00:00Z", "2026-07-05T16:00:00Z", false)
+	completeContextSession(t, svc, 11326, 1289)
+	addContextMeeting(t, svc, 1290, "Belgian Grand Prix", "2026-07-17T11:30:00Z", "2026-07-19T15:00:00Z", false)
+	addContextSession(t, svc, 11334, 1290, "Race", "2026-07-19T13:00:00Z", "2026-07-19T15:00:00Z", false)
+	completeContextSession(t, svc, 11334, 1290)
+
+	got, err := svc.ResolveWeekendContext(LiveEvidence{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got.DefaultAnalysisSession == nil {
+		t.Fatal("no analysis session resolved")
+	}
+	if key := got.DefaultAnalysisSession.Session.SessionKey; key != 11326 {
+		t.Fatalf("analysis session = %d, want 11326 (British); 11334 is the unrun Belgian race", key)
+	}
+	if got.PreviousCompletedSession == nil || got.PreviousCompletedSession.Session.SessionKey != 11326 {
+		t.Fatalf("previous completed = %+v, want 11326", got.PreviousCompletedSession)
+	}
+	if got.NextSession == nil || got.NextSession.Session.SessionKey != 11334 {
+		t.Fatalf("next session = %+v, want 11334", got.NextSession)
+	}
+}
+
 func TestResolveWeekendContextSprintWeekendHandoff(t *testing.T) {
 	now, _ := time.Parse(time.RFC3339, "2026-07-04T12:00:00Z")
 	svc := contextService(t, now)

internal/web/api.go

@@ -16,6 +16,7 @@ import (
 
 	readability "codeberg.org/readeck/go-readability/v2"
 
+	"github.com/AmanTahiliani/box-box/internal/api"
 	"github.com/AmanTahiliani/box-box/internal/models"
 	"github.com/AmanTahiliani/box-box/internal/query"
 )
@@ -43,6 +44,7 @@ func (s *Server) handleMeetings(w http.ResponseWriter, r *http.Request) {
 
 	switch parseSourceMode(r) {
 	case sourceLocal:
+		markLocalResponse(w, false)
 		if !s.hasLocalQuery() {
 			writeJSON(w, []models.Meeting{})
 			return
@@ -62,17 +64,20 @@ func (s *Server) handleMeetings(w http.ResponseWriter, r *http.Request) {
 				return
 			}
 			if len(meetings) > 0 {
+				markLocalResponse(w, false)
 				writeJSON(w, meetings)
 				return
 			}
 		}
 	}
 
-	meetings, err := s.client.GetMeetingsForYear(year)
+	client := s.client.Scoped()
+	meetings, err := client.GetMeetingsForYear(year)
 	if err != nil {
-		writeError(w, err, http.StatusInternalServerError, s.client.LastResponseWasStale())
+		writeError(w, err, http.StatusInternalServerError, client.LastResponseWasStale())
 		return
 	}
+	markOpenF1Response(w, client)
 	writeJSON(w, meetings)
 }
 
@@ -87,6 +92,7 @@ func (s *Server) handleSessions(w http.ResponseWriter, r *http.Request) {
 
 	switch parseSourceMode(r) {
 	case sourceLocal:
+		markLocalResponse(w, false)
 		if !s.hasLocalQuery() {
 			writeJSON(w, []models.Session{})
 			return
@@ -106,23 +112,27 @@ func (s *Server) handleSessions(w http.ResponseWriter, r *http.Request) {
 				return
 			}
 			if len(sessions) > 0 {
+				markLocalResponse(w, false)
 				writeJSON(w, sessions)
 				return
 			}
 		}
 	}
 
-	sessions, err := s.client.GetSessionsForMeeting(meetingKey)
+	client := s.client.Scoped()
+	sessions, err := client.GetSessionsForMeeting(meetingKey)
 	if err != nil {
-		writeError(w, err, http.StatusInternalServerError, s.client.LastResponseWasStale())
+		writeError(w, err, http.StatusInternalServerError, client.LastResponseWasStale())
 		return
 	}
+	markOpenF1Response(w, client)
 	writeJSON(w, sessions)
 }
 
 // --- /api/v1/news ---
 
 func (s *Server) handleNews(w http.ResponseWriter, r *http.Request) {
+	markLocalResponse(w, false)
 	if !s.hasLocalQuery() {
 		writeJSON(w, []query.NewsItem{})
 		return
@@ -223,6 +233,7 @@ func (s *Server) handleDrivers(w http.ResponseWriter, r *http.Request) {
 
 	switch parseSourceMode(r) {
 	case sourceLocal:
+		markLocalResponse(w, false)
 		if !s.hasLocalQuery() {
 			writeJSON(w, []models.Driver{})
 			return
@@ -242,6 +253,7 @@ func (s *Server) handleDrivers(w http.ResponseWriter, r *http.Request) {
 		if s.hasLocalQuery() {
 			drivers, err := s.query.ListDrivers(sessionKey)
 			if err == nil && len(drivers) > 0 {
+				markLocalResponse(w, false)
 				writeJSON(w, drivers)
 				return
 			}
@@ -252,11 +264,13 @@ func (s *Server) handleDrivers(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	drivers, err := s.client.GetDriversForSession(sessionKey)
+	client := s.client.Scoped()
+	drivers, err := client.GetDriversForSession(sessionKey)
 	if err != nil {
-		writeError(w, err, http.StatusInternalServerError, s.client.LastResponseWasStale())
+		writeError(w, err, http.StatusInternalServerError, client.LastResponseWasStale())
 		return
 	}
+	markOpenF1Response(w, client)
 	writeJSON(w, drivers)
 }
 
@@ -279,6 +293,7 @@ func (s *Server) handleResults(w http.ResponseWriter, r *http.Request) {
 
 	switch parseSourceMode(r) {
 	case sourceLocal:
+		markLocalResponse(w, false)
 		if !s.hasLocalQuery() {
 			writeJSON(w, []resultWithDriver{})
 			return
@@ -294,6 +309,7 @@ func (s *Server) handleResults(w http.ResponseWriter, r *http.Request) {
 		if s.hasLocalQuery() {
 			results, err := s.query.ListResults(sessionKey)
 			if err == nil && len(results) > 0 {
+				markLocalResponse(w, false)
 				writeJSON(w, enrichedResultsToAPI(results))
 				return
 			}
@@ -308,30 +324,42 @@ func (s *Server) handleResults(w http.ResponseWriter, r *http.Request) {
 		results    []models.SessionResult
 		drivers    []models.Driver
 		resultsErr error
+		driversErr error
 		wg         sync.WaitGroup
 	)
+	client := s.client.Scoped()
 	wg.Add(2)
-	go func() { defer wg.Done(); results, resultsErr = s.client.GetSessionResult(sessionKey) }()
+	go func() { defer wg.Done(); results, resultsErr = client.GetSessionResult(sessionKey) }()
-	go func() { defer wg.Done(); drivers, _ = s.client.GetDriversForSession(sessionKey) }()
+	go func() { defer wg.Done(); drivers, driversErr = client.GetDriversForSession(sessionKey) }()
 	wg.Wait()
 
 	if resultsErr != nil {
-		writeError(w, resultsErr, http.StatusInternalServerError, s.client.LastResponseWasStale())
+		writeError(w, resultsErr, http.StatusInternalServerError, client.LastResponseWasStale())
 		return
 	}
 
 	driverMap := buildDriverMap(drivers)
+	incomplete := driversErr != nil
 	enriched := make([]resultWithDriver, 0, len(results))
 	for _, res := range results {
 		e := resultWithDriver{SessionResult: res}
-		if d, ok := driverMap[res.DriverNumber]; ok {
+		if d, ok := driverMap[res.DriverNumber]; ok && hasDriverPresentation(d) {
 			e.NameAcronym = d.NameAcronym
 			e.FullName = d.FullName
 			e.TeamName = d.TeamName
 			e.TeamColour = d.TeamColour
+		} else {
+			incomplete = true
 		}
 		enriched = append(enriched, e)
 	}
+	resultsFreshness := "fresh"
+	if len(results) == 0 {
+		resultsFreshness = "limited"
+	} else if incomplete {
+		resultsFreshness = "partial"
+	}
+	markOpenF1Availability(w, client, resultsFreshness)
 	writeJSON(w, enriched)
 }
 
@@ -354,6 +382,7 @@ func (s *Server) handleGrid(w http.ResponseWriter, r *http.Request) {
 
 	switch parseSourceMode(r) {
 	case sourceLocal:
+		markLocalResponse(w, false)
 		if !s.hasLocalQuery() {
 			writeJSON(w, []gridWithDriver{})
 			return
@@ -369,6 +398,7 @@ func (s *Server) handleGrid(w http.ResponseWriter, r *http.Request) {
 		if s.hasLocalQuery() {
 			grid, err := s.query.ListStartingGrid(sessionKey)
 			if err == nil && len(grid) > 0 {
+				markLocalResponse(w, false)
 				writeJSON(w, enrichedGridToAPI(grid))
 				return
 			}
@@ -383,30 +413,42 @@ func (s *Server) handleGrid(w http.ResponseWriter, r *http.Request) {
 		grid       []models.StartingGrid
 		drivers    []models.Driver
 		gridErr    error
+		driversErr error
 		wg         sync.WaitGroup
 	)
+	client := s.client.Scoped()
 	wg.Add(2)
-	go func() { defer wg.Done(); grid, gridErr = s.client.GetStartingGrid(sessionKey) }()
+	go func() { defer wg.Done(); grid, gridErr = client.GetStartingGrid(sessionKey) }()
-	go func() { defer wg.Done(); drivers, _ = s.client.GetDriversForSession(sessionKey) }()
+	go func() { defer wg.Done(); drivers, driversErr = client.GetDriversForSession(sessionKey) }()
 	wg.Wait()
 
 	if gridErr != nil {
-		writeError(w, gridErr, http.StatusInternalServerError, s.client.LastResponseWasStale())
+		writeError(w, gridErr, http.StatusInternalServerError, client.LastResponseWasStale())
 		return
 	}
 
 	driverMap := buildDriverMap(drivers)
+	incomplete := driversErr != nil
 	enriched := make([]gridWithDriver, 0, len(grid))
 	for _, g := range grid {
 		e := gridWithDriver{StartingGrid: g}
-		if d, ok := driverMap[g.DriverNumber]; ok {
+		if d, ok := driverMap[g.DriverNumber]; ok && hasDriverPresentation(d) {
 			e.NameAcronym = d.NameAcronym
 			e.FullName = d.FullName
 			e.TeamName = d.TeamName
 			e.TeamColour = d.TeamColour
+		} else {
+			incomplete = true
 		}
 		enriched = append(enriched, e)
 	}
+	gridFreshness := "fresh"
+	if len(grid) == 0 {
+		gridFreshness = "limited"
+	} else if incomplete {
+		gridFreshness = "partial"
+	}
+	markOpenF1Availability(w, client, gridFreshness)
 	writeJSON(w, enriched)
 }
 
@@ -419,26 +461,29 @@ func (s *Server) handleLaps(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	client := s.client.Scoped()
 	if dnStr := r.URL.Query().Get("driver_number"); dnStr != "" {
 		driverNumber, err := strconv.Atoi(dnStr)
 		if err != nil || driverNumber == 0 {
 			http.Error(w, "invalid driver_number", http.StatusBadRequest)
 			return
 		}
-		laps, err := s.client.GetLapsForDriver(sessionKey, driverNumber)
+		laps, err := client.GetLapsForDriver(sessionKey, driverNumber)
 		if err != nil {
-			writeError(w, err, http.StatusInternalServerError, s.client.LastResponseWasStale())
+			writeError(w, err, http.StatusInternalServerError, client.LastResponseWasStale())
 			return
 		}
+		markOpenF1Response(w, client)
 		writeJSON(w, laps)
 		return
 	}
 
-	laps, err := s.client.GetLapsForSession(sessionKey)
+	laps, err := client.GetLapsForSession(sessionKey)
 	if err != nil {
-		writeError(w, err, http.StatusInternalServerError, s.client.LastResponseWasStale())
+		writeError(w, err, http.StatusInternalServerError, client.LastResponseWasStale())
 		return
 	}
+	markOpenF1Response(w, client)
 	writeJSON(w, laps)
 }
 
@@ -450,11 +495,13 @@ func (s *Server) handleWeather(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "session_key required", http.StatusBadRequest)
 		return
 	}
-	weather, err := s.client.GetWeather(sessionKey)
+	client := s.client.Scoped()
+	weather, err := client.GetWeather(sessionKey)
 	if err != nil {
-		writeError(w, err, http.StatusInternalServerError, s.client.LastResponseWasStale())
+		writeError(w, err, http.StatusInternalServerError, client.LastResponseWasStale())
 		return
 	}
+	markOpenF1Response(w, client)
 	writeJSON(w, weather)
 }
 
@@ -466,11 +513,13 @@ func (s *Server) handleRaceControl(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "session_key required", http.StatusBadRequest)
 		return
 	}
-	rc, err := s.client.GetRaceControl(sessionKey)
+	client := s.client.Scoped()
+	rc, err := client.GetRaceControl(sessionKey)
 	if err != nil {
-		writeError(w, err, http.StatusInternalServerError, s.client.LastResponseWasStale())
+		writeError(w, err, http.StatusInternalServerError, client.LastResponseWasStale())
 		return
 	}
+	markOpenF1Response(w, client)
 	writeJSON(w, rc)
 }
 
@@ -487,11 +536,13 @@ func (s *Server) handleTelemetry(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "driver_number required", http.StatusBadRequest)
 		return
 	}
-	carData, err := s.client.GetCarData(sessionKey, driverNumber)
+	client := s.client.Scoped()
+	carData, err := client.GetCarData(sessionKey, driverNumber)
 	if err != nil {
-		writeError(w, err, http.StatusInternalServerError, s.client.LastResponseWasStale())
+		writeError(w, err, http.StatusInternalServerError, client.LastResponseWasStale())
 		return
 	}
+	markOpenF1Response(w, client)
 	writeJSON(w, carData)
 }
 
@@ -503,11 +554,13 @@ func (s *Server) handleOvertakes(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "session_key required", http.StatusBadRequest)
 		return
 	}
-	overtakes, err := s.client.GetOvertakesForSession(sessionKey)
+	client := s.client.Scoped()
+	overtakes, err := client.GetOvertakesForSession(sessionKey)
 	if err != nil {
-		writeError(w, err, http.StatusInternalServerError, s.client.LastResponseWasStale())
+		writeError(w, err, http.StatusInternalServerError, client.LastResponseWasStale())
 		return
 	}
+	markOpenF1Response(w, client)
 	writeJSON(w, overtakes)
 }
 
@@ -524,11 +577,13 @@ func (s *Server) handleTeamRadio(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "driver_number required", http.StatusBadRequest)
 		return
 	}
-	radios, err := s.client.GetTeamRadio(sessionKey, driverNumber)
+	client := s.client.Scoped()
+	radios, err := client.GetTeamRadio(sessionKey, driverNumber)
 	if err != nil {
-		writeError(w, err, http.StatusInternalServerError, s.client.LastResponseWasStale())
+		writeError(w, err, http.StatusInternalServerError, client.LastResponseWasStale())
 		return
 	}
+	markOpenF1Response(w, client)
 	writeJSON(w, radios)
 }
 
@@ -547,36 +602,42 @@ func (s *Server) handleChampionshipDrivers(w http.ResponseWriter, r *http.Reques
 	if year == 0 {
 		year = time.Now().Year()
 	}
-	champ, err := s.client.GetDriverChampionshipForYear(year)
+	client := s.client.Scoped()
+	champ, err := client.GetDriverChampionshipForYear(year)
 	if err != nil {
-		writeError(w, err, http.StatusInternalServerError, s.client.LastResponseWasStale())
+		writeError(w, err, http.StatusInternalServerError, client.LastResponseWasStale())
 		return
 	}
 	if len(champ) == 0 {
+		markOpenF1Availability(w, client, "limited")
 		writeJSON(w, []any{})
 		return
 	}
 
-	drivers, _ := s.client.GetDriversForSession(champ[0].SessionKey)
+	drivers, driversErr := client.GetDriversForSession(champ[0].SessionKey)
 	driverMap := buildDriverMapFirst(drivers)
+	incomplete := driversErr != nil
 
 	enriched := make([]champDriverWithInfo, 0, len(champ))
 	for _, c := range champ {
 		e := champDriverWithInfo{ChampionshipDriver: c}
-		d, ok := s.championshipDriverInfo(c.SessionKey, c.DriverNumber, driverMap)
+		d, ok := championshipDriverInfo(client, c.SessionKey, c.DriverNumber, driverMap)
-		if ok {
+		if ok && hasDriverPresentation(d) {
 			e.NameAcronym = d.NameAcronym
 			e.FullName = d.FullName
 			e.TeamName = d.TeamName
 			e.TeamColour = d.TeamColour
+		} else {
+			incomplete = true
 		}
 		enriched = append(enriched, e)
 	}
+	markOpenF1AggregateResponse(w, client, incomplete)
 	writeJSON(w, enriched)
 }
 
-func (s *Server) championshipDriverInfo(sessionKey, driverNumber int, fallback map[int]models.Driver) (models.Driver, bool) {
+func championshipDriverInfo(client *api.OpenF1Client, sessionKey, driverNumber int, fallback map[int]models.Driver) (models.Driver, bool) {
-	if d, err := s.client.GetDriver(sessionKey, driverNumber); err == nil && d != nil {
+	if d, err := client.GetDriver(sessionKey, driverNumber); err == nil && d != nil {
 		return *d, true
 	}
 	d, ok := fallback[driverNumber]
@@ -590,11 +651,17 @@ func (s *Server) handleChampionshipTeams(w http.ResponseWriter, r *http.Request)
 	if year == 0 {
 		year = time.Now().Year()
 	}
-	teams, err := s.client.GetTeamChampionshipForYear(year)
+	client := s.client.Scoped()
+	teams, err := client.GetTeamChampionshipForYear(year)
 	if err != nil {
-		writeError(w, err, http.StatusInternalServerError, s.client.LastResponseWasStale())
+		writeError(w, err, http.StatusInternalServerError, client.LastResponseWasStale())
 		return
 	}
+	if len(teams) == 0 {
+		markOpenF1Availability(w, client, "limited")
+	} else {
+		markOpenF1Response(w, client)
+	}
 	writeJSON(w, teams)
 }
 
@@ -672,6 +739,8 @@ func champHubTTL(year int, now time.Time) time.Duration {
 
 type champHubEntry struct {
 	resp      champHubResponse
+	source    string
+	freshness string
 	expires   time.Time
 }
 
@@ -693,12 +762,26 @@ func (c *champHubCache) get(year int, now time.Time) (champHubResponse, bool) {
 }
 
 func (c *champHubCache) put(year int, resp champHubResponse, now time.Time, ttl time.Duration) {
+	c.putWithMetadata(year, resp, "local", "local", now, ttl)
+}
+
+func (c *champHubCache) getWithMetadata(year int, now time.Time) (champHubResponse, string, string, bool) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	e, ok := c.entries[year]
+	if !ok || now.After(e.expires) {
+		return champHubResponse{}, "", "", false
+	}
+	return e.resp, e.source, e.freshness, true
+}
+
+func (c *champHubCache) putWithMetadata(year int, resp champHubResponse, source, freshness string, now time.Time, ttl time.Duration) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 	if c.entries == nil {
 		c.entries = map[int]champHubEntry{}
 	}
-	c.entries[year] = champHubEntry{resp: resp, expires: now.Add(ttl)}
+	c.entries[year] = champHubEntry{resp: resp, source: source, freshness: freshness, expires: now.Add(ttl)}
 }
 
 // fetchMeetingRaces fans fetch out across meetings with bounded concurrency.
@@ -740,13 +823,6 @@ func (s *Server) handleChampionshipHub(w http.ResponseWriter, r *http.Request) {
 	}
 	mode := parseSourceMode(r)
 
-	if mode != sourceLocal {
-		if resp, ok := s.hubCache.get(year, time.Now()); ok {
-			writeJSON(w, resp)
-			return
-		}
-	}
-
 	if mode == sourceLocal || mode == sourceAuto {
 		resp, ok, err := s.localChampionshipHub(year)
 		if err != nil {
@@ -754,21 +830,33 @@ func (s *Server) handleChampionshipHub(w http.ResponseWriter, r *http.Request) {
 			return
 		}
 		if ok {
-			s.hubCache.put(year, resp, time.Now(), champHubTTL(year, time.Now()))
+			s.hubCache.putWithMetadata(year, resp, "local", "local", time.Now(), champHubTTL(year, time.Now()))
+			markLocalResponse(w, false)
 			writeJSON(w, resp)
 			return
 		}
 		if mode == sourceLocal {
+			markDataResponse(w, "none", "limited")
 			writeJSON(w, resp)
 			return
 		}
 	}
 
-	resp, err := s.openF1ChampionshipHub(year)
+	// At this point an auto request has no usable domain aggregate and an
-	if err != nil {
+	// explicit OpenF1 request must not be satisfied by a local cache entry.
-		writeError(w, err, http.StatusInternalServerError, s.client.LastResponseWasStale())
+	if resp, source, freshness, ok := s.hubCache.getWithMetadata(year, time.Now()); ok && source == "openf1" {
+		markDataResponse(w, source, freshness)
+		writeJSON(w, resp)
 		return
 	}
+
+	client := s.client.Scoped()
+	resp, incomplete, err := s.openF1ChampionshipHub(client, year)
+	if err != nil {
+		writeError(w, err, http.StatusInternalServerError, client.LastResponseWasStale())
+		return
+	}
+	markOpenF1AggregateResponse(w, client, incomplete)
 	writeJSON(w, resp)
 }
 
@@ -797,25 +885,35 @@ func (s *Server) localChampionshipHub(year int) (champHubResponse, bool, error)
 	return aggregateChampionshipHub(year, races, inputs.Champ, inputs.Teams, inputs.DriverMap), true, nil
 }
 
-func (s *Server) openF1ChampionshipHub(year int) (champHubResponse, error) {
+func (s *Server) openF1ChampionshipHub(client *api.OpenF1Client, year int) (champHubResponse, bool, error) {
-	champ, err := s.client.GetDriverChampionshipForYear(year)
+	champ, err := client.GetDriverChampionshipForYear(year)
 	if err != nil {
-		return champHubResponse{}, err
+		return champHubResponse{}, false, err
 	}
 	if len(champ) == 0 {
-		return champHubResponse{Season: year, RoundLabels: []string{}, Drivers: []champHubDriver{}, Teams: []champHubTeam{}}, nil
+		return champHubResponse{Season: year, RoundLabels: []string{}, Drivers: []champHubDriver{}, Teams: []champHubTeam{}}, true, nil
 	}
-	teams, _ := s.client.GetTeamChampionshipForYear(year)
+	teams, teamsErr := client.GetTeamChampionshipForYear(year)
 
 	driverInfo := map[int]models.Driver{}
-	if ds, derr := s.client.GetDriversForSession(champ[0].SessionKey); derr == nil {
+	driversIncomplete := false
+	if ds, derr := client.GetDriversForSession(champ[0].SessionKey); derr == nil {
 		driverInfo = buildDriverMapFirst(ds)
+	} else {
+		driversIncomplete = true
+	}
+	for _, standing := range champ {
+		if !hasDriverPresentation(driverInfo[standing.DriverNumber]) {
+			driversIncomplete = true
+			break
+		}
 	}
 
-	races, incomplete, err := s.fetchSeasonRaces(year)
+	races, incomplete, err := fetchSeasonRaces(client, year)
 	if err != nil {
-		return champHubResponse{}, err
+		return champHubResponse{}, false, err
 	}
+	incomplete = incomplete || teamsErr != nil || driversIncomplete
 
 	resp := aggregateChampionshipHub(year, races, champ, teams, driverInfo)
 	ttl := champHubTTL(year, time.Now())
@@ -825,16 +923,22 @@ func (s *Server) openF1ChampionshipHub(year int) (champHubResponse, error) {
 		// so a partial view of the season doesn't stick around for the full TTL.
 		ttl = champHubIncompleteTTL
 	}
-	s.hubCache.put(year, resp, time.Now(), ttl)
+	freshness := "fresh"
-	return resp, nil
+	if client.LastResponseWasStale() {
+		freshness = "stale"
+	} else if incomplete {
+		freshness = "partial"
+	}
+	s.hubCache.putWithMetadata(year, resp, "openf1", freshness, time.Now(), ttl)
+	return resp, incomplete, nil
 }
 
 // fetchSeasonRaces returns a season's GP meetings in date order, each bundled
 // with its race results and starting grid fetched from OpenF1. incomplete
 // reports whether any per-meeting fetch failed, so callers can avoid caching a
 // partial view of the season for long.
-func (s *Server) fetchSeasonRaces(year int) (races []meetingRace, incomplete bool, err error) {
+func fetchSeasonRaces(client *api.OpenF1Client, year int) (races []meetingRace, incomplete bool, err error) {
-	meetings, err := s.client.GetMeetingsForYear(year)
+	meetings, err := client.GetMeetingsForYear(year)
 	if err != nil {
 		return nil, false, err
 	}
@@ -842,7 +946,7 @@ func (s *Server) fetchSeasonRaces(year int) (races []meetingRace, incomplete boo
 
 	var failed atomic.Bool
 	races = fetchMeetingRaces(meetings, champHubWorkers, func(m models.Meeting) (meetingRace, bool) {
-		sessions, serr := s.client.GetSessionsForMeeting(int(m.MeetingKey))
+		sessions, serr := client.GetSessionsForMeeting(int(m.MeetingKey))
 		if serr != nil {
 			failed.Store(true)
 			return meetingRace{}, false
@@ -855,10 +959,17 @@ func (s *Server) fetchSeasonRaces(year int) (races []meetingRace, incomplete boo
 			}
 		}
 		if raceKey == 0 {
-			return meetingRace{}, false // not a GP meeting (e.g. pre-season testing)
+			if isKnownNonChampionshipMeeting(m, sessions) {
+				return meetingRace{}, false
 			}
-		results, rerr := s.client.GetSessionResult(raceKey)
+			failed.Store(true)
-		grid, gerr := s.client.GetStartingGrid(raceKey)
+			// The meeting list does not identify non-championship events. Skipping
+			// a meeting without a Race may be expected (testing), but the aggregate
+			// is not proven complete and must be labelled partial.
+			return meetingRace{}, false
+		}
+		results, rerr := client.GetSessionResult(raceKey)
+		grid, gerr := client.GetStartingGrid(raceKey)
 		if rerr != nil || gerr != nil {
 			failed.Store(true)
 		}
@@ -867,6 +978,29 @@ func (s *Server) fetchSeasonRaces(year int) (races []meetingRace, incomplete boo
 	return races, failed.Load(), nil
 }
 
+func isKnownNonChampionshipMeeting(meeting models.Meeting, sessions []models.Session) bool {
+	if hasTestingToken(meeting.MeetingName + " " + meeting.MeetingOfficialName) {
+		return true
+	}
+	for _, session := range sessions {
+		if hasTestingToken(session.SessionName + " " + session.SessionType) {
+			return true
+		}
+	}
+	return false
+}
+
+func hasTestingToken(value string) bool {
+	for _, token := range strings.FieldsFunc(strings.ToLower(value), func(r rune) bool {
+		return (r < 'a' || r > 'z') && (r < '0' || r > '9')
+	}) {
+		if token == "test" || token == "tests" || token == "testing" {
+			return true
+		}
+	}
+	return false
+}
+
 // aggregateChampionshipHub is the pure aggregation core (no network) so it can be
 // unit-tested with synthetic data. races must be ordered ascending by date and
 // contain only GP meetings (those with a Race session).
@@ -1077,6 +1211,7 @@ type trackOutlineResponse struct {
 }
 
 func (s *Server) handleTrackOutline(w http.ResponseWriter, r *http.Request) {
+	markLocalResponse(w, false)
 	year, _ := strconv.Atoi(r.URL.Query().Get("year"))
 	if year == 0 {
 		year = time.Now().Year()
@@ -1281,14 +1416,17 @@ func (s *Server) handleStrategy(w http.ResponseWriter, r *http.Request) {
 		stintsErr  error
 		pitsErr    error
 		resErr     error
+		driversErr error
+		rcErr      error
 		wg         sync.WaitGroup
 	)
+	client := s.client.Scoped()
 	wg.Add(5)
-	go func() { defer wg.Done(); stints, stintsErr = s.client.GetStintsForSession(sessionKey) }()
+	go func() { defer wg.Done(); stints, stintsErr = client.GetStintsForSession(sessionKey) }()
-	go func() { defer wg.Done(); pits, pitsErr = s.client.GetPitStopsForSession(sessionKey) }()
+	go func() { defer wg.Done(); pits, pitsErr = client.GetPitStopsForSession(sessionKey) }()
-	go func() { defer wg.Done(); results, resErr = s.client.GetSessionResult(sessionKey) }()
+	go func() { defer wg.Done(); results, resErr = client.GetSessionResult(sessionKey) }()
-	go func() { defer wg.Done(); drivers, _ = s.client.GetDriversForSession(sessionKey) }()
+	go func() { defer wg.Done(); drivers, driversErr = client.GetDriversForSession(sessionKey) }()
-	go func() { defer wg.Done(); rc, _ = s.client.GetRaceControl(sessionKey) }()
+	go func() { defer wg.Done(); rc, rcErr = client.GetRaceControl(sessionKey) }()
 	wg.Wait()
 
 	if stintsErr != nil || pitsErr != nil || resErr != nil {
@@ -1299,17 +1437,21 @@ func (s *Server) handleStrategy(w http.ResponseWriter, r *http.Request) {
 		if e == nil {
 			e = resErr
 		}
-		writeError(w, e, http.StatusInternalServerError, s.client.LastResponseWasStale())
+		writeError(w, e, http.StatusInternalServerError, client.LastResponseWasStale())
 		return
 	}
 
-	// Non-race sessions have no stints.
+	// Empty strategy data may mean a non-race session or a race still settling.
 	if len(stints) == 0 {
+		// Without session-type evidence, an empty primary strategy dataset is
+		// not enough to prove "not applicable" (it may still be settling).
+		markOpenF1Availability(w, client, "limited")
 		writeJSON(w, map[string]any{"note": "Not applicable", "drivers": []any{}})
 		return
 	}
 
 	driverMap := buildDriverMap(drivers)
+	incomplete := driversErr != nil || rcErr != nil
 
 	resultMap := make(map[int]models.SessionResult, len(results))
 	totalLaps := 0
@@ -1342,6 +1484,9 @@ func (s *Server) handleStrategy(w http.ResponseWriter, r *http.Request) {
 	stratDrivers := make([]strategyDriver, 0, len(seenDrivers))
 	for dn := range seenDrivers {
 		d := driverMap[dn]
+		if !hasDriverPresentation(d) {
+			incomplete = true
+		}
 		res := resultMap[dn]
 
 		sd := strategyDriver{
@@ -1396,6 +1541,7 @@ func (s *Server) handleStrategy(w http.ResponseWriter, r *http.Request) {
 		return pi < pj
 	})
 
+	markOpenF1AggregateResponse(w, client, incomplete)
 	writeJSON(w, strategyResponse{
 		SessionKey: sessionKey,
 		TotalLaps:  totalLaps,
@@ -1495,17 +1641,27 @@ func (s *Server) handleLapsComparison(w http.ResponseWriter, r *http.Request) {
 		stints    []models.Stint
 		pits      []models.Pit
 		rc        []models.RaceControl
+		lapsErr   error
+		stintsErr error
+		pitsErr   error
+		rcErr     error
 		wg        sync.WaitGroup
 	)
+	client := s.client.Scoped()
 	wg.Add(4)
-	go func() { defer wg.Done(); allLaps, _ = s.client.GetLapsForSession(sessionKey) }()
+	go func() { defer wg.Done(); allLaps, lapsErr = client.GetLapsForSession(sessionKey) }()
-	go func() { defer wg.Done(); stints, _ = s.client.GetStintsForSession(sessionKey) }()
+	go func() { defer wg.Done(); stints, stintsErr = client.GetStintsForSession(sessionKey) }()
-	go func() { defer wg.Done(); pits, _ = s.client.GetPitStopsForSession(sessionKey) }()
+	go func() { defer wg.Done(); pits, pitsErr = client.GetPitStopsForSession(sessionKey) }()
-	go func() { defer wg.Done(); rc, _ = s.client.GetRaceControl(sessionKey) }()
+	go func() { defer wg.Done(); rc, rcErr = client.GetRaceControl(sessionKey) }()
 	wg.Wait()
+	if lapsErr != nil {
+		writeError(w, lapsErr, http.StatusInternalServerError, client.LastResponseWasStale())
+		return
+	}
 
-	allDrivers, _ := s.client.GetDriversForSession(sessionKey)
+	allDrivers, driversErr := client.GetDriversForSession(sessionKey)
 	driverMap := buildDriverMap(allDrivers)
+	incomplete := stintsErr != nil || pitsErr != nil || rcErr != nil || driversErr != nil
 
 	// If no filter, default to first 3 unique driver numbers from lap data.
 	if len(requestedDrivers) == 0 {
@@ -1543,6 +1699,9 @@ func (s *Server) handleLapsComparison(w http.ResponseWriter, r *http.Request) {
 	compDrivers := make([]comparisonDriver, 0, len(requestedDrivers))
 	for _, dn := range requestedDrivers {
 		d := driverMap[dn]
+		if !hasDriverPresentation(d) {
+			incomplete = true
+		}
 		cd := comparisonDriver{
 			DriverNumber: dn,
 			NameAcronym:  d.NameAcronym,
@@ -1558,6 +1717,13 @@ func (s *Server) handleLapsComparison(w http.ResponseWriter, r *http.Request) {
 		compDrivers = append(compDrivers, cd)
 	}
 
+	freshness := "fresh"
+	if len(allLaps) == 0 {
+		freshness = "limited"
+	} else if incomplete {
+		freshness = "partial"
+	}
+	markOpenF1Availability(w, client, freshness)
 	writeJSON(w, lapsComparisonResponse{
 		SessionKey: sessionKey,
 		SCPeriods:  extractSCPeriods(rc),

internal/web/championship_hub_test.go

@@ -1,13 +1,136 @@
 package web
 
 import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
 	"sync/atomic"
 	"testing"
 	"time"
 
+	"github.com/AmanTahiliani/box-box/internal/api"
 	"github.com/AmanTahiliani/box-box/internal/models"
 )
 
+func championshipTestUpstream(t *testing.T, driversOK, meetingHasRace bool) *httptest.Server {
+	t.Helper()
+	completed := time.Now().Add(-time.Hour).UTC().Format(time.RFC3339)
+	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		switch r.URL.Path {
+		case "/v1/sessions":
+			if r.URL.Query().Get("session_name") == "Race" {
+				_, _ = fmt.Fprintf(w, `[{"session_key":99,"session_name":"Race","date_end":%q}]`, completed)
+				return
+			}
+			if meetingHasRace {
+				_, _ = w.Write([]byte(`[{"session_key":101,"meeting_key":1,"session_name":"Race"}]`))
+			} else {
+				_, _ = w.Write([]byte(`[{"session_key":100,"meeting_key":1,"session_name":"Practice 1"}]`))
+			}
+		case "/v1/championship_drivers":
+			_, _ = w.Write([]byte(`[{"driver_number":1,"session_key":99,"position_current":1,"points_current":25}]`))
+		case "/v1/championship_teams":
+			_, _ = w.Write([]byte(`[{"team_name":"Red Bull","position_current":1,"points_current":25}]`))
+		case "/v1/drivers":
+			if !driversOK {
+				http.Error(w, "identity unavailable", http.StatusBadGateway)
+				return
+			}
+			_, _ = w.Write([]byte(`[{"driver_number":1,"name_acronym":"VER","full_name":"Max Verstappen","team_name":"Red Bull","team_colour":"3671c6"}]`))
+		case "/v1/meetings":
+			_, _ = w.Write([]byte(`[{"meeting_key":1,"meeting_name":"Mystery Grand Prix"}]`))
+		case "/v1/session_result":
+			_, _ = w.Write([]byte(`[{"driver_number":1,"position":1,"points":25}]`))
+		case "/v1/starting_grid":
+			_, _ = w.Write([]byte(`[{"driver_number":1,"position":1}]`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+}
+
+func TestOpenF1ChampionshipHubIdentityFailureIsPartialAndCached(t *testing.T) {
+	upstream := championshipTestUpstream(t, false, true)
+	defer upstream.Close()
+	client := api.NewOpenF1Client(upstream.URL, 2*time.Second)
+	defer client.Close()
+	server := NewServer(client, 0, nil)
+	year := time.Now().Year()
+
+	_, incomplete, err := server.openF1ChampionshipHub(client.Scoped(), year)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !incomplete {
+		t.Fatal("missing championship driver identity was labelled complete")
+	}
+	_, source, freshness, ok := server.hubCache.getWithMetadata(year, time.Now())
+	if !ok || source != "openf1" || freshness != "partial" {
+		t.Fatalf("cached metadata = hit %v, %q/%q", ok, source, freshness)
+	}
+}
+
+func TestFetchSeasonRacesMeetingWithoutRaceIsIncomplete(t *testing.T) {
+	upstream := championshipTestUpstream(t, true, false)
+	defer upstream.Close()
+	client := api.NewOpenF1Client(upstream.URL, 2*time.Second)
+	defer client.Close()
+
+	races, incomplete, err := fetchSeasonRaces(client.Scoped(), time.Now().Year())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !incomplete || len(races) != 0 {
+		t.Fatalf("no-Race meeting = races %d, incomplete %v", len(races), incomplete)
+	}
+}
+
+func TestFetchSeasonRacesRecognizedTestingMeetingIsNotIncomplete(t *testing.T) {
+	upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/v1/meetings":
+			_, _ = w.Write([]byte(`[{"meeting_key":1253,"meeting_name":"Pre-Season Testing"}]`))
+		case "/v1/sessions":
+			_, _ = w.Write([]byte(`[{"session_key":1,"meeting_key":1253,"session_name":"Day 1","session_type":"Testing"}]`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer upstream.Close()
+	client := api.NewOpenF1Client(upstream.URL, 2*time.Second)
+	defer client.Close()
+
+	races, incomplete, err := fetchSeasonRaces(client.Scoped(), time.Now().Year())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if incomplete || len(races) != 0 {
+		t.Fatalf("recognized testing meeting = races %d, incomplete %v", len(races), incomplete)
+	}
+}
+
+func TestKnownNonChampionshipMeetingRequiresTestingToken(t *testing.T) {
+	if !isKnownNonChampionshipMeeting(models.Meeting{MeetingName: "Pre-Season Testing"}, nil) {
+		t.Fatal("pre-season testing was not recognized")
+	}
+	if isKnownNonChampionshipMeeting(models.Meeting{MeetingName: "Fastest Grand Prix"}, nil) {
+		t.Fatal("substring inside a normal word was treated as testing")
+	}
+	if !isKnownNonChampionshipMeeting(models.Meeting{MeetingName: "Winter Event"}, []models.Session{{SessionType: "Test"}}) {
+		t.Fatal("explicit Test session was not recognized")
+	}
+}
+
+func TestHandleChampionshipHubSourceLocalWithoutAggregateIsLimited(t *testing.T) {
+	server := NewServer(nil, 0, nil)
+	recorder := httptest.NewRecorder()
+	server.handleChampionshipHub(recorder, httptest.NewRequest(http.MethodGet, "/api/v1/championship/hub?year=2026&source=local", nil))
+	if recorder.Code != http.StatusOK || recorder.Header().Get(dataSourceHeader) != "none" || recorder.Header().Get(dataFreshnessHeader) != "limited" {
+		t.Fatalf("empty local championship = %d %q/%q body=%s", recorder.Code, recorder.Header().Get(dataSourceHeader), recorder.Header().Get(dataFreshnessHeader), recorder.Body.String())
+	}
+}
+
 func raceResult(num, pos int, pts float64) models.SessionResult {
 	return models.SessionResult{DriverNumber: num, Position: pos, Points: pts}
 }

internal/web/component_freshness_test.go

@@ -0,0 +1,120 @@
+package web
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/AmanTahiliani/box-box/internal/api"
+)
+
+func componentTestServer(t *testing.T, responses map[string]string, failures map[string]bool) *Server {
+	t.Helper()
+	upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if failures[r.URL.Path] {
+			http.Error(w, "component unavailable", http.StatusBadGateway)
+			return
+		}
+		body, ok := responses[r.URL.Path]
+		if !ok {
+			http.NotFound(w, r)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write([]byte(body))
+	}))
+	t.Cleanup(upstream.Close)
+	client := api.NewOpenF1Client(upstream.URL, 2*time.Second)
+	t.Cleanup(func() { _ = client.Close() })
+	return NewServer(client, 0, nil)
+}
+
+func assertAvailabilityHeaders(t *testing.T, recorder *httptest.ResponseRecorder, source, freshness string) {
+	t.Helper()
+	if recorder.Code != http.StatusOK || recorder.Header().Get(dataSourceHeader) != source || recorder.Header().Get(dataFreshnessHeader) != freshness {
+		t.Fatalf("response = status %d, metadata %q/%q, body=%s", recorder.Code, recorder.Header().Get(dataSourceHeader), recorder.Header().Get(dataFreshnessHeader), recorder.Body.String())
+	}
+}
+
+func TestResultsAndGridIdentityFailuresReportPartial(t *testing.T) {
+	tests := []struct {
+		name string
+		path string
+		body string
+		run  func(*Server, http.ResponseWriter, *http.Request)
+	}{
+		{name: "results", path: "/v1/session_result", body: `[{"driver_number":1,"position":1}]`, run: func(s *Server, w http.ResponseWriter, r *http.Request) { s.handleResults(w, r) }},
+		{name: "grid", path: "/v1/starting_grid", body: `[{"driver_number":1,"position":1}]`, run: func(s *Server, w http.ResponseWriter, r *http.Request) { s.handleGrid(w, r) }},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			server := componentTestServer(t, map[string]string{tt.path: tt.body}, map[string]bool{"/v1/drivers": true})
+			recorder := httptest.NewRecorder()
+			tt.run(server, recorder, httptest.NewRequest(http.MethodGet, "/api/v1/"+tt.name+"?session_key=99&source=openf1", nil))
+			assertAvailabilityHeaders(t, recorder, "openf1", "partial")
+		})
+	}
+}
+
+func TestStrategyOptionalComponentFailureReportsPartial(t *testing.T) {
+	server := componentTestServer(t, map[string]string{
+		"/v1/stints":         `[{"driver_number":1,"stint_number":1,"lap_start":1,"lap_end":10,"compound":"MEDIUM"}]`,
+		"/v1/pit":            `[]`,
+		"/v1/session_result": `[{"driver_number":1,"position":1,"number_of_laps":10}]`,
+		"/v1/race_control":   `[]`,
+	}, map[string]bool{"/v1/drivers": true})
+	recorder := httptest.NewRecorder()
+	server.handleStrategy(recorder, httptest.NewRequest(http.MethodGet, "/api/v1/strategy?session_key=99", nil))
+	assertAvailabilityHeaders(t, recorder, "openf1", "partial")
+}
+
+func TestStrategyEmptyPrimaryDataReportsLimited(t *testing.T) {
+	server := componentTestServer(t, map[string]string{
+		"/v1/stints":         `[]`,
+		"/v1/pit":            `[]`,
+		"/v1/session_result": `[{"driver_number":1,"position":1,"number_of_laps":10}]`,
+		"/v1/drivers":        `[{"driver_number":1,"full_name":"Max Verstappen","team_name":"Red Bull","team_colour":"3671c6"}]`,
+		"/v1/race_control":   `[]`,
+	}, nil)
+	recorder := httptest.NewRecorder()
+	server.handleStrategy(recorder, httptest.NewRequest(http.MethodGet, "/api/v1/strategy?session_key=99", nil))
+	assertAvailabilityHeaders(t, recorder, "openf1", "limited")
+}
+
+func TestLapsComparisonDoesNotLabelMissingComponentsFresh(t *testing.T) {
+	tests := []struct {
+		name      string
+		laps      string
+		freshness string
+	}{
+		{name: "empty primary data", laps: `[]`, freshness: "limited"},
+		{name: "optional components failed", laps: `[{"driver_number":1,"lap_number":1}]`, freshness: "partial"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			server := componentTestServer(t, map[string]string{"/v1/laps": tt.laps}, map[string]bool{
+				"/v1/stints":       true,
+				"/v1/pit":          true,
+				"/v1/race_control": true,
+				"/v1/drivers":      true,
+			})
+			recorder := httptest.NewRecorder()
+			server.handleLapsComparison(recorder, httptest.NewRequest(http.MethodGet, "/api/v1/laps/comparison?session_key=99", nil))
+			assertAvailabilityHeaders(t, recorder, "openf1", tt.freshness)
+		})
+	}
+	t.Run("primary laps failure is an error", func(t *testing.T) {
+		server := componentTestServer(t, nil, map[string]bool{
+			"/v1/laps":         true,
+			"/v1/stints":       true,
+			"/v1/pit":          true,
+			"/v1/race_control": true,
+		})
+		recorder := httptest.NewRecorder()
+		server.handleLapsComparison(recorder, httptest.NewRequest(http.MethodGet, "/api/v1/laps/comparison?session_key=99", nil))
+		if recorder.Code != http.StatusInternalServerError {
+			t.Fatalf("status = %d body=%s", recorder.Code, recorder.Body.String())
+		}
+	})
+}

internal/web/context.go

@@ -10,6 +10,7 @@ import (
 
 func (s *Server) handleWeekendContext(w http.ResponseWriter, _ *http.Request) {
 	if !s.hasLocalQuery() {
+		markDataResponse(w, "none", "limited")
 		writeJSON(w, query.WeekendContext{TemporalState: query.TemporalNoSeason})
 		return
 	}
@@ -29,9 +30,33 @@ func (s *Server) handleWeekendContext(w http.ResponseWriter, _ *http.Request) {
 		writeError(w, err, http.StatusInternalServerError, false)
 		return
 	}
+	if focus := focusedContextSession(context); focus != nil {
+		markDataResponse(w, focus.Availability.Source, focus.Availability.Freshness)
+	} else {
+		markDataResponse(w, "none", "limited")
+	}
 	writeJSON(w, context)
 }
 
+// focusedContextSession selects the session whose state the Weekend shell is
+// presenting. An older terminal/default session must never override an
+// upcoming focus session's metadata.
+func focusedContextSession(context query.WeekendContext) *query.ContextSession {
+	if context.ActiveSession != nil {
+		return context.ActiveSession
+	}
+	if context.FocusMeeting == nil {
+		return nil
+	}
+	focusKey := context.FocusMeeting.MeetingKey
+	for _, ref := range []*query.ContextSession{context.NextSession, context.PreviousCompletedSession, context.DefaultAnalysisSession} {
+		if ref != nil && ref.Meeting != nil && ref.Meeting.MeetingKey == focusKey {
+			return ref
+		}
+	}
+	return nil
+}
+
 func liveEvidence(data *live.LiveStreamData, active, final bool) query.LiveEvidence {
 	return query.LiveEvidence{Active: active, Final: final, MeetingName: data.Session.MeetingName, CircuitName: data.Session.CircuitName, SessionName: data.Session.SessionName, SessionType: data.Session.SessionType}
 }

internal/web/context_test.go

@@ -47,6 +47,19 @@ func TestWeekendContextHandlerWithoutStoreReturnsNoSeason(t *testing.T) {
 	if got.TemporalState != query.TemporalNoSeason {
 		t.Fatalf("state = %s", got.TemporalState)
 	}
+	if rr.Header().Get(dataSourceHeader) != "none" || rr.Header().Get(dataFreshnessHeader) != "limited" {
+		t.Fatalf("missing context metadata = %q/%q", rr.Header().Get(dataSourceHeader), rr.Header().Get(dataFreshnessHeader))
+	}
+}
+
+func TestWeekendContextHandlerEmptyStoreReportsLimited(t *testing.T) {
+	st := openContextStore(t)
+	s := NewServer(nil, 0, st)
+	rr := httptest.NewRecorder()
+	s.handleWeekendContext(rr, httptest.NewRequest(http.MethodGet, "/api/v1/weekend-context", nil))
+	if rr.Code != http.StatusOK || rr.Header().Get(dataSourceHeader) != "none" || rr.Header().Get(dataFreshnessHeader) != "limited" {
+		t.Fatalf("empty context = %d %q/%q body=%s", rr.Code, rr.Header().Get(dataSourceHeader), rr.Header().Get(dataFreshnessHeader), rr.Body.String())
+	}
 }
 
 func TestWeekendContextHandlerUsesLiveHubIdentityWithoutOpenF1(t *testing.T) {
@@ -76,6 +89,12 @@ func TestWeekendContextHandlerUsesLiveHubIdentityWithoutOpenF1(t *testing.T) {
 	if got.ActiveSession.Availability.LiveTransport != "connected" || got.ActiveSession.Availability.LiveSession != "active" {
 		t.Fatalf("availability = %+v", got.ActiveSession.Availability)
 	}
+	if got.ActiveSession.Availability.Source != "mixed" || got.ActiveSession.Availability.Freshness != "live" {
+		t.Fatalf("live source/freshness = %+v", got.ActiveSession.Availability)
+	}
+	if rr.Header().Get(dataSourceHeader) != "mixed" || rr.Header().Get(dataFreshnessHeader) != "live" {
+		t.Fatalf("response source/freshness = %q/%q", rr.Header().Get(dataSourceHeader), rr.Header().Get(dataFreshnessHeader))
+	}
 }
 
 func TestWeekendContextHandlerUsesTerminalArchiveAsCompletionEvidence(t *testing.T) {
@@ -94,11 +113,48 @@ func TestWeekendContextHandlerUsesTerminalArchiveAsCompletionEvidence(t *testing
 	if got.PreviousCompletedSession == nil || got.PreviousCompletedSession.Availability.Archive != "available" {
 		t.Fatalf("archive context = %+v", got)
 	}
+	if got.PreviousCompletedSession.Availability.Source != "mixed" || got.PreviousCompletedSession.Availability.Freshness != "archive" {
+		t.Fatalf("archive source/freshness = %+v", got.PreviousCompletedSession.Availability)
+	}
+	if rr.Header().Get(dataSourceHeader) != "mixed" || rr.Header().Get(dataFreshnessHeader) != "archive" {
+		t.Fatalf("archive response source/freshness = %q/%q", rr.Header().Get(dataSourceHeader), rr.Header().Get(dataFreshnessHeader))
+	}
 	if got.DefaultAnalysisSession != nil {
 		t.Fatal("archive-only session must not become local default analysis")
 	}
 }
 
+func TestWeekendContextMetadataFollowsUpcomingFocusNotTerminalPrevious(t *testing.T) {
+	st := openContextStore(t)
+	seedContextHandler(t, st)
+	if err := st.UpsertMeeting(store.Meeting{MeetingKey: 2, MeetingName: "Belgian Grand Prix", CircuitShortName: "Spa", Year: 2026, DateStart: "2026-07-10T09:00:00Z", DateEnd: "2026-07-12T16:00:00Z"}); err != nil {
+		t.Fatal(err)
+	}
+	if err := st.UpsertSession(store.Session{SessionKey: 21, MeetingKey: 2, SessionName: "Practice 1", SessionType: "Practice", DateStart: "2026-07-10T09:00:00Z", DateEnd: "2026-07-10T10:00:00Z"}); err != nil {
+		t.Fatal(err)
+	}
+	now, _ := time.Parse(time.RFC3339, "2026-07-05T16:05:00Z")
+	s := NewServer(nil, 0, st)
+	s.query = query.NewServiceWithClock(st, func() time.Time { return now })
+	s.hub.applySnapshot(live.LiveStreamData{SessionStatus: "Finished", Session: live.LiveSessionMeta{MeetingName: "British Grand Prix", CircuitName: "Silverstone", SessionName: "Race", SessionType: "Race"}}, now)
+
+	rr := httptest.NewRecorder()
+	s.handleWeekendContext(rr, httptest.NewRequest(http.MethodGet, "/api/v1/weekend-context", nil))
+	var got query.WeekendContext
+	if err := json.Unmarshal(rr.Body.Bytes(), &got); err != nil {
+		t.Fatal(err)
+	}
+	if got.FocusMeeting == nil || got.FocusMeeting.MeetingKey != 2 || got.NextSession == nil {
+		t.Fatalf("focus context = %+v", got)
+	}
+	if got.PreviousCompletedSession == nil || got.PreviousCompletedSession.Availability.Freshness != "archive" {
+		t.Fatalf("terminal previous missing = %+v", got.PreviousCompletedSession)
+	}
+	if rr.Header().Get(dataSourceHeader) != "local" || rr.Header().Get(dataFreshnessHeader) != "local" {
+		t.Fatalf("focus metadata was overridden by archive = %q/%q", rr.Header().Get(dataSourceHeader), rr.Header().Get(dataFreshnessHeader))
+	}
+}
+
 func TestTerminalSessionStatus(t *testing.T) {
 	for _, status := range []string{"Finished", "Finalised", "ENDED", "Aborted"} {
 		if !terminalSessionStatus(status) {

internal/web/driversummary.go

@@ -1,18 +1,25 @@
 package web
 
 import (
+	"context"
 	"fmt"
 	"net/http"
 	"strconv"
 	"time"
 
+	"github.com/AmanTahiliani/box-box/internal/api"
 	"github.com/AmanTahiliani/box-box/internal/models"
 )
 
 // --- /api/v1/driver/summary ---
-// Per-driver season summary: championship standing plus per-round race results,
+// Per-driver season summary: championship standing plus per-round race results.
-// aggregated server-side from the same sources as the championship hub. Caching
+// Current-season identity/results are local-first from the domain DB. Optional
-// relies on the OpenF1 client's HTTP cache TTLs — no extra layer here.
+// OpenF1 enrichment (headshot / polished identity) is bounded so it cannot hang
+// the profile when remote data is slow or unavailable.
+
+// driverEnrichmentTimeout bounds optional remote enrichment so a hung OpenF1
+// call never blocks a local-first profile response. Overridable in tests.
+var driverEnrichmentTimeout = 2 * time.Second
 
 type driverSummaryRound struct {
 	MeetingKey  int    `json:"meeting_key"`
@@ -49,6 +56,11 @@ type driverSummaryResponse struct {
 	Cumulative   []float64            `json:"cumulative"`
 	RoundLabels  []string             `json:"round_labels"`
 	Rounds       []driverSummaryRound `json:"rounds"`
+	// Source is "local" when served from the domain DB, else "openf1".
+	Source string `json:"source,omitempty"`
+	// Enrichment is "full" when optional remote identity landed, "limited"
+	// when it timed out/failed, or "none" when no enrichment was attempted.
+	Enrichment string `json:"enrichment,omitempty"`
 }
 
 func (s *Server) handleDriverSummary(w http.ResponseWriter, r *http.Request) {
@@ -61,12 +73,102 @@ func (s *Server) handleDriverSummary(w http.ResponseWriter, r *http.Request) {
 	if year == 0 {
 		year = time.Now().Year()
 	}
+	mode := parseSourceMode(r)
+	// Driver summary is local-first for current-season identity/results. When the
+	// caller omits ?source=, prefer auto (local then OpenF1) rather than the
+	// package default of openf1-only.
+	if r.URL.Query().Get("source") == "" {
+		mode = sourceAuto
+	}
+	client := s.client.Scoped()
 
-	champ, err := s.client.GetDriverChampionshipForYear(year)
+	if mode == sourceLocal || mode == sourceAuto {
-	if err != nil {
+		resp, sessionKey, ok, lerr := s.localDriverSummary(year, driverNumber)
-		writeError(w, err, http.StatusInternalServerError, s.client.LastResponseWasStale())
+		if lerr != nil {
+			writeError(w, lerr, http.StatusInternalServerError, false)
 			return
 		}
+		if ok {
+			if mode != sourceLocal {
+				tryEnrichDriverSummary(r.Context(), client, &resp, sessionKey)
+			}
+			switch resp.Enrichment {
+			case "full":
+				markMixedResponse(w, client, false)
+			case "limited":
+				markDataResponse(w, "local", "limited")
+			default:
+				markLocalResponse(w, false)
+			}
+			writeJSON(w, resp)
+			return
+		}
+		if mode == sourceLocal {
+			http.Error(w, fmt.Sprintf("driver %d not found in %d championship", driverNumber, year), http.StatusNotFound)
+			return
+		}
+	}
+
+	resp, incomplete, err := openF1DriverSummary(client, year, driverNumber)
+	if err != nil {
+		writeError(w, err, http.StatusInternalServerError, client.LastResponseWasStale())
+		return
+	}
+	if resp == nil {
+		http.Error(w, fmt.Sprintf("driver %d not found in %d championship", driverNumber, year), http.StatusNotFound)
+		return
+	}
+	markOpenF1AggregateResponse(w, client, incomplete)
+	writeJSON(w, resp)
+}
+
+func (s *Server) localDriverSummary(year, driverNumber int) (driverSummaryResponse, int, bool, error) {
+	if !s.hasLocalQuery() {
+		return driverSummaryResponse{}, 0, false, nil
+	}
+	inputs, err := s.query.GetChampionshipInputs(year)
+	if err != nil {
+		return driverSummaryResponse{}, 0, false, err
+	}
+	if len(inputs.Champ) == 0 {
+		return driverSummaryResponse{}, 0, false, nil
+	}
+
+	races := make([]meetingRace, 0, len(inputs.Races))
+	for _, race := range inputs.Races {
+		races = append(races, meetingRace{
+			Meeting:        race.Meeting,
+			RaceSessionKey: race.RaceSessionKey,
+			Results:        race.Results,
+			Grid:           race.Grid,
+		})
+	}
+
+	resp, ok := aggregateDriverSummary(year, driverNumber, races, inputs.Champ, inputs.DriverMap)
+	if !ok {
+		return driverSummaryResponse{}, 0, false, nil
+	}
+	resp.Source = "local"
+	resp.Enrichment = "none"
+
+	sessionKey := 0
+	for _, c := range inputs.Champ {
+		if c.DriverNumber == driverNumber && c.SessionKey > 0 {
+			sessionKey = c.SessionKey
+			break
+		}
+		if sessionKey == 0 && c.SessionKey > 0 {
+			sessionKey = c.SessionKey
+		}
+	}
+	return resp, sessionKey, true, nil
+}
+
+func openF1DriverSummary(client *api.OpenF1Client, year, driverNumber int) (*driverSummaryResponse, bool, error) {
+	champ, err := client.GetDriverChampionshipForYear(year)
+	if err != nil {
+		return nil, false, err
+	}
 	var entry *models.ChampionshipDriver
 	for i := range champ {
 		if champ[i].DriverNumber == driverNumber {
@@ -75,30 +177,83 @@ func (s *Server) handleDriverSummary(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 	if entry == nil {
-		http.Error(w, fmt.Sprintf("driver %d not found in %d championship", driverNumber, year), http.StatusNotFound)
+		return nil, false, nil
-		return
 	}
 
 	driverInfo := map[int]models.Driver{}
-	if ds, derr := s.client.GetDriversForSession(champ[0].SessionKey); derr == nil {
+	sessionKey := champ[0].SessionKey
+	if ds, derr := client.GetDriversForSession(sessionKey); derr == nil {
 		driverInfo = buildDriverMapFirst(ds)
 	}
-	if d, ok := s.championshipDriverInfo(entry.SessionKey, driverNumber, driverInfo); ok {
+	d, directErr := client.GetDriver(entry.SessionKey, driverNumber)
-		driverInfo[driverNumber] = d
+	if directErr == nil && d != nil {
+		driverInfo[driverNumber] = *d
+	} else if fallback, ok := driverInfo[driverNumber]; ok {
+		driverInfo[driverNumber] = fallback
 	}
-
+	identityIncomplete := !hasDriverPresentation(driverInfo[driverNumber])
-	races, _, err := s.fetchSeasonRaces(year)
+	races, racesIncomplete, err := fetchSeasonRaces(client, year)
 	if err != nil {
-		writeError(w, err, http.StatusInternalServerError, s.client.LastResponseWasStale())
+		return nil, false, err
-		return
 	}
 
 	resp, ok := aggregateDriverSummary(year, driverNumber, races, champ, driverInfo)
 	if !ok {
-		http.Error(w, fmt.Sprintf("driver %d not found in %d championship", driverNumber, year), http.StatusNotFound)
+		return nil, false, nil
+	}
+	incomplete := identityIncomplete || racesIncomplete
+	resp.Source = "openf1"
+	if identityIncomplete {
+		resp.Enrichment = "limited"
+	} else {
+		resp.Enrichment = "full"
+	}
+	return &resp, incomplete, nil
+}
+
+func hasDriverPresentation(driver models.Driver) bool {
+	hasName := driver.FullName != "" || driver.NameAcronym != "" || driver.BroadcastName != ""
+	return hasName && driver.TeamName != "" && driver.TeamColour != ""
+}
+
+// tryEnrichDriverSummary optionally fills headshot / polished identity from
+// OpenF1. It never blocks longer than driverEnrichmentTimeout — on timeout or
+// failure the local profile remains intact with enrichment=limited.
+func tryEnrichDriverSummary(parent context.Context, client *api.OpenF1Client, resp *driverSummaryResponse, sessionKey int) {
+	if resp == nil || client == nil || sessionKey <= 0 {
+		if resp != nil && resp.Enrichment == "none" {
+			// No session to enrich from — leave as none (local identity only).
+		}
 		return
 	}
-	writeJSON(w, resp)
+
+	ctx, cancel := context.WithTimeout(parent, driverEnrichmentTimeout)
+	defer cancel()
+	driver, err := client.GetDriverContext(ctx, sessionKey, resp.DriverNumber)
+	if err != nil || driver == nil {
+		resp.Enrichment = "limited"
+		return
+	}
+	applyDriverEnrichment(resp, *driver)
+	resp.Enrichment = "full"
+}
+
+func applyDriverEnrichment(resp *driverSummaryResponse, d models.Driver) {
+	if d.HeadshotURL != "" {
+		resp.HeadshotURL = d.HeadshotURL
+	}
+	if d.FullName != "" {
+		resp.FullName = d.FullName
+	}
+	if d.NameAcronym != "" {
+		resp.NameAcronym = d.NameAcronym
+	}
+	if d.TeamName != "" {
+		resp.TeamName = d.TeamName
+	}
+	if d.TeamColour != "" {
+		resp.TeamColour = d.TeamColour
+	}
 }
 
 // aggregateDriverSummary is the pure aggregation core (no network) so it can be

internal/web/driversummary_test.go

@@ -1,11 +1,16 @@
 package web
 
 import (
+	"encoding/json"
+	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"testing"
+	"time"
 
+	"github.com/AmanTahiliani/box-box/internal/api"
 	"github.com/AmanTahiliani/box-box/internal/models"
+	"github.com/AmanTahiliani/box-box/internal/store"
 )
 
 func driverSummaryFixtures() ([]meetingRace, []models.ChampionshipDriver, map[int]models.Driver) {
@@ -134,3 +139,234 @@ func TestHandleDriverSummaryBadRequest(t *testing.T) {
 		}
 	}
 }
+
+func seedDriverSummaryStore(t *testing.T, st *store.Store) {
+	t.Helper()
+	meetingKey := 1201
+	sessionKey := 9901
+
+	if err := st.UpsertMeeting(store.Meeting{
+		MeetingKey:  meetingKey,
+		MeetingName: "Bahrain GP",
+		CountryCode: "BHR",
+		CountryName: "Bahrain",
+		Year:        2025,
+		DateStart:   "2025-03-02",
+	}); err != nil {
+		t.Fatalf("UpsertMeeting: %v", err)
+	}
+	if err := st.UpsertSession(store.Session{
+		SessionKey:  sessionKey,
+		MeetingKey:  meetingKey,
+		SessionName: "Race",
+		SessionType: "Race",
+		DateStart:   "2025-03-02T15:00:00Z",
+	}); err != nil {
+		t.Fatalf("UpsertSession: %v", err)
+	}
+	if err := st.UpsertDriver(store.Driver{
+		DriverNumber: 1,
+		FullName:     "Max Verstappen",
+		NameAcronym:  "VER",
+		TeamName:     "Red Bull",
+		TeamColour:   "3671c6",
+	}); err != nil {
+		t.Fatalf("UpsertDriver: %v", err)
+	}
+	if err := st.UpsertSessionDriver(store.SessionDriver{
+		SessionKey:   sessionKey,
+		DriverNumber: 1,
+		MeetingKey:   meetingKey,
+		FullName:     "Max Verstappen",
+		NameAcronym:  "VER",
+		TeamName:     "Red Bull",
+		TeamColour:   "3671c6",
+	}); err != nil {
+		t.Fatalf("UpsertSessionDriver: %v", err)
+	}
+	if err := st.UpsertSessionResult(store.SessionResult{
+		SessionKey:   sessionKey,
+		DriverNumber: 1,
+		MeetingKey:   meetingKey,
+		Position:     1,
+		Points:       25,
+	}); err != nil {
+		t.Fatalf("UpsertSessionResult: %v", err)
+	}
+	if err := st.UpsertStartingGridEntry(store.StartingGridEntry{
+		SessionKey:   sessionKey,
+		DriverNumber: 1,
+		MeetingKey:   meetingKey,
+		Position:     1,
+	}); err != nil {
+		t.Fatalf("UpsertStartingGridEntry: %v", err)
+	}
+}
+
+func TestHandleDriverSummaryLocalFirstIgnoresHangingEnrichment(t *testing.T) {
+	prev := driverEnrichmentTimeout
+	driverEnrichmentTimeout = 40 * time.Millisecond
+	t.Cleanup(func() { driverEnrichmentTimeout = prev })
+
+	st := openTestStore(t)
+	seedDriverSummaryStore(t, st)
+
+	// Enrichment seam: OpenF1 hangs until released. Local summary must still return.
+	release := make(chan struct{})
+	cancelObserved := make(chan struct{})
+	hang := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		select {
+		case <-release:
+		case <-r.Context().Done():
+			close(cancelObserved)
+		}
+	}))
+	t.Cleanup(func() {
+		close(release)
+		hang.Close()
+	})
+
+	client := api.NewOpenF1Client(hang.URL, 15*time.Second)
+	t.Cleanup(func() { _ = client.Close() })
+	srv := NewServer(client, 8080, st)
+
+	start := time.Now()
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/driver/summary?year=2025&driver_number=1", nil)
+	rec := httptest.NewRecorder()
+	srv.handleDriverSummary(rec, req)
+	elapsed := time.Since(start)
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d body=%s", rec.Code, rec.Body.String())
+	}
+	if elapsed > 500*time.Millisecond {
+		t.Fatalf("handler blocked on enrichment for %v", elapsed)
+	}
+	select {
+	case <-cancelObserved:
+	case <-time.After(250 * time.Millisecond):
+		t.Fatal("timed-out enrichment did not cancel its upstream request")
+	}
+
+	var resp driverSummaryResponse
+	if err := json.NewDecoder(rec.Body).Decode(&resp); err != nil {
+		t.Fatalf("decode: %v", err)
+	}
+	if resp.Source != "local" {
+		t.Errorf("source = %q, want local", resp.Source)
+	}
+	if resp.Enrichment != "limited" {
+		t.Errorf("enrichment = %q, want limited", resp.Enrichment)
+	}
+	if rec.Header().Get(dataSourceHeader) != "local" || rec.Header().Get(dataFreshnessHeader) != "limited" {
+		t.Errorf("limited metadata = %q/%q", rec.Header().Get(dataSourceHeader), rec.Header().Get(dataFreshnessHeader))
+	}
+	if resp.DriverNumber != 1 || resp.NameAcronym != "VER" || resp.Points != 25 {
+		t.Errorf("local identity/results missing: %+v", resp)
+	}
+}
+
+func TestHandleDriverSummaryLocalFirstWithFailingEnrichment(t *testing.T) {
+	prev := driverEnrichmentTimeout
+	driverEnrichmentTimeout = 200 * time.Millisecond
+	t.Cleanup(func() { driverEnrichmentTimeout = prev })
+
+	st := openTestStore(t)
+	seedDriverSummaryStore(t, st)
+
+	fail := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		http.Error(w, "boom", http.StatusBadGateway)
+	}))
+	t.Cleanup(fail.Close)
+
+	client := api.NewOpenF1Client(fail.URL, 2*time.Second)
+	t.Cleanup(func() { _ = client.Close() })
+	srv := NewServer(client, 8080, st)
+
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/driver/summary?year=2025&driver_number=1&source=auto", nil)
+	rec := httptest.NewRecorder()
+	srv.handleDriverSummary(rec, req)
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d body=%s", rec.Code, rec.Body.String())
+	}
+	var resp driverSummaryResponse
+	if err := json.NewDecoder(rec.Body).Decode(&resp); err != nil {
+		t.Fatalf("decode: %v", err)
+	}
+	if resp.Source != "local" {
+		t.Errorf("source = %q, want local", resp.Source)
+	}
+	if resp.Enrichment != "limited" {
+		t.Errorf("enrichment = %q, want limited", resp.Enrichment)
+	}
+	if rec.Header().Get(dataSourceHeader) != "local" || rec.Header().Get(dataFreshnessHeader) != "limited" {
+		t.Errorf("limited metadata = %q/%q", rec.Header().Get(dataSourceHeader), rec.Header().Get(dataFreshnessHeader))
+	}
+	if resp.FullName != "Max Verstappen" {
+		t.Errorf("full_name = %q, want local identity", resp.FullName)
+	}
+}
+
+func TestHandleDriverSummarySourceLocalOnly(t *testing.T) {
+	st := openTestStore(t)
+	seedDriverSummaryStore(t, st)
+
+	// Even with a broken OpenF1 client, source=local must succeed from the DB.
+	fail := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		http.Error(w, "nope", http.StatusInternalServerError)
+	}))
+	t.Cleanup(fail.Close)
+	client := api.NewOpenF1Client(fail.URL, time.Second)
+	t.Cleanup(func() { _ = client.Close() })
+	srv := NewServer(client, 8080, st)
+
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/driver/summary?year=2025&driver_number=1&source=local", nil)
+	rec := httptest.NewRecorder()
+	srv.handleDriverSummary(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d body=%s", rec.Code, rec.Body.String())
+	}
+	if rec.Header().Get(dataSourceHeader) != "local" || rec.Header().Get(dataFreshnessHeader) != "local" {
+		t.Fatalf("local metadata = %q/%q", rec.Header().Get(dataSourceHeader), rec.Header().Get(dataFreshnessHeader))
+	}
+}
+
+func TestHandleRemoteDriverSummaryReportsIdentityAndRoundLimitations(t *testing.T) {
+	tests := []struct {
+		name           string
+		driversOK      bool
+		meetingHasRace bool
+		wantEnrichment string
+	}{
+		{name: "missing identity", driversOK: false, meetingHasRace: true, wantEnrichment: "limited"},
+		{name: "missing race round", driversOK: true, meetingHasRace: false, wantEnrichment: "full"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			upstream := championshipTestUpstream(t, tt.driversOK, tt.meetingHasRace)
+			defer upstream.Close()
+			client := api.NewOpenF1Client(upstream.URL, 2*time.Second)
+			defer client.Close()
+			server := NewServer(client, 0, nil)
+			year := time.Now().Year()
+			recorder := httptest.NewRecorder()
+			request := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/api/v1/driver/summary?year=%d&driver_number=1&source=openf1", year), nil)
+
+			server.handleDriverSummary(recorder, request)
+			if recorder.Code != http.StatusOK {
+				t.Fatalf("status = %d body=%s", recorder.Code, recorder.Body.String())
+			}
+			var response driverSummaryResponse
+			if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
+				t.Fatal(err)
+			}
+			if response.Enrichment != tt.wantEnrichment {
+				t.Fatalf("enrichment = %q, want %q", response.Enrichment, tt.wantEnrichment)
+			}
+			if recorder.Header().Get(dataSourceHeader) != "openf1" || recorder.Header().Get(dataFreshnessHeader) != "partial" {
+				t.Fatalf("remote limitation metadata = %q/%q", recorder.Header().Get(dataSourceHeader), recorder.Header().Get(dataFreshnessHeader))
+			}
+		})
+	}
+}

internal/web/freshness.go

@@ -0,0 +1,65 @@
+package web
+
+import (
+	"net/http"
+)
+
+const (
+	dataSourceHeader    = "X-BoxBox-Data-Source"
+	dataFreshnessHeader = "X-BoxBox-Data-Freshness"
+)
+
+type staleResponseReporter interface {
+	LastResponseWasStale() bool
+}
+
+// markOpenF1Response publishes request-scoped success provenance. Callers must
+// pass the scoped client used for this response, never Server.client.
+func markOpenF1Response(w http.ResponseWriter, client staleResponseReporter) {
+	markOpenF1AggregateResponse(w, client, false)
+}
+
+func markOpenF1AggregateResponse(w http.ResponseWriter, client staleResponseReporter, partial bool) {
+	freshness := "fresh"
+	if partial {
+		freshness = "partial"
+	}
+	markOpenF1Availability(w, client, freshness)
+}
+
+func markOpenF1Availability(w http.ResponseWriter, client staleResponseReporter, freshness string) {
+	w.Header().Set(dataSourceHeader, "openf1")
+	if client != nil && client.LastResponseWasStale() {
+		w.Header().Set(dataFreshnessHeader, "stale")
+		return
+	}
+	if freshness == "" {
+		freshness = "fresh"
+	}
+	w.Header().Set(dataFreshnessHeader, freshness)
+}
+
+func markDataResponse(w http.ResponseWriter, source, freshness string) {
+	w.Header().Set(dataSourceHeader, source)
+	w.Header().Set(dataFreshnessHeader, freshness)
+}
+
+func markLocalResponse(w http.ResponseWriter, partial bool) {
+	w.Header().Set(dataSourceHeader, "local")
+	if partial {
+		w.Header().Set(dataFreshnessHeader, "partial")
+		return
+	}
+	w.Header().Set(dataFreshnessHeader, "local")
+}
+
+func markMixedResponse(w http.ResponseWriter, client staleResponseReporter, partial bool) {
+	w.Header().Set(dataSourceHeader, "mixed")
+	if client != nil && client.LastResponseWasStale() {
+		w.Header().Set(dataFreshnessHeader, "stale")
+	} else if partial {
+		w.Header().Set(dataFreshnessHeader, "partial")
+	} else {
+		w.Header().Set(dataFreshnessHeader, "local")
+	}
+}

internal/web/freshness_test.go

@@ -0,0 +1,86 @@
+package web
+
+import (
+	"database/sql"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/AmanTahiliani/box-box/internal/api"
+	_ "modernc.org/sqlite"
+)
+
+type fakeStaleReporter bool
+
+func (f fakeStaleReporter) LastResponseWasStale() bool { return bool(f) }
+
+func TestStaleFreshnessTakesPrecedenceOverPartialAndLimited(t *testing.T) {
+	for _, fallback := range []string{"partial", "limited"} {
+		recorder := httptest.NewRecorder()
+		markOpenF1Availability(recorder, fakeStaleReporter(true), fallback)
+		if recorder.Header().Get(dataFreshnessHeader) != "stale" {
+			t.Fatalf("fallback %q overrode stale: %q", fallback, recorder.Header().Get(dataFreshnessHeader))
+		}
+	}
+}
+
+func TestOpenF1HandlerReportsFreshThenStaleSuccess(t *testing.T) {
+	year := time.Now().Year()
+	upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_, _ = fmt.Fprintf(w, `[{"meeting_key":1,"meeting_name":"British Grand Prix","year":%d}]`, year)
+	}))
+	client := api.NewOpenF1Client(upstream.URL, time.Second)
+	t.Cleanup(func() { _ = client.Close() })
+	server := NewServer(client, 0, nil)
+	cacheKey := fmt.Sprintf("%s/v1/meetings?year=%d", upstream.URL, year)
+	requestURL := fmt.Sprintf("/api/v1/meetings?year=%d&source=openf1", year)
+	defer func() {
+		// Keep the shared application cache clean even if this test fails.
+		db, err := sql.Open("sqlite", api.DefaultCacheDBPath()+"?_busy_timeout=5000")
+		if err == nil {
+			_, _ = db.Exec(`DELETE FROM cache WHERE key = ?`, cacheKey)
+			_ = db.Close()
+		}
+	}()
+
+	fresh := httptest.NewRecorder()
+	server.handleMeetings(fresh, httptest.NewRequest(http.MethodGet, requestURL, nil))
+	if fresh.Code != http.StatusOK || fresh.Header().Get(dataSourceHeader) != "openf1" || fresh.Header().Get(dataFreshnessHeader) != "fresh" {
+		t.Fatalf("fresh response status/metadata = %d %q/%q body=%s", fresh.Code, fresh.Header().Get(dataSourceHeader), fresh.Header().Get(dataFreshnessHeader), fresh.Body.String())
+	}
+
+	db, err := sql.Open("sqlite", api.DefaultCacheDBPath()+"?_busy_timeout=5000")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := db.Exec(`UPDATE cache SET created_at = ? WHERE key = ?`, time.Now().Add(-48*time.Hour).Unix(), cacheKey); err != nil {
+		_ = db.Close()
+		t.Fatal(err)
+	}
+	_ = db.Close()
+	upstream.Close()
+
+	stale := httptest.NewRecorder()
+	server.handleMeetings(stale, httptest.NewRequest(http.MethodGet, requestURL, nil))
+	if stale.Code != http.StatusOK || stale.Header().Get(dataSourceHeader) != "openf1" || stale.Header().Get(dataFreshnessHeader) != "stale" {
+		t.Fatalf("stale response status/metadata = %d %q/%q body=%s", stale.Code, stale.Header().Get(dataSourceHeader), stale.Header().Get(dataFreshnessHeader), stale.Body.String())
+	}
+}
+
+func TestFreshnessHeadersAreExposedToBrowserClients(t *testing.T) {
+	handler := withCORS(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		markDataResponse(w, "local", "partial")
+		writeJSON(w, map[string]bool{"ok": true})
+	}))
+	recorder := httptest.NewRecorder()
+	handler.ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, "/api/v1/test", nil))
+
+	if got := recorder.Header().Get("Access-Control-Expose-Headers"); got != dataSourceHeader+", "+dataFreshnessHeader {
+		t.Fatalf("exposed headers = %q", got)
+	}
+	if recorder.Header().Get(dataSourceHeader) != "local" || recorder.Header().Get(dataFreshnessHeader) != "partial" {
+		t.Fatalf("data metadata = %q/%q", recorder.Header().Get(dataSourceHeader), recorder.Header().Get(dataFreshnessHeader))
+	}
+}

internal/web/live.go

@@ -134,7 +134,7 @@ func (h *SSEHub) applySnapshot(data live.LiveStreamData, now time.Time) liveStat
 	h.mu.Lock()
 	defer h.mu.Unlock()
 
-	if live.SessionStatusIsActive(data.SessionStatus) {
+	if snapshotIsLive(data) {
 		h.isLive = true
 		h.activeSnapshot = &data
 		if data.PositionUpdated && len(data.Positions) > 0 {
@@ -208,6 +208,40 @@ func (h *SSEHub) stateLocked() liveStatePayload {
 	return payload
 }
 
+// snapshotIsLive reports whether the current live-timing snapshot represents an
+// ongoing session that should be surfaced as live.
+//
+// An actively running session (Started/Resumed) is always live. A non-terminal
+// but temporarily inactive session — e.g. a red-flag pause where SessionStatus
+// drops to "Inactive" while the session is still in progress — is also live when
+// the snapshot itself carries live evidence: a session clock with time remaining
+// plus session metadata. This keeps the paused track state visible instead of
+// collapsing to the inactive empty state.
+//
+// Terminal sessions (Finished/Finalised/Ends/Aborted) are never live. A generic
+// inactive/no-session stale snapshot is not live either: the predicate keys off
+// the current snapshot's clock and session, so old metadata alone is not enough.
+func snapshotIsLive(data live.LiveStreamData) bool {
+	if live.SessionStatusIsActive(data.SessionStatus) {
+		return true
+	}
+	if live.SessionStatusIsTerminal(data.SessionStatus) {
+		return false
+	}
+	return clockHasTimeRemaining(data.Clock) && data.Session.SessionName != ""
+}
+
+// clockHasTimeRemaining reports whether an "HH:MM:SS" session clock has any time
+// left. Empty or all-zero clocks (a spent or absent session) return false.
+func clockHasTimeRemaining(clock string) bool {
+	for _, r := range clock {
+		if r >= '1' && r <= '9' {
+			return true
+		}
+	}
+	return false
+}
+
 func hasLiveSnapshotData(data live.LiveStreamData) bool {
 	return len(data.Drivers) > 0 ||
 		len(data.DriverInfo) > 0 ||
@@ -330,7 +364,15 @@ func cloneLivePositions(in map[string]live.LivePositionData) map[string]live.Liv
 
 // handleLiveState returns the current live data snapshot as JSON.
 func (s *Server) handleLiveState(w http.ResponseWriter, r *http.Request) {
-	writeJSON(w, s.hub.State())
+	state := s.hub.State()
+	freshness := "limited"
+	if state.IsLive {
+		freshness = "live"
+	} else if state.LastSnapshot != nil {
+		freshness = "archive"
+	}
+	markDataResponse(w, "fia", freshness)
+	writeJSON(w, state)
 }
 
 // handleSSEStream is the persistent SSE endpoint for live data.

internal/web/live_archive_test.go

@@ -51,6 +51,101 @@ func TestSSEHubArchivesTerminalSessionSnapshot(t *testing.T) {
 	}
 }
 
+func TestSnapshotIsLive(t *testing.T) {
+	redFlag := live.LiveStreamData{
+		SessionStatus: "Inactive",
+		TrackStatus:   "2",
+		Clock:         "00:03:27",
+		Session:       live.LiveSessionMeta{MeetingName: "Belgian Grand Prix", SessionName: "Practice 2", SessionType: "Practice"},
+	}
+	tests := []struct {
+		name string
+		data live.LiveStreamData
+		want bool
+	}{
+		{"started", live.LiveStreamData{SessionStatus: "Started"}, true},
+		{"resumed", live.LiveStreamData{SessionStatus: "Resumed"}, true},
+		{"red flag inactive with clock and session", redFlag, true},
+		{"terminal finished with clock", func() live.LiveStreamData {
+			d := redFlag
+			d.SessionStatus = "Finished"
+			return d
+		}(), false},
+		{"inactive spent clock", func() live.LiveStreamData {
+			d := redFlag
+			d.Clock = "00:00:00"
+			return d
+		}(), false},
+		{"inactive no clock", func() live.LiveStreamData {
+			d := redFlag
+			d.Clock = ""
+			return d
+		}(), false},
+		{"inactive no session metadata", func() live.LiveStreamData {
+			d := redFlag
+			d.Session = live.LiveSessionMeta{}
+			return d
+		}(), false},
+	}
+	for _, tt := range tests {
+		if got := snapshotIsLive(tt.data); got != tt.want {
+			t.Errorf("%s: snapshotIsLive = %v, want %v", tt.name, got, tt.want)
+		}
+	}
+}
+
+func TestSSEHubKeepsRedFlagSessionLive(t *testing.T) {
+	hub := newSSEHub()
+	now := time.Date(2026, 7, 26, 14, 0, 0, 0, time.UTC)
+
+	redFlag := live.LiveStreamData{
+		SessionStatus:   "Inactive",
+		TrackStatus:     "2",
+		Clock:           "00:03:27",
+		Session:         live.LiveSessionMeta{MeetingName: "Belgian Grand Prix", SessionName: "Practice 2", SessionType: "Practice"},
+		SnapshotUpdated: true,
+	}
+	state := hub.applySnapshot(redFlag, now)
+
+	if !state.IsLive {
+		t.Fatal("red-flag paused session should report is_live=true")
+	}
+	if state.Data == nil {
+		t.Fatal("red-flag paused session must still send the active snapshot")
+	}
+	if state.Data.TrackStatus != "2" {
+		t.Fatalf("track status = %q, want the paused state \"2\"", state.Data.TrackStatus)
+	}
+	if state.LastSnapshot != nil {
+		t.Fatalf("red-flag session should not be archived: %+v", state.LastSnapshot)
+	}
+}
+
+func TestSSEHubStaleInactiveSnapshotNotLive(t *testing.T) {
+	hub := newSSEHub()
+	now := time.Date(2026, 7, 26, 14, 0, 0, 0, time.UTC)
+
+	// Inactive snapshot with session metadata but no remaining clock: this is a
+	// stale/no-live-evidence snapshot and must not be surfaced as live.
+	stale := live.LiveStreamData{
+		SessionStatus:   "Inactive",
+		Clock:           "00:00:00",
+		Session:         live.LiveSessionMeta{MeetingName: "Belgian Grand Prix", SessionName: "Practice 2"},
+		SnapshotUpdated: true,
+	}
+	state := hub.applySnapshot(stale, now)
+
+	if state.IsLive {
+		t.Fatal("stale inactive snapshot should report is_live=false")
+	}
+	if state.Data != nil {
+		t.Fatalf("stale inactive snapshot leaked into active data: %+v", state.Data)
+	}
+	if state.LastSnapshot == nil {
+		t.Fatal("stale inactive snapshot with metadata should be archived")
+	}
+}
+
 func TestHandleLiveStateKeepsArchiveOutOfActiveData(t *testing.T) {
 	hub := newSSEHub()
 	now := time.Date(2026, 7, 4, 14, 0, 0, 0, time.UTC)

internal/web/navigation.go

@@ -9,6 +9,7 @@ import (
 )
 
 func (s *Server) handleSeasons(w http.ResponseWriter, r *http.Request) {
+	markLocalResponse(w, false)
 	if !s.hasLocalQuery() {
 		writeJSON(w, []int{})
 		return
@@ -26,6 +27,7 @@ func (s *Server) handleSeasons(w http.ResponseWriter, r *http.Request) {
 }
 
 func (s *Server) handleWeekend(w http.ResponseWriter, r *http.Request) {
+	markLocalResponse(w, false)
 	meetingKey, err := strconv.Atoi(r.URL.Query().Get("meeting_key"))
 	if err != nil || meetingKey == 0 {
 		http.Error(w, "meeting_key required", http.StatusBadRequest)
@@ -46,5 +48,6 @@ func (s *Server) handleWeekend(w http.ResponseWriter, r *http.Request) {
 		writeError(w, err, http.StatusInternalServerError, false)
 		return
 	}
+	markLocalResponse(w, weekend.Source == query.ResponseSourcePartial)
 	writeJSON(w, weekend)
 }

internal/web/racehub.go

@@ -17,6 +17,7 @@ func (s *Server) handleRaceHub(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if !s.hasLocalQuery() {
+		markDataResponse(w, "none", "limited")
 		writeJSON(w, emptyRaceHub(sessionKey))
 		return
 	}
@@ -26,6 +27,14 @@ func (s *Server) handleRaceHub(w http.ResponseWriter, r *http.Request) {
 		writeError(w, err, http.StatusInternalServerError, false)
 		return
 	}
+	switch hub.Source {
+	case query.ResponseSourceNone:
+		markDataResponse(w, "none", "limited")
+	case query.ResponseSourcePartial:
+		markLocalResponse(w, true)
+	default:
+		markLocalResponse(w, false)
+	}
 	writeJSON(w, hub)
 }
 

internal/web/racehub_test.go

@@ -86,11 +86,29 @@ func TestHandleRaceHubWithoutStore(t *testing.T) {
 	if hub.Source != query.ResponseSourceNone {
 		t.Fatalf("source = %q, want %q", hub.Source, query.ResponseSourceNone)
 	}
+	if rec.Header().Get(dataSourceHeader) != "none" || rec.Header().Get(dataFreshnessHeader) != "limited" {
+		t.Fatalf("missing hub metadata = %q/%q", rec.Header().Get(dataSourceHeader), rec.Header().Get(dataFreshnessHeader))
+	}
 	if hub.Datasets["session"].Status != query.DatasetStatusMissing {
 		t.Fatalf("session dataset = %+v, want missing", hub.Datasets["session"])
 	}
 }
 
+func TestHandleRaceHubUnknownSessionWithStoreReportsLimited(t *testing.T) {
+	st := openTestStore(t)
+	srv := testServer(t, st)
+	rec := httptest.NewRecorder()
+	srv.handleRaceHub(rec, httptest.NewRequest(http.MethodGet, "/api/v1/race-hub?session_key=999999", nil))
+
+	var hub query.RaceHub
+	if err := json.Unmarshal(rec.Body.Bytes(), &hub); err != nil {
+		t.Fatal(err)
+	}
+	if hub.Source != query.ResponseSourceNone || rec.Header().Get(dataSourceHeader) != "none" || rec.Header().Get(dataFreshnessHeader) != "limited" {
+		t.Fatalf("unknown session = source %q, metadata %q/%q", hub.Source, rec.Header().Get(dataSourceHeader), rec.Header().Get(dataFreshnessHeader))
+	}
+}
+
 func TestHandleRaceHubWithLocalData(t *testing.T) {
 	st := openTestStore(t)
 	seedRaceHubStore(t, st)
@@ -117,6 +135,12 @@ func TestHandleRaceHubWithLocalData(t *testing.T) {
 	if hub.Datasets["results"].Status != query.DatasetStatusMissing {
 		t.Fatalf("results dataset = %+v, want missing", hub.Datasets["results"])
 	}
+	if hub.Source != query.ResponseSourcePartial {
+		t.Fatalf("source = %q, want partial", hub.Source)
+	}
+	if rec.Header().Get(dataSourceHeader) != "local" || rec.Header().Get(dataFreshnessHeader) != "partial" {
+		t.Fatalf("partial hub metadata = %q/%q", rec.Header().Get(dataSourceHeader), rec.Header().Get(dataFreshnessHeader))
+	}
 }
 
 func TestHandleRaceHubIncludesChapters(t *testing.T) {

internal/web/replay.go

@@ -61,15 +61,27 @@ func (s *Server) handleReplayFrames(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	resp, err := assembleReplayFrames(r.Context(), s.client, sessionKey, intervalMS)
+	client := s.client.Scoped()
+	resp, incomplete, err := assembleReplayFrames(r.Context(), client, sessionKey, intervalMS)
 	if err != nil {
-		writeError(w, err, http.StatusInternalServerError, s.client.LastResponseWasStale())
+		writeError(w, err, http.StatusInternalServerError, client.LastResponseWasStale())
 		return
 	}
+	markOpenF1Availability(w, client, replayResponseFreshness(resp, incomplete))
 	writeJSON(w, resp)
 }
 
-func assembleReplayFrames(ctx context.Context, client replayDataClient, sessionKey, intervalMS int) (replayFramesResponse, error) {
+func replayResponseFreshness(resp replayFramesResponse, incomplete bool) string {
+	if !incomplete {
+		return "fresh"
+	}
+	if len(resp.Frames) == 0 {
+		return "limited"
+	}
+	return "partial"
+}
+
+func assembleReplayFrames(ctx context.Context, client replayDataClient, sessionKey, intervalMS int) (replayFramesResponse, bool, error) {
 	if intervalMS < defaultReplayIntervalMS {
 		intervalMS = defaultReplayIntervalMS
 	}
@@ -82,26 +94,26 @@ func assembleReplayFrames(ctx context.Context, client replayDataClient, sessionK
 
 	drivers, err := client.GetDriversForSession(sessionKey)
 	if err != nil {
-		return resp, err
+		return resp, false, err
 	}
 
 	driverNumbers := uniqueDriverNumbers(drivers)
 	if len(driverNumbers) == 0 {
-		return resp, nil
+		return resp, true, nil
 	}
 
 	series, err := fetchReplayLocationSeries(ctx, client, sessionKey, driverNumbers)
 	if err != nil && len(series) == 0 {
-		return resp, err
+		return resp, false, err
 	}
 
 	start, ok := earliestReplayLocationTime(series)
 	if !ok {
-		return resp, nil
+		return resp, true, nil
 	}
 	resp.StartTime = start.Format(time.RFC3339Nano)
 	resp.Frames = snapReplayFrames(series, start, intervalMS)
-	return resp, nil
+	return resp, err != nil || len(series) < len(driverNumbers) || len(resp.Frames) == 0, nil
 }
 
 func uniqueDriverNumbers(drivers []models.Driver) []int {

internal/web/replay_test.go

@@ -3,6 +3,7 @@ package web
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"net/http"
 	"net/http/httptest"
 	"sync"
@@ -16,6 +17,7 @@ type fakeReplayClient struct {
 	drivers []models.Driver
 	locs    map[int][]models.Location
 	err     error
+	locErrs map[int]error
 
 	mu          sync.Mutex
 	inFlight    int
@@ -46,7 +48,38 @@ func (f *fakeReplayClient) GetLocation(sessionKey, driverNumber int) ([]models.L
 	f.inFlight--
 	f.mu.Unlock()
 
-	return f.locs[driverNumber], nil
+	return f.locs[driverNumber], f.locErrs[driverNumber]
+}
+
+func TestAssembleReplayFramesReportsPartialDriverSeries(t *testing.T) {
+	start := time.Date(2025, 5, 25, 13, 0, 0, 0, time.UTC)
+	client := &fakeReplayClient{
+		drivers: []models.Driver{{DriverNumber: 1}, {DriverNumber: 4}},
+		locs: map[int][]models.Location{
+			1: {{Date: start.Format(time.RFC3339Nano), X: 1, Y: 2}},
+		},
+		locErrs: map[int]error{4: errors.New("location unavailable")},
+	}
+	resp, incomplete, err := assembleReplayFrames(context.Background(), client, 99, defaultReplayIntervalMS)
+	if err != nil {
+		t.Fatalf("partial replay should remain usable: %v", err)
+	}
+	if !incomplete || len(resp.Frames) != 1 {
+		t.Fatalf("partial replay = incomplete %v, frames %+v", incomplete, resp.Frames)
+	}
+	if got := replayResponseFreshness(resp, incomplete); got != "partial" {
+		t.Fatalf("partial replay freshness = %q", got)
+	}
+}
+
+func TestAssembleReplayFramesEmptyDriverSetIsLimited(t *testing.T) {
+	resp, incomplete, err := assembleReplayFrames(context.Background(), &fakeReplayClient{}, 99, defaultReplayIntervalMS)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !incomplete || replayResponseFreshness(resp, incomplete) != "limited" {
+		t.Fatalf("empty replay = incomplete %v, freshness %q", incomplete, replayResponseFreshness(resp, incomplete))
+	}
 }
 
 func TestAssembleReplayFramesSnapsNearestSamplesAndOmitsEmptyDrivers(t *testing.T) {
@@ -70,10 +103,16 @@ func TestAssembleReplayFramesSnapsNearestSamplesAndOmitsEmptyDrivers(t *testing.
 		},
 	}
 
-	resp, err := assembleReplayFrames(context.Background(), client, 99, 5000)
+	resp, incomplete, err := assembleReplayFrames(context.Background(), client, 99, 5000)
 	if err != nil {
 		t.Fatalf("assembleReplayFrames() error = %v", err)
 	}
+	if !incomplete {
+		t.Fatal("empty entrant location series was labelled complete")
+	}
+	if got := replayResponseFreshness(resp, incomplete); got != "partial" {
+		t.Fatalf("empty entrant freshness = %q", got)
+	}
 	if resp.SessionKey != 99 || resp.Interval != 5000 {
 		t.Fatalf("response metadata = %+v", resp)
 	}
@@ -112,7 +151,7 @@ func TestAssembleReplayFramesCapsFrameCount(t *testing.T) {
 		locs:    map[int][]models.Location{1: locs},
 	}
 
-	resp, err := assembleReplayFrames(context.Background(), client, 99, defaultReplayIntervalMS)
+	resp, _, err := assembleReplayFrames(context.Background(), client, 99, defaultReplayIntervalMS)
 	if err != nil {
 		t.Fatalf("assembleReplayFrames() error = %v", err)
 	}
@@ -139,7 +178,7 @@ func TestAssembleReplayFramesBoundsLocationFanOut(t *testing.T) {
 		delay:   5 * time.Millisecond,
 	}
 
-	if _, err := assembleReplayFrames(context.Background(), client, 99, defaultReplayIntervalMS); err != nil {
+	if _, _, err := assembleReplayFrames(context.Background(), client, 99, defaultReplayIntervalMS); err != nil {
 		t.Fatalf("assembleReplayFrames() error = %v", err)
 	}
 	if client.maxInFlight > replayFetchConcurrency {
@@ -167,7 +206,7 @@ func TestHandleReplayFramesValidatesParamsAndFloorsInterval(t *testing.T) {
 	client := &fakeReplayClient{drivers: []models.Driver{{DriverNumber: 1}}, locs: map[int][]models.Location{
 		1: {{Date: time.Date(2025, 5, 25, 13, 0, 0, 0, time.UTC).Format(time.RFC3339Nano), X: 1, Y: 2}},
 	}}
-	resp, err := assembleReplayFrames(context.Background(), client, 99, 1000)
+	resp, _, err := assembleReplayFrames(context.Background(), client, 99, 1000)
 	if err != nil {
 		t.Fatalf("assembleReplayFrames() error = %v", err)
 	}

internal/web/server.go

@@ -159,6 +159,7 @@ func withCORS(next http.Handler) http.Handler {
 		w.Header().Set("Access-Control-Allow-Origin", "*")
 		w.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS")
 		w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
+		w.Header().Set("Access-Control-Expose-Headers", dataSourceHeader+", "+dataFreshnessHeader)
 		if r.Method == http.MethodOptions {
 			w.WriteHeader(http.StatusNoContent)
 			return

tests/command-center.spec.ts

@@ -0,0 +1,77 @@
+import { test, expect } from '@playwright/test'
+
+const FULL_SESSION = 9472
+
+test.describe('Command Center', () => {
+  test('loads as default route with weekend identity band', async ({ page }) => {
+    await page.goto('/')
+
+    await expect(page.getByTestId('command-center')).toBeVisible()
+    await expect(page.getByTestId('cc-focus')).toBeVisible()
+    await expect(page.getByTestId('cc-session-9472')).toBeVisible()
+    await expect(page.getByTestId('hero-last-race-link')).toBeVisible()
+  })
+
+  test('nav link reaches command center from race hub', async ({ page }) => {
+    await page.goto(`/race-hub?session_key=${FULL_SESSION}`)
+    await page.getByRole('link', { name: 'Command' }).click()
+    await expect(page).toHaveURL('/')
+    await expect(page.getByTestId('command-center')).toBeVisible()
+  })
+
+  test('open analysis action opens race hub for the focus session', async ({ page }) => {
+    await page.goto('/')
+    await expect(page.getByTestId('hero-last-race-link')).toBeVisible()
+    await page.getByTestId('hero-last-race-link').click()
+    await expect(page).toHaveURL(new RegExp(`/race-hub\\?session_key=${FULL_SESSION}`))
+    await expect(page.getByTestId('rh-identity')).toBeVisible()
+    await expect(page.getByTestId(`rh-session-${FULL_SESSION}`)).toBeVisible()
+  })
+
+  test('archived live snapshot does not mark command center live', async ({ page }) => {
+    await page.route('**/api/v1/live/state', (route) =>
+      route.fulfill({
+        contentType: 'application/json',
+        body: JSON.stringify({
+          is_live: false,
+          data: null,
+          last_snapshot: {
+            Drivers: { '1': { RacingNumber: '1', Position: 1 } },
+            DriverInfo: { '1': { RacingNumber: '1', Tla: 'VER', TeamColour: '3671C6' } },
+            Tyres: {},
+            RCMessages: [],
+            Weather: {},
+            Session: { MeetingName: 'Archived GP', SessionName: 'Race', SessionType: 'Race' },
+            TeamRadio: [],
+            SessionStatus: 'Finished',
+            TrackStatus: '1',
+            CurrentLap: 57,
+            TotalLaps: 57,
+            Clock: '',
+            ClockRefTime: '',
+            ClockExtrapolating: false,
+            Stints: {},
+          },
+          last_snapshot_at: '2026-07-04T14:00:00Z',
+        }),
+      }),
+    )
+
+    await page.goto('/')
+    await expect(page.getByTestId('command-center')).toBeVisible()
+    await expect(page.getByTestId('cc-live-status')).toContainText('No live session')
+    await expect(page.getByTestId('cc-live-status')).not.toContainText('Live session active')
+  })
+
+  test('existing routes continue to work', async ({ page }) => {
+    await page.goto(`/race-hub?session_key=${FULL_SESSION}`)
+    await expect(page.getByTestId('race-hub')).toBeVisible()
+    await expect(page.getByTestId('rh-overview')).toBeVisible()
+
+    await page.goto('/admin')
+    await expect(page.getByTestId('data-library')).toBeVisible()
+
+    await page.goto('/live')
+    await expect(page.getByTestId('live-empty')).toBeVisible()
+  })
+})

tests/live-timing.spec.ts

@@ -147,6 +147,58 @@ const sprintQualifyingSnapshot = {
   },
 }
 
+// Practice: the feed sets best laps but no GapToLeader/Interval, and there is
+// no race lap-total concept. Exercises computed gaps, the non-race banner, the
+// collapsed-by-default tyre panel, and the 390px core-field layout.
+const practiceSnapshot = {
+  is_live: true,
+  data: {
+    ...raceSnapshot.data,
+    Drivers: Object.fromEntries(
+      Array.from({ length: 10 }, (_, index) => {
+        const num = String(index + 1)
+        return [
+          num,
+          driver(num, index + 1, '', '', {
+            // Distinct, increasing best laps; P1 fastest, +0.200s per position.
+            BestLapTime: `1:${(45.9 + index * 0.2).toFixed(3).padStart(6, '0')}`,
+            LastLapTime: '1:46.500',
+            NumberOfLaps: 12,
+            Sectors: index === 0
+              ? [
+                  { Value: '28.500', PersonalFastest: true, OverallFastest: false },
+                  { Value: '52.100', PersonalFastest: false, OverallFastest: false },
+                  { Value: '25.344', PersonalFastest: false, OverallFastest: false },
+                ]
+              : [],
+          }),
+        ]
+      }),
+    ),
+    DriverInfo: Object.fromEntries(
+      Array.from({ length: 10 }, (_, index) => {
+        const num = String(index + 1)
+        return [num, info(num, `D${index + 1}`, 'Driver', String(index + 1), 'Test Team', index % 2 ? 'FF8000' : '27F4D2')]
+      }),
+    ),
+    Tyres: Object.fromEntries(
+      Array.from({ length: 10 }, (_, index) => [String(index + 1), { Compound: 'SOFT', New: false, Age: index % 4 }]),
+    ),
+    Session: {
+      MeetingName: 'Belgian Grand Prix',
+      CircuitName: 'Spa-Francorchamps',
+      SessionType: 'Practice',
+      SessionName: 'Practice 2',
+    },
+    TrackStatus: '1',
+    CurrentLap: 0,
+    TotalLaps: 0,
+    Clock: '00:45:00',
+    ClockRefTime: '2026-07-17T13:00:00Z',
+    ClockExtrapolating: false,
+  },
+}
+
 test.describe('Live Timing (mocked snapshot)', () => {
   test.beforeEach(async ({ page }) => {
     await page.route('**/api/v1/live/state', (route) =>
@@ -233,6 +285,94 @@ test.describe('Live Timing (mocked Sprint Qualifying)', () => {
   })
 })
 
+test.describe('Live Timing (mocked Practice)', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.route('**/api/v1/live/state', (route) =>
+      route.fulfill({ contentType: 'application/json', body: JSON.stringify(practiceSnapshot) }),
+    )
+    await page.route('**/api/v1/live/stream', (route) =>
+      route.fulfill({ contentType: 'text/event-stream', body: 'event: heartbeat\ndata: {}\n\n' }),
+    )
+    await page.goto('/live')
+  })
+
+  test('derives a gap to P1 from best laps and marks the leader', async ({ page }) => {
+    const tower = page.locator('.live-tower')
+    await expect(tower).toBeVisible()
+    // P1 shows a leader marker, not a fabricated gap.
+    await expect(tower.locator('tbody tr').first()).toContainText('—')
+    // P2 shows the computed +0.200 delta.
+    await expect(tower).toContainText('+0.200')
+  })
+
+  test('omits the race lap counter and keeps the session clock for practice', async ({ page }) => {
+    await expect(page.getByTestId('live-lap-counter')).toHaveCount(0)
+    await expect(page.getByTestId('live-clock')).toContainText('00:45:00')
+    await expect(page.locator('.live-banner')).not.toContainText('L-/-')
+  })
+
+  test('collapses the tyre panel by default so the tower is above the fold', async ({ page }) => {
+    await expect(page.getByTestId('tyredeg-panel')).toBeVisible()
+    await expect(page.getByTestId('tyredeg-row')).toHaveCount(0)
+    await expect(page.locator('.live-tower')).toBeVisible()
+  })
+
+  test('labels Race Control times as UTC', async ({ page }) => {
+    await expect(page.getByTestId('rc-timezone')).toContainText('UTC')
+  })
+
+  test('marks Live as active in the primary navigation', async ({ page }) => {
+    await expect(page.getByTestId('nav-live')).toHaveAttribute('data-live-active', 'true')
+    await expect(page.getByTestId('nav-live').locator('.nav-live-dot')).toBeVisible()
+  })
+})
+
+test.describe('Live Timing (390px practice viewport)', () => {
+  test.use({ viewport: { width: 390, height: 844 } })
+
+  test.beforeEach(async ({ page }) => {
+    await page.route('**/api/v1/live/state', (route) =>
+      route.fulfill({ contentType: 'application/json', body: JSON.stringify(practiceSnapshot) }),
+    )
+    await page.route('**/api/v1/live/stream', (route) =>
+      route.fulfill({ contentType: 'text/event-stream', body: 'event: heartbeat\ndata: {}\n\n' }),
+    )
+    await page.goto('/live')
+  })
+
+  test('shows the five core fields with no horizontal overflow', async ({ page }) => {
+    const tower = page.locator('.live-tower')
+    await expect(tower).toBeVisible()
+
+    // Core comparison fields are present in the header.
+    await expect(tower.locator('thead')).toContainText('Pos')
+    await expect(tower.locator('thead')).toContainText('Driver')
+    await expect(tower.locator('thead')).toContainText('Tyre')
+    await expect(tower.locator('thead')).toContainText('Best')
+    await expect(tower.locator('thead')).toContainText('Gap to P1')
+
+    // Sectors are hidden from the initial mobile tower (reachable via expand).
+    const firstSector = tower.locator('thead th', { hasText: 'S1' })
+    await expect(firstSector).toBeHidden()
+
+    // The document must not scroll horizontally.
+    const overflow = await page.evaluate(
+      () => document.documentElement.scrollWidth - document.documentElement.clientWidth,
+    )
+    expect(overflow).toBeLessThanOrEqual(0)
+  })
+
+  test('exposes sectors through the row detail interaction', async ({ page }) => {
+    // Sector columns are not in the initial mobile tower...
+    await expect(page.locator('.live-tower thead th', { hasText: 'S1' })).toBeHidden()
+    // ...but the P1 row's sectors are reachable by expanding the row.
+    await page.locator('.live-tower tbody tr', { hasText: 'D1' }).first().click()
+    const sectors = page.getByTestId('expanded-sectors')
+    await expect(sectors).toBeVisible()
+    await expect(sectors).toContainText('28.500')
+  })
+})
+
 test.describe('Live Timing (no session)', () => {
   test('shows the empty state when the feed has no snapshot', async ({ page }) => {
     await page.goto('/live')

tests/production-smoke.spec.ts

@@ -3,11 +3,11 @@ import { test, expect } from '@playwright/test'
 const FULL_SESSION = 9472
 
 test.describe('Production serving (Go + built React)', () => {
-  test('serves the Weekend home as default route', async ({ page }) => {
+  test('serves command center as default route', async ({ page }) => {
     await page.goto('/')
 
-    await expect(page.getByTestId('weekend-page')).toBeVisible()
+    await expect(page.getByTestId('command-center')).toBeVisible()
-    await expect(page.getByTestId('weekend-between-races')).toBeVisible()
+    await expect(page.getByTestId('cc-session-9472')).toBeVisible()
   })
 
   test('serves race hub workspace from built assets', async ({ page }) => {
@@ -44,21 +44,16 @@ test.describe('Production serving (Go + built React)', () => {
     await expect(page.getByText('No live session active')).toBeVisible()
   })
 
-  test('primary nav links and Admin utility work from built SPA', async ({ page }) => {
+  test('nav links work from built SPA', async ({ page }) => {
     await page.goto('/')
-    const primary = page.getByRole('navigation', { name: 'Primary' }).first()
+    await page.locator('.app-nav').getByRole('link', { name: 'Race Hub' }).click()
+    await expect(page).toHaveURL(/\/race-hub/)
 
-    await primary.getByRole('link', { name: 'Championship', exact: true }).click()
+    await page.locator('.app-nav').getByRole('link', { name: 'Admin', exact: true }).click()
-    await expect(page).toHaveURL(/\/championship/)
-
-    await primary.getByRole('link', { name: 'Explore', exact: true }).click()
-    await expect(page).toHaveURL(/\/explore/)
-
-    await primary.getByRole('link', { name: 'Weekend', exact: true }).click()
-    await expect(page).toHaveURL('/')
-
-    // Admin is an operator utility outside the Primary landmark.
-    await page.getByRole('toolbar', { name: 'Operator utilities' }).getByRole('link', { name: 'Admin' }).click()
     await expect(page).toHaveURL(/\/admin/)
+
+    await page.getByRole('link', { name: 'Live', exact: true }).click()
+    await expect(page).toHaveURL(/\/live/)
+    await expect(page.getByTestId('live-empty')).toBeVisible()
   })
 })

tests/visual/helpers.ts

@@ -14,13 +14,16 @@ export async function waitForScreenshotReady(page: Page): Promise<void> {
   await page.waitForTimeout(150)
 }
 
-export async function gotoWeekendReady(page: Page): Promise<void> {
+export async function gotoCommandCenterReady(page: Page): Promise<void> {
   await page.goto('/')
-  await expect(page.getByTestId('weekend-page')).toBeVisible()
+  await expect(page.getByTestId('command-center')).toBeVisible()
-  // The seeded hermetic DB (Monaco 2025, completed) resolves to season_complete,
+  await expect(page.getByTestId('cc-focus')).toBeVisible()
-  // rendered by the between-races surface.
+  await expect(page.getByTestId('cc-session-9472')).toBeVisible()
-  await expect(page.getByTestId('weekend-between-races')).toBeVisible()
+  // The e2e stack runs with an unreachable OpenF1 base URL, so wait for the
-  await expect(page.getByTestId('wk-last-event')).toBeVisible()
+  // season-calendar query to settle on its local fallback before screenshotting.
+  await expect(
+    page.getByText('Using local meetings because the full calendar could not load.'),
+  ).toBeVisible()
   await waitForScreenshotReady(page)
 }
 

tests/visual/mvp-screens.spec.ts

@@ -1,6 +1,6 @@
 import { test } from '@playwright/test'
 import {
-  gotoWeekendReady,
+  gotoCommandCenterReady,
   gotoDataLibraryReady,
   gotoLiveEmptyReady,
   gotoRaceHubReady,
@@ -8,9 +8,9 @@ import {
 } from './helpers'
 
 test.describe('MVP visual regression', () => {
-  test('weekend', async ({ page }) => {
+  test('command-center', async ({ page }) => {
-    await gotoWeekendReady(page)
+    await gotoCommandCenterReady(page)
-    await screenshotPage(page, 'weekend')
+    await screenshotPage(page, 'command-center')
   })
 
   test('race-hub', async ({ page }) => {

tests/weekend-states.spec.ts

@@ -1,156 +0,0 @@
-import { test, expect, type Page } from '@playwright/test'
-
-// These journeys inject the canonical /api/v1/weekend-context payload directly so
-// each temporal state is exercised deterministically and hermetically, regardless
-// of the seeded database clock. The payloads mirror internal/query.WeekendContext.
-
-const availability = {
-  schedule: 'available',
-  live_transport: 'unknown',
-  live_session: 'inactive',
-  archive: 'unavailable',
-  local_analysis: 'complete',
-  freshness: 'fresh',
-  limitations: [],
-}
-
-function meeting(key: number, name: string, start: string) {
-  return {
-    meeting_key: key,
-    meeting_name: name,
-    meeting_official_name: name,
-    location: name,
-    country_code: 'GBR',
-    country_name: 'United Kingdom',
-    country_flag: '',
-    circuit_key: key,
-    circuit_short_name: name,
-    date_start: start,
-    date_end: start,
-    year: 2026,
-  }
-}
-
-function ctxSession(key: number, name: string, start: string, meetingKey: number) {
-  return {
-    session: {
-      session_key: key,
-      session_name: name,
-      session_type: name,
-      meeting_key: meetingKey,
-      date_start: start,
-      date_end: start,
-      gmt_offset: '',
-    },
-    meeting: meeting(meetingKey, 'British Grand Prix', start),
-    availability,
-  }
-}
-
-async function stubContext(page: Page, body: Record<string, unknown>): Promise<void> {
-  await page.route('**/api/v1/weekend-context', (route) =>
-    route.fulfill({ contentType: 'application/json', body: JSON.stringify(body) }),
-  )
-  // Keep supplementary reads hermetic and empty.
-  await page.route('**/api/v1/news**', (route) =>
-    route.fulfill({ contentType: 'application/json', body: '[]' }),
-  )
-}
-
-test.describe('Weekend canonical temporal states (injected)', () => {
-  test('between_weekends pairs the last completed event with the next-event countdown and Prepare CTA', async ({ page }) => {
-    await stubContext(page, {
-      season: 2026,
-      temporal_state: 'between_weekends',
-      previous_meeting: meeting(1, 'British Grand Prix', '2026-07-05T14:00:00Z'),
-      previous_completed_session: ctxSession(11, 'Race', '2026-07-05T14:00:00Z', 1),
-      default_analysis_session: ctxSession(11, 'Race', '2026-07-05T14:00:00Z', 1),
-      next_meeting: meeting(2, 'Hungarian Grand Prix', '2026-07-24T09:00:00Z'),
-      next_session: ctxSession(21, 'Practice 1', '2026-07-24T09:00:00Z', 2),
-      focus_meeting: meeting(2, 'Hungarian Grand Prix', '2026-07-24T09:00:00Z'),
-      championship_round: 12,
-      total_championship_rounds: 24,
-    })
-
-    await page.goto('/')
-    await expect(page.getByTestId('weekend-between-races')).toBeVisible()
-    await expect(page.getByTestId('wk-last-event')).toBeVisible()
-    await expect(page.getByTestId('wk-next-event')).toBeVisible()
-    await expect(page.getByTestId('wk-prepare')).toHaveAttribute('href', '/preview')
-    await expect(page.getByTestId('wk-season-nav')).toContainText('Round 12 of 24')
-  })
-
-  test('between_races Prepare CTA folds into the preparation surface instead of looping', async ({ page }) => {
-    await stubContext(page, {
-      season: 2026,
-      temporal_state: 'between_weekends',
-      next_meeting: meeting(2, 'Hungarian Grand Prix', '2026-07-24T09:00:00Z'),
-      next_session: ctxSession(21, 'Practice 1', '2026-07-24T09:00:00Z', 2),
-      championship_round: 12,
-      total_championship_rounds: 24,
-    })
-
-    await page.goto('/')
-    await page.getByTestId('wk-prepare').click()
-    await expect(page).toHaveURL(/\/preview$/)
-    await expect(page.getByTestId('weekend-pre-session')).toBeVisible()
-    await expect(page.getByTestId('weekend-between-races')).toHaveCount(0)
-  })
-
-  test('pre_session surfaces the preview and the next-session countdown', async ({ page }) => {
-    await stubContext(page, {
-      season: 2026,
-      temporal_state: 'pre_session',
-      next_meeting: meeting(2, 'Hungarian Grand Prix', '2026-07-24T09:00:00Z'),
-      next_session: ctxSession(21, 'Practice 1', '2026-07-24T09:00:00Z', 2),
-      focus_meeting: meeting(2, 'Hungarian Grand Prix', '2026-07-24T09:00:00Z'),
-      championship_round: 12,
-      total_championship_rounds: 24,
-    })
-
-    await page.goto('/')
-    await expect(page.getByTestId('weekend-pre-session')).toBeVisible()
-    await expect(page.getByTestId('wk-pre-head')).toBeVisible()
-  })
-
-  test('between_sessions shows the last result recap and the next-session countdown together', async ({ page }) => {
-    await stubContext(page, {
-      season: 2026,
-      temporal_state: 'between_sessions',
-      focus_meeting: meeting(1, 'British Grand Prix', '2026-07-04T10:00:00Z'),
-      previous_completed_session: ctxSession(11, 'Sprint', '2026-07-04T10:00:00Z', 1),
-      default_analysis_session: ctxSession(11, 'Sprint', '2026-07-04T10:00:00Z', 1),
-      next_session: ctxSession(12, 'Race', '2026-07-05T14:00:00Z', 1),
-      championship_round: 12,
-      total_championship_rounds: 24,
-    })
-
-    await page.goto('/')
-    await expect(page.getByTestId('weekend-between-sessions')).toBeVisible()
-    await expect(page.getByTestId('wk-last-session')).toBeVisible()
-    await expect(page.getByTestId('wk-next-session')).toBeVisible()
-  })
-
-  test('session_live hands off to live timing', async ({ page }) => {
-    await stubContext(page, {
-      season: 2026,
-      temporal_state: 'session_live',
-      focus_meeting: meeting(1, 'British Grand Prix', '2026-07-05T14:00:00Z'),
-      active_session: ctxSession(11, 'Race', '2026-07-05T14:00:00Z', 1),
-      championship_round: 12,
-      total_championship_rounds: 24,
-    })
-
-    await page.goto('/')
-    await expect(page.getByTestId('weekend-live')).toBeVisible()
-    await expect(page.getByTestId('wk-watch-live')).toHaveAttribute('href', '/live')
-  })
-
-  test('an error from the canonical endpoint shows an explicit error surface', async ({ page }) => {
-    await page.route('**/api/v1/weekend-context', (route) =>
-      route.fulfill({ status: 500, contentType: 'application/json', body: '{"error":"boom"}' }),
-    )
-    await page.goto('/')
-    await expect(page.getByTestId('weekend-error')).toBeVisible()
-  })
-})

tests/weekend.spec.ts

@@ -1,118 +0,0 @@
-import { test, expect, type Page } from '@playwright/test'
-
-const FULL_SESSION = 9472
-
-async function documentOverflow(page: Page): Promise<number> {
-  return page.evaluate(() => {
-    const doc = document.documentElement
-    return doc.scrollWidth - doc.clientWidth
-  })
-}
-
-test.describe('Weekend home (seeded canonical context)', () => {
-  test('renders the Weekend home from the canonical endpoint, not the limited fallback', async ({ page }) => {
-    await page.goto('/')
-
-    await expect(page.getByTestId('weekend-page')).toBeVisible()
-    // The seeded DB (Monaco 2025, completed) resolves to season_complete, driven
-    // by the canonical /api/v1/weekend-context endpoint.
-    await expect(page.getByTestId('weekend-page')).toHaveAttribute('data-temporal-state', 'season_complete')
-    await expect(page.getByTestId('weekend-between-races')).toBeVisible()
-    await expect(page.getByTestId('weekend-limited')).toHaveCount(0)
-    // No ingest/dataset terminology on the Weekend surface.
-    await expect(page.getByText(/ingest/i)).toHaveCount(0)
-  })
-
-  test('the completed-event CTA opens the canonical analysis session in Race Hub', async ({ page }) => {
-    await page.goto('/')
-    await expect(page.getByTestId('wk-last-event')).toBeVisible()
-    await page.getByTestId('wk-explore-race-story').click()
-    await expect(page).toHaveURL(/\/race-hub\?session_key=\d+/)
-    await expect(page.getByTestId('race-hub')).toBeVisible()
-  })
-
-  test('/preview alias resolves without looping back to the same screen', async ({ page }) => {
-    await page.goto('/preview')
-    // In the seeded season-complete state there is no next event, so /preview
-    // resolves to the Weekend home rather than a redirect loop.
-    await expect(page.getByTestId('weekend-page')).toBeVisible()
-    await expect(page).toHaveURL(/\/preview$/)
-  })
-
-  test('existing deep-link routes remain valid', async ({ page }) => {
-    await page.goto(`/race-hub?session_key=${FULL_SESSION}`)
-    await expect(page.getByTestId('race-hub')).toBeVisible()
-    await expect(page.getByTestId('rh-overview')).toBeVisible()
-
-    await page.goto('/admin')
-    await expect(page.getByTestId('data-library')).toBeVisible()
-
-    await page.goto('/live')
-    await expect(page.getByTestId('live-empty')).toBeVisible()
-
-    await page.goto('/explore')
-    await expect(page.getByTestId('explore-page')).toBeVisible()
-  })
-})
-
-test.describe('Weekend navigation hierarchy', () => {
-  test('all four destinations are reachable from primary navigation', async ({ page }) => {
-    await page.goto('/')
-    const primary = page.getByRole('navigation', { name: 'Primary' }).first()
-    for (const [label, url] of [
-      ['Championship', /\/championship/],
-      ['Briefing', /\/briefing/],
-      ['Explore', /\/explore/],
-      ['Weekend', /\/$/],
-    ] as const) {
-      await primary.getByRole('link', { name: label, exact: true }).click()
-      await expect(page).toHaveURL(url)
-    }
-  })
-
-  test('Admin is an operator utility outside the Primary landmark', async ({ page }) => {
-    await page.goto('/')
-    const primaries = page.getByRole('navigation', { name: 'Primary' })
-    await expect(primaries.first()).toBeVisible()
-    // Admin must not appear inside any Primary landmark.
-    await expect(primaries.getByRole('link', { name: /Admin/i })).toHaveCount(0)
-    await expect(
-      page.getByRole('toolbar', { name: 'Operator utilities' }).getByRole('link', { name: 'Admin' }),
-    ).toBeVisible()
-  })
-})
-
-test.describe('Weekend responsive — no global horizontal overflow', () => {
-  for (const { name, width, height } of [
-    { name: 'mobile 390', width: 390, height: 844 },
-    { name: 'tablet 768', width: 768, height: 1024 },
-    { name: 'desktop 1440', width: 1440, height: 900 },
-  ]) {
-    test(`no document overflow at ${name}`, async ({ page }) => {
-      await page.setViewportSize({ width, height })
-      await page.goto('/')
-      await expect(page.getByTestId('weekend-between-races')).toBeVisible()
-      expect(await documentOverflow(page)).toBeLessThanOrEqual(1)
-    })
-  }
-
-  test('mobile shows exactly one visible primary navigation (bottom bar)', async ({ page }) => {
-    await page.setViewportSize({ width: 390, height: 844 })
-    await page.goto('/')
-    await expect(page.getByTestId('weekend-page')).toBeVisible()
-
-    // The bottom bar is the single visible primary nav; the top bar's links are
-    // hidden by CSS at this breakpoint.
-    const bottom = page.locator('.app-bottom-nav')
-    await expect(bottom).toBeVisible()
-    await expect(bottom.getByRole('link')).toHaveCount(4)
-
-    const topLinks = page.locator('.app-nav .nav-links')
-    await expect(topLinks).toBeHidden()
-
-    // All four destinations remain reachable via the bottom bar.
-    for (const label of ['Weekend', 'Championship', 'Briefing', 'Explore']) {
-      await expect(bottom.getByRole('link', { name: new RegExp(label) })).toBeVisible()
-    }
-  })
-})