feat(frontend): calendar-aware paddock briefing digest (#26 )

Reframe Briefing into GP-window sections with driver/team tag chips, a sticky "since last race" header, and client-side digest helpers (gpWindows, groupByWindow, tagItems). Overlapping inter-race windows resolve to the latest GP; undated items land in a Recent bucket. Vitest covers digest lib + page render/filter behaviour. Co-authored-by: Cursor <cursoragent@cursor.com>
fix(agents): quote skill YAML descriptions — strict parsers (cursor CLI) fail on embedded quotes/colons
2026-08-08 12:07:23 -04:00 · 2026-07-11 18:14:55 -04:00 · 2026-07-11 18:10:34 -04:00
23 changed files with 1289 additions and 1306 deletions
--- a/.agents/skills/groom/SKILL.md
+++ b/.agents/skills/groom/SKILL.md
@@ -1,6 +1,6 @@
 ---
 name: groom
-description: Groom a box-box GitHub issue into a Ready spec via a seeded grill-me interrogation. Use when the user asks to groom an issue, for example "/groom <issue-number>" or "$groom <issue-number>" with optional "--lens architect". Single-issue path: asks targeted questions, writes a structured spec into the issue body, sets Effort/Priority, and leaves Stage at Research for approval.
+description: 'Groom a box-box GitHub issue into a Ready spec via a seeded grill-me interrogation. Use when the user asks to groom an issue, for example "/groom <issue-number>" or "$groom <issue-number>" with optional "--lens architect". Single-issue path: asks targeted questions, writes a structured spec into the issue body, sets Effort/Priority, and leaves Stage at Research for approval.'
 argument-hint: <issue-number> [--lens architect]
 ---

--- a/.agents/skills/implement/SKILL.md
+++ b/.agents/skills/implement/SKILL.md
@@ -1,6 +1,6 @@
 ---
 name: implement
-description: Dispatch a Ready box-box issue to a coding harness (claude/codex/opencode/pi/cursor) in an isolated git worktree, run the build gate, and open a PR. Use when supervising implementation via "/implement <issue-number> --harness <name> [--dry-run]" or from any harness terminal with .agents/bin/dev.
+description: 'Dispatch a Ready box-box issue to a coding harness (claude/codex/opencode/pi/cursor) in an isolated git worktree, run the build gate, and open a PR. Use when supervising implementation via "/implement <issue-number> --harness <name> [--dry-run]" or from any harness terminal with .agents/bin/dev.'
 argument-hint: <issue-number> --harness <claude|codex|opencode|pi|cursor> [--dry-run]
 ---

--- a/.agents/skills/lens-architect/SKILL.md
+++ b/.agents/skills/lens-architect/SKILL.md
@@ -1,6 +1,6 @@
 ---
 name: lens-architect
-description: Grill/analyze a box-box issue or epic from a software-architecture perspective and post the findings as a comment. Use standalone as "/lens-architect <issue-number>" for an on-the-fly architecture review, or let /groom compose it via "--lens architect". Reads the base grill + architect persona and focuses on reuse, data flow, seams, testability, and risk.
+description: 'Grill/analyze a box-box issue or epic from a software-architecture perspective and post the findings as a comment. Use standalone as "/lens-architect <issue-number>" for an on-the-fly architecture review, or let /groom compose it via "--lens architect". Reads the base grill + architect persona and focuses on reuse, data flow, seams, testability, and risk.'
 argument-hint: <issue-number>
 ---

--- a/.agents/skills/review/SKILL.md
+++ b/.agents/skills/review/SKILL.md
@@ -1,6 +1,6 @@
 ---
 name: review
-description: Locally review a box-box PR against its linked GitHub issue spec, run tests, capture visual screenshots when applicable, create a .review packet, and post a GitHub PR comment. Use when a ticket implementation is ready for independent local review before the human merge gate.
+description: 'Locally review a box-box PR against its linked GitHub issue spec, run tests, capture visual screenshots when applicable, create a .review packet, and post a GitHub PR comment. Use when a ticket implementation is ready for independent local review before the human merge gate.'
 argument-hint: <pr-number> [--harness <name>] [--publish-screenshots]
 ---

--- a/.agents/skills/write-spec/SKILL.md
+++ b/.agents/skills/write-spec/SKILL.md
@@ -1,6 +1,6 @@
 ---
 name: write-spec
-description: Render a groomed design into the box-box Ready-spec template and write it into a GitHub issue body, then set Effort and Priority. Called by /groom after a grill session, or run standalone as "/write-spec <issue-number>" to (re)write an issue's spec from agreed decisions. Does not change Stage.
+description: 'Render a groomed design into the box-box Ready-spec template and write it into a GitHub issue body, then set Effort and Priority. Called by /groom after a grill session, or run standalone as "/write-spec <issue-number>" to (re)write an issue''s spec from agreed decisions. Does not change Stage.'
 argument-hint: <issue-number>
 ---

--- a/frontend/src/api.ts
+++ b/frontend/src/api.ts
@@ -10,7 +10,6 @@ import type {
  Meeting,
  NewsItem,
  RaceHub,
-  ReplayFramesResponse,
  Session,
  TrackOutline,
  Weekend,
@@ -81,21 +80,6 @@ export async function fetchTrackOutline(circuitKey: number, year: number): Promi
  return data as TrackOutline
 }

-export async function fetchReplayFrames(
-  sessionKey: number,
-  intervalMs = 5000,
-): Promise<ReplayFramesResponse> {
-  const params = new URLSearchParams({
-    session_key: String(sessionKey),
-    interval_ms: String(intervalMs),
-  })
-  const res = await fetch(`/api/v1/replay/frames?${params}`)
-  if (!res.ok) {
-    throw new Error(`API ${res.status}: ${res.statusText}`)
-  }
-  return res.json()
-}
-
 export async function fetchSessions(meetingKey: number, source = 'openf1'): Promise<Session[]> {
  const res = await fetch(`/api/v1/sessions?meeting_key=${meetingKey}&source=${source}`)
  if (!res.ok) {
--- a/frontend/src/components/PaddockBriefing.tsx
+++ b/frontend/src/components/PaddockBriefing.tsx
@@ -1,7 +1,23 @@
+import { useMemo } from 'react'
 import { useQuery } from '@tanstack/react-query'
 import { Link } from '@tanstack/react-router'
-import { fetchNews } from '../api'
+import {
+  fetchChampionshipHub,
+  fetchNews,
+  fetchSeasonMeetings,
+  fetchSeasons,
+} from '../api'
+import {
+  activeDigestWindow,
+  gpWindows,
+  itemsForWindow,
+  sinceLastLabel,
+  tagColour,
+  tagItems,
+  topTags,
+} from '../lib/digest'
 import { timeAgo } from '../utils'
+import '../styles/digest.css'

 const SOURCE_DISPLAY: Record<string, string> = {
  'fia': 'FIA',
@@ -14,14 +30,53 @@ const SOURCE_DISPLAY: Record<string, string> = {
 }

 export function PaddockBriefing() {
+  const now = useMemo(() => new Date(), [])
+
  const { data: news, isLoading, isError } = useQuery({
    queryKey: ['news'],
    queryFn: () => fetchNews(100),
    staleTime: 60_000,
  })

+  const seasonsQuery = useQuery({
+    queryKey: ['seasons'],
+    queryFn: fetchSeasons,
+  })
+  const latestSeason = seasonsQuery.data?.[0] ?? null
+
+  const meetingsQuery = useQuery({
+    queryKey: ['season-meetings', latestSeason],
+    queryFn: () => fetchSeasonMeetings(latestSeason!),
+    enabled: latestSeason != null,
+  })
+
+  const hubQuery = useQuery({
+    queryKey: ['championship-hub', latestSeason],
+    queryFn: () => fetchChampionshipHub(latestSeason!),
+    enabled: latestSeason != null,
+  })
+
+  const meetings = meetingsQuery.data ?? []
+  const hub = hubQuery.data
+  const tagged = useMemo(
+    () => tagItems(news ?? [], hub?.drivers ?? [], hub?.teams ?? []),
+    [news, hub],
+  )
+
+  const windows = useMemo(() => gpWindows(meetings, now), [meetings, now])
+  const activeWindow = useMemo(
+    () => activeDigestWindow(windows, meetings, now),
+    [windows, meetings, now],
+  )
+  const sinceItems = useMemo(
+    () => itemsForWindow(tagged, activeWindow),
+    [tagged, activeWindow],
+  )
+  const sinceTags = useMemo(() => topTags(sinceItems, 4), [sinceItems])
+  const sinceLabel = sinceLastLabel(meetings, now)
+
  const unreadCount = news?.filter((i) => !i.read_at).length ?? 0
-  const preview = news?.slice(0, 5) ?? []
+  const preview = sinceItems.length > 0 ? sinceItems.slice(0, 5) : (tagged.slice(0, 5))

  return (
    <section className="cc-briefing" data-testid="paddock-briefing">
@@ -37,6 +92,27 @@ export function PaddockBriefing() {
        </Link>
      </div>

+      {meetings.length > 0 && (
+        <div className="cc-brief-digest-meta" data-testid="cc-brief-digest-meta">
+          <span>Since {sinceLabel}</span>
+          <span>·</span>
+          <span>{sinceItems.length} items</span>
+          {sinceTags.length > 0 && (
+            <div className="cc-brief-digest-tags">
+              {sinceTags.map((tag) => (
+                <span
+                  key={tag.key}
+                  className="cc-brief-tag"
+                  style={{ borderColor: tagColour(tag.colour) }}
+                >
+                  {tag.label}
+                </span>
+              ))}
+            </div>
+          )}
+        </div>
+      )}
+
      {isLoading && <div className="briefing-state loading-state">loading…</div>}
      {isError && <div className="briefing-state error-box">Failed to load briefing</div>}

--- a/frontend/src/components/RaceStoryCanvas.tsx
+++ b/frontend/src/components/RaceStoryCanvas.tsx
@@ -1,8 +1,5 @@
-import { useEffect, useMemo, useRef, useState } from 'react'
-import { useQuery } from '@tanstack/react-query'
-import type { Driver, EnrichedResult, EnrichedGrid, PositionSample, Lap, Meeting, Session } from '../types'
-import { fetchReplayFrames, fetchTrackOutline } from '../api'
-import { ReplayTrackMap } from './ReplayTrackMap'
+import { useState, useMemo, useRef, useCallback } from 'react'
+import type { EnrichedResult, EnrichedGrid, PositionSample, Lap, Session } from '../types'
 import { gridDelta, gridDeltaClass, formatDuration, formatGap } from '../utils'

 interface Props {
@@ -15,97 +12,28 @@ interface Props {
    race_control?: any[]
    pit_stops?: any[]
    session?: Session
-    meeting?: Meeting
-    drivers?: Driver[]
  }
 }

 export function RaceStoryCanvas({ data }: Props) {
-  const {
-    results,
-    starting_grid: grid,
-    positions,
-    datasets,
-    race_control = [],
-    pit_stops = [],
-    laps = [],
-    session,
-    meeting,
-    drivers = [],
-  } = data
+  const { results, starting_grid: grid, positions, datasets, race_control = [], pit_stops = [], laps = [] } = data
  const hasPositions = datasets['positions']?.status === 'available'

  const [scrubTime, setScrubTime] = useState<number | null>(null)
  const [hoverDriver, setHoverDriver] = useState<number | null>(null)
-  const [mapOpen, setMapOpen] = useState(false)
-  const [isPlaying, setIsPlaying] = useState(false)
-  const [playbackSpeed, setPlaybackSpeed] = useState(10)
  const svgRef = useRef<SVGSVGElement>(null)

  // Position Evolution Chart Logic
  const allTimes = useMemo(() => [...new Set(positions.map((p) => p.date))].sort(), [positions])
  const hasChartData = hasPositions && allTimes.length > 0
-  const chartTiming = useMemo(() => {
-    if (!hasChartData) return null
-    const tMin = new Date(allTimes[0]).getTime()
-    const tMax = new Date(allTimes[allTimes.length - 1]).getTime()
-    return { tMin, tMax, tRange: Math.max(tMax - tMin, 1) }
-  }, [allTimes, hasChartData])
-  const circuitKey = session?.circuit_key ?? meeting?.circuit_key ?? 0
-  const outlineYear = meeting?.year ?? (session?.date_start ? new Date(session.date_start).getFullYear() : 0)
-
-  const replayQuery = useQuery({
-    queryKey: ['replay-frames', session?.session_key, 5000],
-    queryFn: () => fetchReplayFrames(session!.session_key, 5000),
-    enabled: mapOpen && Boolean(session?.session_key),
-  })
-  const outlineQuery = useQuery({
-    queryKey: ['track-outline', circuitKey, outlineYear],
-    queryFn: () => fetchTrackOutline(circuitKey, outlineYear),
-    enabled: mapOpen && circuitKey > 0 && outlineYear > 0,
-  })
-
-  useEffect(() => {
-    if (!isPlaying || !chartTiming) return
-
-    let frame = 0
-    let last = performance.now()
-    const tick = (now: number) => {
-      const delta = now - last
-      last = now
-      setScrubTime((current) => {
-        const next = Math.min(1, (current ?? 0) + (delta * playbackSpeed) / chartTiming.tRange)
-        if (next >= 1) {
-          setIsPlaying(false)
-        }
-        return next
-      })
-      frame = requestAnimationFrame(tick)
-    }
-
-    frame = requestAnimationFrame(tick)
-    return () => cancelAnimationFrame(frame)
-  }, [chartTiming, isPlaying, playbackSpeed])
-
-  const replayTMs = useMemo(() => {
-    const replay = replayQuery.data
-    const frames = replay?.frames ?? []
-    if (frames.length === 0) return 0
-    const lastFrameT = frames[frames.length - 1].t
-    const progress = scrubTime ?? 0
-    if (!chartTiming || !replay?.start_time) {
-      return Math.max(0, Math.min(lastFrameT, Math.round(progress * lastFrameT)))
-    }
-    const replayStart = new Date(replay.start_time).getTime()
-    const chartTime = chartTiming.tMin + progress * chartTiming.tRange
-    return Math.max(0, Math.min(lastFrameT, Math.round(chartTime - replayStart)))
-  }, [chartTiming, replayQuery.data, scrubTime])

  let chartContent = null
  let displayResults = results

-  if (hasChartData && chartTiming) {
-    const { tMin, tRange } = chartTiming
+  if (hasChartData) {
+    const tMin = new Date(allTimes[0]).getTime()
+    const tMax = new Date(allTimes[allTimes.length - 1]).getTime()
+    const tRange = Math.max(tMax - tMin, 1)

    const byDriver = new Map<number, Array<{ t: number; pos: number }>>()
    for (const p of positions) {
@@ -209,7 +137,6 @@ export function RaceStoryCanvas({ data }: Props) {
    }

    const handlePointerMove = (e: React.PointerEvent<SVGRectElement>) => {
-      setIsPlaying(false)
      if (!svgRef.current) return
      const rect = svgRef.current.getBoundingClientRect()
      const x = e.clientX - rect.left
@@ -361,78 +288,24 @@ export function RaceStoryCanvas({ data }: Props) {
            height={plotH}
            fill="transparent"
            onPointerMove={handlePointerMove}
-            onPointerLeave={() => {
-              if (!isPlaying) setScrubTime(null)
-            }}
+            onPointerLeave={() => setScrubTime(null)}
            style={{ cursor: 'crosshair', touchAction: 'none' }}
          />
        </svg>
-        <div className="rs-replay-tools" aria-label="Race replay controls">
-          <button
-            type="button"
-            className={`rs-tool-btn ${isPlaying ? 'active' : ''}`}
-            onClick={() => {
-              setScrubTime((current) => current ?? 0)
-              setIsPlaying((current) => !current)
-            }}
-          >
-            {isPlaying ? 'Pause' : 'Play'}
-          </button>
-          <div className="rs-speed-group" aria-label="Playback speed">
-            {[1, 10, 30].map((speed) => (
-              <button
-                key={speed}
-                type="button"
-                className={`rs-speed-btn ${playbackSpeed === speed ? 'active' : ''}`}
-                onClick={() => setPlaybackSpeed(speed)}
-              >
-                {speed}x
-              </button>
-            ))}
-          </div>
-          <button
-            type="button"
-            className={`rs-tool-btn ${mapOpen ? 'active' : ''}`}
-            onClick={() => setMapOpen((current) => !current)}
-          >
-            Map
-          </button>
-        </div>
      </div>
    )
  }

  return (
    <div className="race-story-canvas">
-      <div className="rs-replay-shell">
-        <div className="rs-replay-main">
-          {hasChartData ? (
-            chartContent
-          ) : (
-            <div className="analysis-notice">
-              <strong>Lap-by-lap positions not available.</strong> This session does not
-              have ingested position samples in <code>/api/v1/race-hub</code>.
-            </div>
-          )}
+      {hasChartData ? (
+        chartContent
+      ) : (
+        <div className="analysis-notice">
+          <strong>Lap-by-lap positions not available.</strong> This session does not
+          have ingested position samples in <code>/api/v1/race-hub</code>.
        </div>
-        {mapOpen && (
-          <div className="rs-replay-map-slot">
-            {circuitKey > 0 && outlineYear > 0 ? (
-              <ReplayTrackMap
-                outline={outlineQuery.data}
-                replay={replayQuery.data}
-                tMs={replayTMs}
-                drivers={drivers}
-                results={results}
-                loading={outlineQuery.isLoading || replayQuery.isLoading}
-                error={outlineQuery.isError || replayQuery.isError}
-              />
-            ) : (
-              <div className="rs-replay-map-placeholder">track identity unavailable for replay map</div>
-            )}
-          </div>
-        )}
-      </div>
+      )}

      {displayResults.length > 0 && (
        <div className="rs-field-list">
--- a/frontend/src/components/ReplayTrackMap.tsx
+++ b/frontend/src/components/ReplayTrackMap.tsx
@@ -1,133 +0,0 @@
-import { useMemo, useState } from 'react'
-import type { Driver, EnrichedResult, ReplayFramesResponse, TrackOutline } from '../types'
-import { buildOutlinePath } from '../lib/trackmap'
-import { interpolateReplayCars, replayCarToSvg } from '../lib/replay'
-import '../styles/replay-map.css'
-
-interface Props {
-  outline?: TrackOutline | null
-  replay?: ReplayFramesResponse | null
-  tMs: number
-  drivers: Driver[]
-  results: EnrichedResult[]
-  loading?: boolean
-  error?: boolean
-}
-
-export function ReplayTrackMap({
-  outline,
-  replay,
-  tMs,
-  drivers,
-  results,
-  loading = false,
-  error = false,
-}: Props) {
-  const [pinned, setPinned] = useState<string | null>(null)
-  const outlinePath = useMemo(() => buildOutlinePath(outline?.points ?? []), [outline])
-  const driverInfo = useMemo(() => {
-    const info = new Map<string, { label: string; color: string }>()
-    for (const driver of drivers) {
-      info.set(String(driver.driver_number), {
-        label: driver.name_acronym || String(driver.driver_number),
-        color: normalizeColor(driver.team_colour),
-      })
-    }
-    for (const result of results) {
-      const key = String(result.driver_number)
-      if (!info.has(key)) {
-        info.set(key, {
-          label: result.name_acronym || key,
-          color: normalizeColor(result.team_colour),
-        })
-      }
-    }
-    return info
-  }, [drivers, results])
-
-  const cars = useMemo(() => {
-    if (!outline?.bounds || !replay?.frames?.length) return []
-    const positions = interpolateReplayCars(replay.frames, tMs)
-    return Object.entries(positions)
-      .map(([number, car]) => ({
-        number,
-        svg: replayCarToSvg(car, outline.bounds),
-        info: driverInfo.get(number),
-      }))
-      .sort((a, b) => Number(a.number) - Number(b.number))
-  }, [driverInfo, outline?.bounds, replay?.frames, tMs])
-
-  if (loading) {
-    return (
-      <section className="replay-map-panel" data-testid="replay-track-map">
-        <div className="replay-map-empty">loading replay GPS...</div>
-      </section>
-    )
-  }
-
-  if (error) {
-    return (
-      <section className="replay-map-panel" data-testid="replay-track-map">
-        <div className="replay-map-empty">replay GPS unavailable for this session</div>
-      </section>
-    )
-  }
-
-  if (!outline || !outlinePath) {
-    return (
-      <section className="replay-map-panel" data-testid="replay-track-map">
-        <div className="replay-map-empty">track outline unavailable for this session</div>
-      </section>
-    )
-  }
-
-  if (!replay?.frames?.length || cars.length === 0) {
-    return (
-      <section className="replay-map-panel" data-testid="replay-track-map">
-        <div className="replay-map-empty">historical GPS unavailable for this session</div>
-      </section>
-    )
-  }
-
-  return (
-    <section className="replay-map-panel" data-testid="replay-track-map">
-      <div className="replay-map-stage">
-        <svg className="replay-map-svg" viewBox="0 0 100 100" role="img" aria-label="Replay track map">
-          <path className="replay-map-outline-shadow" d={outlinePath} />
-          <path className="replay-map-outline" d={outlinePath} />
-          {cars.map((car) => {
-            const label = car.info?.label ?? car.number
-            const selected = pinned === car.number
-            return (
-              <g
-                key={car.number}
-                role="button"
-                tabIndex={0}
-                aria-label={`${label} replay position`}
-                className={`replay-car ${selected ? 'replay-car-pinned' : ''}`}
-                transform={`translate(${car.svg.x.toFixed(2)} ${car.svg.y.toFixed(2)})`}
-                onClick={() => setPinned(selected ? null : car.number)}
-                onKeyDown={(event) => {
-                  if (event.key === 'Enter' || event.key === ' ') {
-                    event.preventDefault()
-                    setPinned(selected ? null : car.number)
-                  }
-                }}
-              >
-                <title>{label}</title>
-                <circle r="2.7" fill={car.info?.color ?? '#777777'} />
-                <text y="0.85">{label}</text>
-              </g>
-            )
-          })}
-        </svg>
-      </div>
-    </section>
-  )
-}
-
-function normalizeColor(color: string | undefined): string {
-  const raw = color?.trim()
-  if (!raw) return '#777777'
-  return raw.startsWith('#') ? raw : `#${raw}`
-}
--- a/frontend/src/lib/digest.ts
+++ b/frontend/src/lib/digest.ts
@@ -0,0 +1,293 @@
+import { meetingEndTime, meetingStartTime, mostRecentPastMeeting, nextUpcomingMeeting } from './schedule'
+import type { ChampHubDriver, ChampHubTeam, Meeting, NewsItem } from '../types'
+
+export interface GPWindow {
+  meeting_key: number
+  meeting_name: string
+  /** Inclusive lower bound: end of previous GP, or open for season opener. */
+  start: Date | null
+  /** Exclusive upper bound: start of next GP, or open after the final round. */
+  end: Date | null
+}
+
+export interface DigestTag {
+  kind: 'driver' | 'team'
+  key: string
+  label: string
+  colour: string
+}
+
+export type TaggedNewsItem = NewsItem & { tags: DigestTag[] }
+
+export const RECENT_BUCKET_KEY = '__recent__'
+
+interface MatchCandidate {
+  start: number
+  end: number
+  tag: DigestTag
+}
+
+interface TagPattern {
+  pattern: string
+  tag: DigestTag
+}
+
+function sortMeetings(meetings: Meeting[]): Meeting[] {
+  return [...meetings].sort((a, b) => {
+    const left = meetingStartTime(a)?.getTime() ?? 0
+    const right = meetingStartTime(b)?.getTime() ?? 0
+    if (left !== right) return left - right
+    return a.meeting_name.localeCompare(b.meeting_name)
+  })
+}
+
+/** Derive inter-race windows [prev GP end → next GP start] for each round. */
+export function gpWindows(meetings: Meeting[], _now: Date): GPWindow[] {
+  const sorted = sortMeetings(meetings)
+  return sorted.map((meeting, index) => ({
+    meeting_key: meeting.meeting_key,
+    meeting_name: meeting.meeting_name,
+    start: index > 0 ? meetingEndTime(sorted[index - 1]) : null,
+    end: index < sorted.length - 1 ? meetingStartTime(sorted[index + 1]) : null,
+  }))
+}
+
+function itemPublishedAt(item: NewsItem): Date | null {
+  if (!item.published_at) return null
+  const parsed = Date.parse(item.published_at)
+  return Number.isNaN(parsed) ? null : new Date(parsed)
+}
+
+function itemInWindow(published: Date, window: GPWindow): boolean {
+  if (window.start && published < window.start) return false
+  if (window.end && published >= window.end) return false
+  return true
+}
+
+export function windowForDate(windows: GPWindow[], published: Date): GPWindow | null {
+  const matches = windows.filter((window) => itemInWindow(published, window))
+  if (matches.length === 0) return null
+  return matches.reduce((best, window) => {
+    const bestStart = best.start?.getTime() ?? Number.NEGATIVE_INFINITY
+    const windowStart = window.start?.getTime() ?? Number.NEGATIVE_INFINITY
+    return windowStart >= bestStart ? window : best
+  })
+}
+
+export interface GroupedDigest {
+  windows: Array<{ window: GPWindow; items: NewsItem[] }>
+  recent: NewsItem[]
+}
+
+/** Bucket news items into GP windows; undated items land in `recent`. */
+export function groupByWindow(items: NewsItem[], windows: GPWindow[]): GroupedDigest {
+  const buckets = new Map<number, NewsItem[]>()
+  const recent: NewsItem[] = []
+
+  for (const item of items) {
+    const published = itemPublishedAt(item)
+    if (!published) {
+      recent.push(item)
+      continue
+    }
+    const match = windowForDate(windows, published)
+    if (!match) {
+      recent.push(item)
+      continue
+    }
+    const list = buckets.get(match.meeting_key) ?? []
+    list.push(item)
+    buckets.set(match.meeting_key, list)
+  }
+
+  const grouped = windows
+    .map((window) => ({
+      window,
+      items: buckets.get(window.meeting_key) ?? [],
+    }))
+    .filter((entry) => entry.items.length > 0)
+
+  return { windows: grouped, recent }
+}
+
+function driverLastName(fullName: string): string | null {
+  const parts = fullName.trim().split(/\s+/).filter(Boolean)
+  if (parts.length < 2) return null
+  return parts[parts.length - 1] ?? null
+}
+
+function buildTagPatterns(drivers: ChampHubDriver[], teams: ChampHubTeam[]): TagPattern[] {
+  const patterns: TagPattern[] = []
+
+  for (const team of teams) {
+    if (!team.team_name.trim()) continue
+    patterns.push({
+      pattern: team.team_name.toLowerCase(),
+      tag: {
+        kind: 'team',
+        key: `team:${team.team_name}`,
+        label: team.team_name,
+        colour: team.team_colour,
+      },
+    })
+  }
+
+  for (const driver of drivers) {
+    const colour = driver.team_colour
+    const base = {
+      kind: 'driver' as const,
+      colour,
+    }
+    if (driver.full_name.trim()) {
+      patterns.push({
+        pattern: driver.full_name.toLowerCase(),
+        tag: {
+          ...base,
+          key: `driver:${driver.name_acronym}`,
+          label: driver.name_acronym,
+        },
+      })
+      const lastName = driverLastName(driver.full_name)
+      if (lastName) {
+        patterns.push({
+          pattern: lastName.toLowerCase(),
+          tag: {
+            ...base,
+            key: `driver:${driver.name_acronym}`,
+            label: driver.name_acronym,
+          },
+        })
+      }
+    }
+    if (driver.name_acronym.trim()) {
+      patterns.push({
+        pattern: driver.name_acronym.toLowerCase(),
+        tag: {
+          ...base,
+          key: `driver:${driver.name_acronym}`,
+          label: driver.name_acronym,
+        },
+      })
+    }
+  }
+
+  patterns.sort((a, b) => b.pattern.length - a.pattern.length)
+  return patterns
+}
+
+function overlaps(a: MatchCandidate, b: MatchCandidate): boolean {
+  return a.start < b.end && b.start < a.end
+}
+
+/**
+ * Tag items via case-insensitive substring match on title + summary.
+ * Longest pattern wins on overlapping spans (v1 string match — no NLP).
+ *
+ * Known limitations: common-word last names, team names inside other words,
+ * and driver TLAs that appear in unrelated acronyms can false-positive.
+ */
+export function tagItems(
+  items: NewsItem[],
+  drivers: ChampHubDriver[],
+  teams: ChampHubTeam[],
+): TaggedNewsItem[] {
+  const patterns = buildTagPatterns(drivers, teams)
+
+  return items.map((item) => {
+    const haystack = `${item.title} ${item.summary ?? ''}`.toLowerCase()
+    const accepted: MatchCandidate[] = []
+
+    for (const { pattern, tag } of patterns) {
+      if (!pattern) continue
+      let from = 0
+      while (from <= haystack.length - pattern.length) {
+        const index = haystack.indexOf(pattern, from)
+        if (index === -1) break
+        const candidate: MatchCandidate = {
+          start: index,
+          end: index + pattern.length,
+          tag,
+        }
+        if (!accepted.some((match) => overlaps(match, candidate))) {
+          accepted.push(candidate)
+        }
+        from = index + 1
+      }
+    }
+
+    const tagsByKey = new Map<string, DigestTag>()
+    for (const match of accepted) {
+      tagsByKey.set(match.tag.key, match.tag)
+    }
+
+    return {
+      ...item,
+      tags: [...tagsByKey.values()].sort((a, b) => a.label.localeCompare(b.label)),
+    }
+  })
+}
+
+export function activeDigestWindow(
+  windows: GPWindow[],
+  meetings: Meeting[],
+  now: Date,
+): GPWindow | null {
+  const next = nextUpcomingMeeting(meetings, now)
+  if (next) {
+    return windows.find((window) => window.meeting_key === next.meeting_key) ?? null
+  }
+  const recent = mostRecentPastMeeting(meetings, now)
+  if (recent) {
+    return windows.find((window) => window.meeting_key === recent.meeting_key) ?? null
+  }
+  return windows[0] ?? null
+}
+
+export function sinceLastLabel(meetings: Meeting[], now: Date): string {
+  const last = mostRecentPastMeeting(meetings, now)
+  if (last) return last.meeting_name
+  const next = nextUpcomingMeeting(meetings, now)
+  if (next) return `Before ${next.meeting_name}`
+  return 'Pre-season'
+}
+
+export function itemsForWindow(items: TaggedNewsItem[], window: GPWindow | null): TaggedNewsItem[] {
+  if (!window) return []
+  return items.filter((item) => {
+    const published = itemPublishedAt(item)
+    return published != null && itemInWindow(published, window)
+  })
+}
+
+export function topTags(items: TaggedNewsItem[], limit = 5): DigestTag[] {
+  const counts = new Map<string, { tag: DigestTag; count: number }>()
+  for (const item of items) {
+    for (const tag of item.tags) {
+      const current = counts.get(tag.key)
+      if (current) current.count += 1
+      else counts.set(tag.key, { tag, count: 1 })
+    }
+  }
+  return [...counts.values()]
+    .sort((a, b) => b.count - a.count || a.tag.label.localeCompare(b.tag.label))
+    .slice(0, limit)
+    .map((entry) => entry.tag)
+}
+
+export function filterByTag(items: TaggedNewsItem[], tagKey: string | null): TaggedNewsItem[] {
+  if (!tagKey) return items
+  return items.filter((item) => item.tags.some((tag) => tag.key === tagKey))
+}
+
+export function tagColour(colour: string): string {
+  if (!colour) return 'var(--text-3)'
+  return colour.startsWith('#') ? colour : `#${colour}`
+}
+
+export function sortWindowBucketsNewestFirst<T extends { window: GPWindow }>(buckets: T[]): T[] {
+  return [...buckets].sort((a, b) => {
+    const left = a.window.start?.getTime() ?? 0
+    const right = b.window.start?.getTime() ?? 0
+    return right - left
+  })
+}
--- a/frontend/src/lib/replay.ts
+++ b/frontend/src/lib/replay.ts
@@ -1,75 +0,0 @@
-import type { ReplayCarPosition, ReplayFrame, TrackBounds } from '../types'
-import { canvasToSvg, normalizeRawPoint } from './trackmap'
-
-export interface ReplayFramePair {
-  previous: ReplayFrame | null
-  next: ReplayFrame | null
-}
-
-export function lookupReplayFramePair(
-  frames: ReadonlyArray<ReplayFrame>,
-  tMs: number,
-): ReplayFramePair {
-  if (frames.length === 0) return { previous: null, next: null }
-  if (tMs <= frames[0].t) return { previous: frames[0], next: frames[0] }
-  const last = frames[frames.length - 1]
-  if (tMs >= last.t) return { previous: last, next: last }
-
-  let lo = 0
-  let hi = frames.length - 1
-  while (lo <= hi) {
-    const mid = Math.floor((lo + hi) / 2)
-    const frame = frames[mid]
-    if (frame.t === tMs) return { previous: frame, next: frame }
-    if (frame.t < tMs) {
-      lo = mid + 1
-    } else {
-      hi = mid - 1
-    }
-  }
-
-  return { previous: frames[Math.max(0, hi)], next: frames[Math.min(frames.length - 1, lo)] }
-}
-
-export function interpolateReplayCars(
-  frames: ReadonlyArray<ReplayFrame>,
-  tMs: number,
-): Record<string, ReplayCarPosition> {
-  const { previous, next } = lookupReplayFramePair(frames, tMs)
-  if (!previous && !next) return {}
-  if (!previous) return next?.cars ?? {}
-  if (!next || previous.t === next.t) return previous.cars
-
-  const span = next.t - previous.t
-  const fraction = span <= 0 ? 0 : clamp01((tMs - previous.t) / span)
-  const cars: Record<string, ReplayCarPosition> = {}
-  const numbers = new Set([...Object.keys(previous.cars), ...Object.keys(next.cars)])
-
-  for (const number of numbers) {
-    const before = previous.cars[number]
-    const after = next.cars[number]
-    if (before && after) {
-      cars[number] = {
-        x: before.x + (after.x - before.x) * fraction,
-        y: before.y + (after.y - before.y) * fraction,
-      }
-    } else if (before) {
-      cars[number] = before
-    } else if (after) {
-      cars[number] = after
-    }
-  }
-  return cars
-}
-
-export function replayCarToSvg(
-  car: ReplayCarPosition,
-  bounds: TrackBounds,
-): ReplayCarPosition {
-  return canvasToSvg(normalizeRawPoint({ x: car.x, y: car.y }, bounds))
-}
-
-function clamp01(value: number): number {
-  if (!Number.isFinite(value)) return 0
-  return Math.min(1, Math.max(0, value))
-}
--- a/frontend/src/pages/BriefingPage.tsx
+++ b/frontend/src/pages/BriefingPage.tsx
@@ -1,13 +1,33 @@
-import { useCallback, useEffect, useRef, useState } from 'react'
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { useQuery, useQueryClient } from '@tanstack/react-query'
-import { fetchNews, fetchNewsArticle, markNewsRead } from '../api'
+import {
+  fetchChampionshipHub,
+  fetchNews,
+  fetchNewsArticle,
+  fetchSeasonMeetings,
+  fetchSeasons,
+  markNewsRead,
+} from '../api'
+import {
+  activeDigestWindow,
+  filterByTag,
+  groupByWindow,
+  gpWindows,
+  itemsForWindow,
+  sinceLastLabel,
+  sortWindowBucketsNewestFirst,
+  tagColour,
+  tagItems,
+  topTags,
+  type DigestTag,
+  type TaggedNewsItem,
+} from '../lib/digest'
 import { stripHtml, timeAgo } from '../utils'
 import type { ArticleContent, NewsItem } from '../types'
+import '../styles/digest.css'

 type Category = 'all' | 'official' | 'news' | 'video'

-const PAGE_SIZE = 16
-
 const CATEGORY_LABELS: Record<Category, string> = {
  all: 'All',
  official: 'Official',
@@ -71,6 +91,31 @@ function CategoryTabs({
  )
 }

+function TagChip({
+  tag,
+  active,
+  onClick,
+  className = 'digest-tag-chip',
+}: {
+  tag: DigestTag
+  active?: boolean
+  onClick?: () => void
+  className?: string
+}) {
+  return (
+    <button
+      type="button"
+      className={`${className}${active ? ' active' : ''}`}
+      style={{ '--tag-colour': tagColour(tag.colour) } as React.CSSProperties}
+      onClick={onClick}
+      aria-pressed={active}
+    >
+      <span className="digest-tag-dot" aria-hidden="true" />
+      {tag.label}
+    </button>
+  )
+}
+
 function OGImage({ url, title }: { url?: string; title: string }) {
  const [failed, setFailed] = useState(false)
  const initial = (title[0] ?? '?').toUpperCase()
@@ -98,11 +143,15 @@ function OGImage({ url, title }: { url?: string; title: string }) {
 function BriefingCard({
  item,
  isActive,
+  activeTag,
  onSelect,
+  onTagClick,
 }: {
-  item: NewsItem
+  item: TaggedNewsItem
  isActive: boolean
+  activeTag: string | null
  onSelect: (item: NewsItem) => void
+  onTagClick: (tag: DigestTag) => void
 }) {
  const isRead = !!item.read_at
  const isVideo = categoryOf(item) === 'video'
@@ -129,6 +178,25 @@ function BriefingCard({
            {stripHtml(item.og_description || item.summary || '')}
          </p>
        )}
+        {item.tags.length > 0 && (
+          <div className="bp-card-tags">
+            {item.tags.map((tag) => (
+              <button
+                key={tag.key}
+                type="button"
+                className={`bp-card-tag${activeTag === tag.key ? ' active' : ''}`}
+                style={{ '--tag-colour': tagColour(tag.colour) } as React.CSSProperties}
+                onClick={(e) => {
+                  e.stopPropagation()
+                  onTagClick(tag)
+                }}
+              >
+                <span className="digest-tag-dot" aria-hidden="true" />
+                {tag.label}
+              </button>
+            ))}
+          </div>
+        )}
      </div>
    </article>
  )
@@ -146,7 +214,6 @@ function ReaderPanel({
  const [loading, setLoading] = useState(false)
  const [error, setError] = useState<string | null>(null)

-  // Close on Escape
  useEffect(() => {
    const handler = (e: KeyboardEvent) => {
      if (e.key === 'Escape') onClose()
@@ -155,7 +222,6 @@ function ReaderPanel({
    return () => document.removeEventListener('keydown', handler)
  }, [onClose])

-  // Fetch article when item changes
  useEffect(() => {
    if (!item) {
      setArticle(null)
@@ -175,9 +241,14 @@ function ReaderPanel({
      .catch((err) => { setError(String(err)); setLoading(false) })
  }, [item?.url, item ? categoryOf(item) : ''])

-  // Scroll panel to top when item changes
  useEffect(() => {
-    panelRef.current?.scrollTo({ top: 0 })
+    const panel = panelRef.current
+    if (!panel) return
+    if (typeof panel.scrollTo === 'function') {
+      panel.scrollTo({ top: 0 })
+    } else {
+      panel.scrollTop = 0
+    }
  }, [item?.url])

  const isOpen = item !== null
@@ -297,7 +368,6 @@ function ReaderPanel({
              {article && !loading && article.content && (
                <div
                  className="bp-reader-body"
-                  // readability strips scripts/iframes; sources are all known news outlets
                  // eslint-disable-next-line react/no-danger
                  dangerouslySetInnerHTML={{ __html: article.content }}
                />
@@ -332,8 +402,9 @@ function ReaderPanel({
 export function BriefingPage() {
  const [activeCategory, setActiveCategory] = useState<Category>('all')
  const [selectedItem, setSelectedItem] = useState<NewsItem | null>(null)
-  const [page, setPage] = useState(1)
+  const [activeTag, setActiveTag] = useState<string | null>(null)
  const queryClient = useQueryClient()
+  const now = useMemo(() => new Date(), [])

  const { data: allNews = [], isLoading, isError } = useQuery({
    queryKey: ['news'],
@@ -341,13 +412,74 @@ export function BriefingPage() {
    staleTime: 60_000,
  })

-  const filtered = allNews.filter(
-    (item) => activeCategory === 'all' || categoryOf(item) === activeCategory,
+  const seasonsQuery = useQuery({
+    queryKey: ['seasons'],
+    queryFn: fetchSeasons,
+  })
+  const latestSeason = seasonsQuery.data?.[0] ?? null
+
+  const meetingsQuery = useQuery({
+    queryKey: ['season-meetings', latestSeason],
+    queryFn: () => fetchSeasonMeetings(latestSeason!),
+    enabled: latestSeason != null,
+  })
+
+  const hubQuery = useQuery({
+    queryKey: ['championship-hub', latestSeason],
+    queryFn: () => fetchChampionshipHub(latestSeason!),
+    enabled: latestSeason != null,
+  })
+
+  const meetings = meetingsQuery.data ?? []
+  const hub = hubQuery.data
+
+  const taggedNews = useMemo(
+    () => tagItems(allNews, hub?.drivers ?? [], hub?.teams ?? []),
+    [allNews, hub],
  )
-  const pageCount = Math.max(1, Math.ceil(filtered.length / PAGE_SIZE))
-  const safePage = Math.min(page, pageCount)
-  const pageStart = (safePage - 1) * PAGE_SIZE
-  const pagedItems = filtered.slice(pageStart, pageStart + PAGE_SIZE)
+
+  const categoryFiltered = useMemo(
+    () => taggedNews.filter(
+      (item) => activeCategory === 'all' || categoryOf(item) === activeCategory,
+    ),
+    [taggedNews, activeCategory],
+  )
+
+  const tagFiltered = useMemo(
+    () => filterByTag(categoryFiltered, activeTag),
+    [categoryFiltered, activeTag],
+  )
+
+  const windows = useMemo(() => gpWindows(meetings, now), [meetings, now])
+  const grouped = useMemo(() => groupByWindow(tagFiltered, windows), [tagFiltered, windows])
+  const windowSections = useMemo(
+    () => sortWindowBucketsNewestFirst(grouped.windows),
+    [grouped.windows],
+  )
+
+  const activeWindow = useMemo(
+    () => activeDigestWindow(windows, meetings, now),
+    [windows, meetings, now],
+  )
+
+  const sinceLastItems = useMemo(
+    () => itemsForWindow(tagFiltered, activeWindow),
+    [tagFiltered, activeWindow],
+  )
+
+  const sinceLastTags = useMemo(() => topTags(sinceLastItems), [sinceLastItems])
+  const sinceLabel = sinceLastLabel(meetings, now)
+
+  const taggedByUrl = useMemo(() => {
+    const map = new Map<string, TaggedNewsItem>()
+    for (const item of tagFiltered) map.set(item.url, item)
+    return map
+  }, [tagFiltered])
+
+  const recentTagged = useMemo(() => {
+    const urls = new Set(grouped.recent.map((item) => item.url))
+    return tagFiltered.filter((item) => urls.has(item.url))
+  }, [grouped.recent, tagFiltered])

  const counts: Record<Category, number> = {
    all: allNews.length,
@@ -374,22 +506,14 @@ export function BriefingPage() {

  const handleClose = useCallback(() => setSelectedItem(null), [])

-  useEffect(() => {
-    setPage((current) => Math.min(current, pageCount))
-  }, [pageCount])
-
-  const handlePageChange = useCallback(
-    (nextPage: number) => {
-      setPage(Math.min(Math.max(nextPage, 1), pageCount))
-      setSelectedItem(null)
-      window.scrollTo({ top: 0, behavior: 'smooth' })
-    },
-    [pageCount],
-  )
+  const handleTagClick = useCallback((tag: DigestTag) => {
+    setActiveTag((current) => (current === tag.key ? null : tag.key))
+    setSelectedItem(null)
+  }, [])

  const unreadCount = allNews.filter((i) => !i.read_at).length
-  const pageEnd = Math.min(pageStart + pagedItems.length, filtered.length)
-  const showPagination = filtered.length > PAGE_SIZE
+  const hasDigest = meetings.length > 0
+  const showEmpty = tagFiltered.length === 0 && grouped.recent.length === 0

  return (
    <div className="bp-page" data-testid="briefing-page">
@@ -408,74 +532,106 @@ export function BriefingPage() {
          <CategoryTabs
            active={activeCategory}
            counts={counts}
-            onChange={(c) => { setActiveCategory(c); setSelectedItem(null); setPage(1) }}
+            onChange={(c) => {
+              setActiveCategory(c)
+              setSelectedItem(null)
+              setActiveTag(null)
+            }}
          />

-          {filtered.length === 0 ? (
+          {hasDigest && (
+            <div className="digest-sticky" data-testid="digest-sticky-header">
+              <div className="digest-sticky-head">
+                <h2 className="digest-sticky-title">Since {sinceLabel}</h2>
+                <span className="digest-sticky-count">
+                  {sinceLastItems.length} item{sinceLastItems.length === 1 ? '' : 's'}
+                </span>
+              </div>
+              {(sinceLastTags.length > 0 || activeTag) && (
+                <div className="digest-sticky-tags">
+                  {sinceLastTags.map((tag) => (
+                    <TagChip
+                      key={tag.key}
+                      tag={tag}
+                      active={activeTag === tag.key}
+                      onClick={() => handleTagClick(tag)}
+                    />
+                  ))}
+                  {activeTag && (
+                    <button
+                      type="button"
+                      className="digest-filter-clear"
+                      onClick={() => setActiveTag(null)}
+                      data-testid="digest-filter-clear"
+                    >
+                      Clear filter
+                    </button>
+                  )}
+                </div>
+              )}
+            </div>
+          )}
+
+          {showEmpty ? (
            <div className="bp-empty">
              No {activeCategory !== 'all' ? activeCategory : ''} items available.
-              Run <code>box-box --ingest-news</code> to refresh feeds.
+              {activeTag ? ' Try clearing the tag filter.' : ''}
+              {!activeTag && (
+                <>
+                  {' '}
+                  Run <code>box-box --ingest-news</code> to refresh feeds.
+                </>
+              )}
            </div>
          ) : (
            <>
-              {showPagination && (
-                <div className="bp-pagination bp-pagination-top">
-                  <span className="bp-pagination-meta mono">
-                    {pageStart + 1}-{pageEnd} of {filtered.length}
-                  </span>
-                  <div className="bp-pagination-actions">
-                    <button
-                      className="bp-page-btn"
-                      onClick={() => handlePageChange(safePage - 1)}
-                      disabled={safePage === 1}
-                    >
-                      Previous
-                    </button>
-                    <span className="bp-page-current mono">
-                      Page {safePage} / {pageCount}
-                    </span>
-                    <button
-                      className="bp-page-btn"
-                      onClick={() => handlePageChange(safePage + 1)}
-                      disabled={safePage === pageCount}
-                    >
-                      Next
-                    </button>
+              {windowSections.map(({ window, items }) => (
+                <section
+                  key={window.meeting_key}
+                  className="digest-section"
+                  data-testid={`digest-window-${window.meeting_key}`}
+                >
+                  <div className="digest-section-head">
+                    <h3 className="digest-section-title">{window.meeting_name}</h3>
+                    <span className="digest-section-count">{items.length}</span>
                  </div>
-                </div>
-              )}
+                  <div className={`bp-grid${selectedItem ? ' bp-grid-narrow' : ''}`}>
+                    {items.map((item) => {
+                      const tagged = taggedByUrl.get(item.url) ?? { ...item, tags: [] }
+                      return (
+                        <BriefingCard
+                          key={item.url}
+                          item={tagged}
+                          isActive={selectedItem?.url === item.url}
+                          activeTag={activeTag}
+                          onSelect={handleSelect}
+                          onTagClick={handleTagClick}
+                        />
+                      )
+                    })}
+                  </div>
+                </section>
+              ))}

-              <div className={`bp-grid${selectedItem ? ' bp-grid-narrow' : ''}`}>
-                {pagedItems.map((item) => (
-                  <BriefingCard
-                    key={item.url}
-                    item={item}
-                    isActive={selectedItem?.url === item.url}
-                    onSelect={handleSelect}
-                  />
-                ))}
-              </div>
-
-              {showPagination && (
-                <div className="bp-pagination bp-pagination-bottom">
-                  <button
-                    className="bp-page-btn"
-                    onClick={() => handlePageChange(safePage - 1)}
-                    disabled={safePage === 1}
-                  >
-                    Previous
-                  </button>
-                  <span className="bp-page-current mono">
-                    Page {safePage} / {pageCount}
-                  </span>
-                  <button
-                    className="bp-page-btn"
-                    onClick={() => handlePageChange(safePage + 1)}
-                    disabled={safePage === pageCount}
-                  >
-                    Next
-                  </button>
-                </div>
+              {recentTagged.length > 0 && (
+                <section className="digest-section digest-recent-section" data-testid="digest-recent">
+                  <div className="digest-section-head">
+                    <h3 className="digest-section-title">Recent</h3>
+                    <span className="digest-section-count">{recentTagged.length}</span>
+                  </div>
+                  <div className={`bp-grid${selectedItem ? ' bp-grid-narrow' : ''}`}>
+                    {recentTagged.map((item) => (
+                      <BriefingCard
+                        key={item.url}
+                        item={item}
+                        isActive={selectedItem?.url === item.url}
+                        activeTag={activeTag}
+                        onSelect={handleSelect}
+                        onTagClick={handleTagClick}
+                      />
+                    ))}
+                  </div>
+                </section>
              )}
            </>
          )}
--- a/frontend/src/styles/digest.css
+++ b/frontend/src/styles/digest.css
@@ -0,0 +1,178 @@
+/* ── Calendar-aware paddock digest ── */
+
+.digest-sticky {
+  position: sticky;
+  top: 0;
+  z-index: 20;
+  margin-bottom: var(--s5);
+  padding: var(--s4) var(--s5);
+  background: color-mix(in srgb, var(--bg) 92%, transparent);
+  backdrop-filter: blur(8px);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+}
+
+.digest-sticky-head {
+  display: flex;
+  align-items: baseline;
+  gap: var(--s3);
+  flex-wrap: wrap;
+  margin-bottom: var(--s3);
+}
+
+.digest-sticky-title {
+  font-size: 15px;
+  font-weight: 600;
+  color: var(--text);
+  margin: 0;
+}
+
+.digest-sticky-count {
+  font-size: 11px;
+  color: var(--text-3);
+  font-family: var(--f-mono);
+  letter-spacing: 0.04em;
+}
+
+.digest-sticky-tags {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--s2);
+  align-items: center;
+}
+
+.digest-tag-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: var(--s2);
+  padding: 2px 8px;
+  border-radius: 999px;
+  border: 1px solid var(--border-2);
+  background: var(--surface);
+  color: var(--text-2);
+  font-size: 11px;
+  font-family: var(--f-mono);
+  cursor: pointer;
+  transition: border-color 0.1s, color 0.1s, background 0.1s;
+}
+
+.digest-tag-chip:hover {
+  color: var(--text);
+  background: var(--surface-h);
+}
+
+.digest-tag-chip.active {
+  color: var(--text);
+  border-color: var(--tag-colour, var(--red));
+  box-shadow: 0 0 0 1px color-mix(in srgb, var(--tag-colour, var(--red)) 35%, transparent);
+}
+
+.digest-tag-dot {
+  width: 7px;
+  height: 7px;
+  border-radius: 50%;
+  background: var(--tag-colour, var(--text-3));
+  flex-shrink: 0;
+}
+
+.digest-filter-clear {
+  padding: 2px 8px;
+  border: 1px dashed var(--border-2);
+  border-radius: 999px;
+  background: none;
+  color: var(--text-3);
+  font-size: 11px;
+  font-family: var(--f-mono);
+  cursor: pointer;
+}
+
+.digest-filter-clear:hover {
+  color: var(--text);
+  border-color: var(--border-2);
+}
+
+.digest-section {
+  margin-bottom: var(--s6);
+}
+
+.digest-section-head {
+  display: flex;
+  align-items: baseline;
+  gap: var(--s3);
+  margin-bottom: var(--s4);
+  padding-bottom: var(--s3);
+  border-bottom: 1px solid var(--border);
+}
+
+.digest-section-title {
+  font-size: 13px;
+  font-weight: 600;
+  color: var(--text);
+  margin: 0;
+  letter-spacing: 0.02em;
+}
+
+.digest-section-count {
+  font-size: 11px;
+  color: var(--text-3);
+  font-family: var(--f-mono);
+}
+
+.digest-recent-section .digest-section-title {
+  color: var(--text-2);
+}
+
+.bp-card-tags {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--s2);
+  margin-top: var(--s2);
+}
+
+.bp-card-tag {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  padding: 1px 6px;
+  border-radius: 999px;
+  border: 1px solid var(--border);
+  background: var(--bg);
+  color: var(--text-2);
+  font-size: 10px;
+  font-family: var(--f-mono);
+  cursor: pointer;
+}
+
+.bp-card-tag:hover {
+  color: var(--text);
+  border-color: var(--border-2);
+}
+
+.bp-card-tag.active {
+  border-color: var(--tag-colour, var(--red));
+}
+
+.cc-brief-digest-meta {
+  display: flex;
+  align-items: center;
+  gap: var(--s2);
+  margin-bottom: var(--s3);
+  font-size: 11px;
+  color: var(--text-3);
+  font-family: var(--f-mono);
+}
+
+.cc-brief-digest-tags {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--s2);
+}
+
+.cc-brief-tag {
+  font-size: 10px;
+  padding: 1px 6px;
+  border-radius: 999px;
+  border: 1px solid var(--border);
+  color: var(--text-2);
+  font-family: var(--f-mono);
+}
--- a/frontend/src/styles/replay-map.css
+++ b/frontend/src/styles/replay-map.css
@@ -1,161 +0,0 @@
-.rs-replay-shell {
-  display: grid;
-  grid-template-columns: minmax(0, 1.4fr) minmax(260px, 0.8fr);
-  gap: var(--s5);
-  align-items: stretch;
-}
-
-.rs-replay-main {
-  min-width: 0;
-}
-
-.rs-replay-tools {
-  display: flex;
-  align-items: center;
-  flex-wrap: wrap;
-  gap: var(--s3);
-  margin-top: var(--s3);
-}
-
-.rs-tool-btn,
-.rs-speed-btn {
-  height: 28px;
-  padding: 0 var(--s4);
-  font-family: var(--f-mono);
-  font-size: 10px;
-  font-weight: 700;
-  color: var(--text-2);
-  background: var(--surface);
-  border: 1px solid var(--border-2);
-  border-radius: 2px;
-  cursor: pointer;
-}
-
-.rs-tool-btn:hover,
-.rs-speed-btn:hover {
-  color: var(--text);
-  border-color: var(--text-3);
-}
-
-.rs-tool-btn.active,
-.rs-speed-btn.active {
-  color: var(--text);
-  border-color: var(--red);
-  background: rgba(230, 36, 41, 0.12);
-}
-
-.rs-speed-group {
-  display: inline-flex;
-  gap: 2px;
-}
-
-.rs-replay-map-slot {
-  min-width: 0;
-}
-
-.rs-replay-map-placeholder {
-  min-height: 244px;
-  display: grid;
-  place-items: center;
-  padding: var(--s5);
-  color: var(--text-3);
-  font-family: var(--f-mono);
-  font-size: 11px;
-  text-align: center;
-  border: 1px dashed var(--border-2);
-  background: var(--surface);
-}
-
-.replay-map-panel {
-  min-height: 244px;
-  height: 100%;
-  border: 1px solid var(--border);
-  background: var(--surface);
-}
-
-.replay-map-stage {
-  position: relative;
-  min-height: 244px;
-  height: 100%;
-}
-
-.replay-map-svg {
-  width: 100%;
-  height: 100%;
-  min-height: 244px;
-  display: block;
-  background: radial-gradient(circle at 50% 50%, rgba(255, 255, 255, 0.04), transparent 62%);
-}
-
-.replay-map-outline-shadow,
-.replay-map-outline {
-  fill: none;
-  vector-effect: non-scaling-stroke;
-  stroke-linecap: round;
-  stroke-linejoin: round;
-}
-
-.replay-map-outline-shadow {
-  stroke: rgba(255, 255, 255, 0.08);
-  stroke-width: 5;
-}
-
-.replay-map-outline {
-  stroke: var(--text-2);
-  stroke-width: 1.8;
-}
-
-.replay-car {
-  cursor: pointer;
-  outline: none;
-}
-
-.replay-car circle {
-  stroke: var(--bg);
-  stroke-width: 0.8;
-  filter: drop-shadow(0 1px 3px rgba(0, 0, 0, 0.55));
-}
-
-.replay-car text {
-  fill: #fff;
-  font-family: var(--f-mono);
-  font-size: 2.6px;
-  font-weight: 800;
-  text-anchor: middle;
-  pointer-events: none;
-  paint-order: stroke;
-  stroke: rgba(0, 0, 0, 0.75);
-  stroke-width: 0.7;
-}
-
-.replay-car:not(.replay-car-pinned) text {
-  opacity: 0;
-}
-
-.replay-car:hover text,
-.replay-car:focus-visible text,
-.replay-car-pinned text {
-  opacity: 1;
-}
-
-.replay-car-pinned circle {
-  stroke: #fff;
-  stroke-width: 1.2;
-}
-
-.replay-map-empty {
-  min-height: 244px;
-  display: grid;
-  place-items: center;
-  padding: var(--s5);
-  color: var(--text-3);
-  font-family: var(--f-mono);
-  font-size: 11px;
-  text-align: center;
-}
-
-@media (max-width: 860px) {
-  .rs-replay-shell {
-    grid-template-columns: 1fr;
-  }
-}
--- a/frontend/src/test/BriefingPage.test.tsx
+++ b/frontend/src/test/BriefingPage.test.tsx
@@ -0,0 +1,209 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { render, screen, waitFor, fireEvent, within } from '@testing-library/react'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { BriefingPage } from '../pages/BriefingPage'
+import type { ChampHubDriver, ChampHubTeam, ChampionshipHub, Meeting, NewsItem } from '../types'
+
+vi.mock('../api', () => ({
+  fetchNews: vi.fn(),
+  fetchNewsArticle: vi.fn(),
+  markNewsRead: vi.fn(),
+  fetchSeasons: vi.fn(),
+  fetchSeasonMeetings: vi.fn(),
+  fetchChampionshipHub: vi.fn(),
+}))
+
+import {
+  fetchNews,
+  fetchNewsArticle,
+  fetchSeasons,
+  fetchSeasonMeetings,
+  fetchChampionshipHub,
+  markNewsRead,
+} from '../api'
+
+const mockFetchNews = vi.mocked(fetchNews)
+const mockFetchNewsArticle = vi.mocked(fetchNewsArticle)
+const mockFetchSeasons = vi.mocked(fetchSeasons)
+const mockFetchSeasonMeetings = vi.mocked(fetchSeasonMeetings)
+const mockFetchHub = vi.mocked(fetchChampionshipHub)
+const mockMarkNewsRead = vi.mocked(markNewsRead)
+
+const bahrain: Meeting = {
+  meeting_key: 1,
+  meeting_name: 'Bahrain',
+  meeting_official_name: 'Bahrain GP',
+  location: 'Sakhir',
+  country_name: 'Bahrain',
+  country_code: 'BRN',
+  country_flag: '',
+  circuit_short_name: 'Sakhir',
+  date_start: '2025-03-14T00:00:00+00:00',
+  date_end: '2025-03-16T23:59:59+00:00',
+  year: 2025,
+}
+
+const monaco: Meeting = {
+  meeting_key: 2,
+  meeting_name: 'Monaco',
+  meeting_official_name: 'Monaco GP',
+  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-25T23:59:59+00:00',
+  year: 2025,
+}
+
+const drivers: ChampHubDriver[] = [
+  {
+    driver_number: 1,
+    name_acronym: 'VER',
+    full_name: 'Max Verstappen',
+    team_name: 'Red Bull',
+    team_colour: '3671c6',
+    points: 100,
+    position: 1,
+    wins: 3,
+    podiums: 5,
+    poles: 2,
+    form: [25, 18, 25],
+    cumulative: [25, 43, 68, 100],
+    teammate_wins: 4,
+    teammate_losses: 1,
+  },
+  {
+    driver_number: 4,
+    name_acronym: 'NOR',
+    full_name: 'Lando Norris',
+    team_name: 'McLaren',
+    team_colour: 'ff8000',
+    points: 80,
+    position: 2,
+    wins: 1,
+    podiums: 4,
+    poles: 1,
+    form: [18, 25, 18],
+    cumulative: [18, 36, 54, 80],
+    teammate_wins: 3,
+    teammate_losses: 2,
+  },
+]
+
+const teams: ChampHubTeam[] = [
+  { team_name: 'Red Bull', team_colour: '3671c6', points: 150, position: 1, wins: 4 },
+  { team_name: 'McLaren', team_colour: 'ff8000', points: 120, position: 2, wins: 2 },
+]
+
+const hub: ChampionshipHub = {
+  season: 2025,
+  round: 2,
+  total_rounds: 2,
+  rounds_left: 0,
+  last_race: 'Monaco GP',
+  round_labels: ['R1', 'R2'],
+  drivers,
+  teams,
+}
+
+const newsItems: NewsItem[] = [
+  {
+    source: 'autosport-f1',
+    title: 'Verstappen sets the pace in Bahrain',
+    url: 'https://example.com/bahrain-ver',
+    published_at: '2025-03-15T10:00:00Z',
+    fetched_at: '2025-03-15T11:00:00Z',
+    summary: 'Red Bull dominate opening practice',
+  },
+  {
+    source: 'racefans-f1',
+    title: 'Norris targets Monaco upgrade',
+    url: 'https://example.com/monaco-nor',
+    published_at: '2025-04-20T10:00:00Z',
+    fetched_at: '2025-04-20T11:00:00Z',
+    summary: 'McLaren bring new floor',
+  },
+  {
+    source: 'bbc-f1',
+    title: 'Undated paddock rumour',
+    url: 'https://example.com/undated',
+    fetched_at: '2025-04-21T11:00:00Z',
+  },
+]
+
+function renderPage() {
+  const queryClient = new QueryClient({
+    defaultOptions: { queries: { retry: false } },
+  })
+
+  return render(
+    <QueryClientProvider client={queryClient}>
+      <BriefingPage />
+    </QueryClientProvider>,
+  )
+}
+
+describe('BriefingPage digest layout', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.setSystemTime(new Date('2025-04-10T12:00:00Z'))
+    mockFetchSeasons.mockResolvedValue([2025])
+    mockFetchSeasonMeetings.mockResolvedValue([bahrain, monaco])
+    mockFetchHub.mockResolvedValue(hub)
+    mockFetchNews.mockResolvedValue(newsItems)
+    mockFetchNewsArticle.mockResolvedValue({ title: 'Article', content: '<p>Body</p>' })
+    mockMarkNewsRead.mockResolvedValue(undefined)
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('renders sticky since-last header, GP sections, and recent bucket', async () => {
+    renderPage()
+
+    await waitFor(() => {
+      expect(screen.getByTestId('digest-sticky-header')).toHaveTextContent('Since Bahrain')
+    })
+
+    expect(screen.getByTestId('digest-window-2')).toHaveTextContent('Monaco')
+    expect(screen.getByTestId('digest-window-1')).toHaveTextContent('Bahrain')
+    expect(screen.getByTestId('digest-recent')).toHaveTextContent('Undated paddock rumour')
+    expect(screen.getByText('Verstappen sets the pace in Bahrain')).toBeInTheDocument()
+    expect(screen.getByText('Norris targets Monaco upgrade')).toBeInTheDocument()
+  })
+
+  it('filters the digest when a tag chip is clicked', async () => {
+    renderPage()
+
+    await waitFor(() => {
+      expect(screen.getByTestId('digest-sticky-header')).toBeInTheDocument()
+    })
+
+    const sticky = screen.getByTestId('digest-sticky-header')
+    const norTag = within(sticky).getByRole('button', { name: /^NOR$/i })
+    fireEvent.click(norTag)
+
+    await waitFor(() => {
+      expect(screen.queryByText('Verstappen sets the pace in Bahrain')).not.toBeInTheDocument()
+    })
+    expect(screen.getByText('Norris targets Monaco upgrade')).toBeInTheDocument()
+    expect(screen.getByTestId('digest-filter-clear')).toBeInTheDocument()
+
+    fireEvent.click(screen.getByTestId('digest-filter-clear'))
+    await waitFor(() => {
+      expect(screen.getByText('Verstappen sets the pace in Bahrain')).toBeInTheDocument()
+    })
+  })
+
+  it('preserves category tabs', async () => {
+    renderPage()
+
+    await waitFor(() => {
+      expect(screen.getByRole('tab', { name: /All/i })).toBeInTheDocument()
+    })
+    expect(screen.getByRole('tab', { name: /News/i })).toBeInTheDocument()
+  })
+})
--- a/frontend/src/test/RaceStoryCanvas.test.tsx
+++ b/frontend/src/test/RaceStoryCanvas.test.tsx
@@ -1,135 +0,0 @@
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
-import { fireEvent, render, screen, waitFor } from '@testing-library/react'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { RaceStoryCanvas } from '../components/RaceStoryCanvas'
-import type { RaceHub, ReplayFramesResponse, TrackOutline } from '../types'
-
-vi.mock('../api', () => ({
-  fetchReplayFrames: vi.fn(),
-  fetchTrackOutline: vi.fn(),
-}))
-
-import { fetchReplayFrames, fetchTrackOutline } from '../api'
-
-const mockFetchReplayFrames = vi.mocked(fetchReplayFrames)
-const mockFetchTrackOutline = vi.mocked(fetchTrackOutline)
-
-const outline: TrackOutline = {
-  circuit_key: 1,
-  bounds: { minX: 0, maxX: 100, minY: 0, maxY: 100 },
-  points: [
-    { x: 0, y: 0 },
-    { x: 1, y: 0 },
-    { x: 1, y: 1 },
-  ],
-}
-
-const replay: ReplayFramesResponse = {
-  session_key: 99,
-  interval_ms: 5000,
-  start_time: '2025-05-25T13:00:00Z',
-  frames: [{ t: 0, cars: { '1': { x: 10, y: 20 } } }],
-}
-
-const raceHub: RaceHub = {
-  source: 'local',
-  session_key: 99,
-  datasets: {
-    positions: { status: 'available', source: 'local', count: 2 },
-  },
-  meeting: {
-    meeting_key: 1,
-    meeting_name: 'Monaco Grand Prix',
-    meeting_official_name: 'FORMULA 1 GRAND PRIX DE MONACO 2025',
-    location: 'Monaco',
-    country_name: 'Monaco',
-    country_code: 'MON',
-    country_flag: '',
-    circuit_key: 1,
-    circuit_short_name: 'Monaco',
-    date_start: '2025-05-23T00:00:00Z',
-    date_end: '2025-05-25T00:00:00Z',
-    year: 2025,
-  },
-  session: {
-    session_key: 99,
-    session_name: 'Race',
-    session_type: 'Race',
-    circuit_key: 1,
-    meeting_key: 1,
-    date_start: '2025-05-25T13:00:00Z',
-    date_end: '2025-05-25T15:00:00Z',
-    gmt_offset: '02:00:00',
-  },
-  drivers: [],
-  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: null,
-      gap_to_leader: null,
-      number_of_laps: 78,
-      points: 25,
-      session_key: 99,
-      meeting_key: 1,
-    },
-  ],
-  starting_grid: [
-    {
-      driver_number: 1,
-      position: 1,
-      name_acronym: 'VER',
-      full_name: 'Max Verstappen',
-      team_name: 'Red Bull Racing',
-      team_colour: '3671C6',
-      session_key: 99,
-      meeting_key: 1,
-      lap_duration: null,
-    },
-  ],
-  stints: [],
-  pit_stops: [],
-  positions: [
-    { session_key: 99, driver_number: 1, meeting_key: 1, date: '2025-05-25T13:00:00Z', position: 1 },
-    { session_key: 99, driver_number: 1, meeting_key: 1, date: '2025-05-25T13:05:00Z', position: 1 },
-  ],
-  race_control: [],
-  weather: [],
-  laps: [],
-  chapters: [],
-}
-
-function renderCanvas() {
-  const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
-  return render(
-    <QueryClientProvider client={queryClient}>
-      <RaceStoryCanvas data={raceHub} />
-    </QueryClientProvider>,
-  )
-}
-
-describe('RaceStoryCanvas replay map', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-    mockFetchReplayFrames.mockResolvedValue(replay)
-    mockFetchTrackOutline.mockResolvedValue(outline)
-  })
-
-  it('fetches replay frames lazily when the map panel opens', async () => {
-    renderCanvas()
-
-    expect(mockFetchReplayFrames).not.toHaveBeenCalled()
-    fireEvent.click(screen.getByRole('button', { name: 'Map' }))
-
-    await waitFor(() => expect(mockFetchReplayFrames).toHaveBeenCalledWith(99, 5000))
-    expect(mockFetchTrackOutline).toHaveBeenCalledWith(1, 2025)
-    expect(await screen.findByTestId('replay-track-map')).toBeInTheDocument()
-  })
-})
--- a/frontend/src/test/ReplayTrackMap.test.tsx
+++ b/frontend/src/test/ReplayTrackMap.test.tsx
@@ -1,56 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { render, screen } from '@testing-library/react'
-import { ReplayTrackMap } from '../components/ReplayTrackMap'
-import type { EnrichedResult, ReplayFramesResponse, TrackOutline } from '../types'
-
-const outline: TrackOutline = {
-  circuit_key: 1,
-  bounds: { minX: 0, maxX: 100, minY: 0, maxY: 100 },
-  points: [
-    { x: 0, y: 0 },
-    { x: 1, y: 0 },
-    { x: 1, y: 1 },
-  ],
-}
-
-const replay: ReplayFramesResponse = {
-  session_key: 99,
-  interval_ms: 5000,
-  start_time: '2025-05-25T13:00:00Z',
-  frames: [
-    { t: 0, cars: { '1': { x: 0, y: 0 } } },
-    { t: 5000, cars: { '1': { x: 50, y: 50 } } },
-  ],
-}
-
-const results: EnrichedResult[] = [
-  {
-    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: null,
-    gap_to_leader: null,
-    number_of_laps: 78,
-    points: 25,
-    session_key: 99,
-    meeting_key: 1,
-  },
-]
-
-describe('ReplayTrackMap', () => {
-  it('renders an empty state when replay frames are missing', () => {
-    render(<ReplayTrackMap outline={outline} replay={{ ...replay, frames: [] }} tMs={0} drivers={[]} results={results} />)
-    expect(screen.getByTestId('replay-track-map')).toHaveTextContent(/historical GPS unavailable/i)
-  })
-
-  it('renders car labels from result metadata', () => {
-    render(<ReplayTrackMap outline={outline} replay={replay} tMs={2500} drivers={[]} results={results} />)
-    expect(screen.getByLabelText(/VER replay position/i)).toBeInTheDocument()
-  })
-})
--- a/frontend/src/test/digest.test.ts
+++ b/frontend/src/test/digest.test.ts
@@ -0,0 +1,265 @@
+import { describe, it, expect } from 'vitest'
+import {
+  activeDigestWindow,
+  filterByTag,
+  groupByWindow,
+  gpWindows,
+  itemsForWindow,
+  sinceLastLabel,
+  sortWindowBucketsNewestFirst,
+  tagItems,
+  topTags,
+  windowForDate,
+} from '../lib/digest'
+import type { ChampHubDriver, ChampHubTeam, Meeting, NewsItem } from '../types'
+
+const meeting = (overrides: Partial<Meeting> = {}): Meeting => ({
+  meeting_key: 1,
+  meeting_name: 'Bahrain',
+  meeting_official_name: 'Bahrain GP',
+  location: 'Sakhir',
+  country_name: 'Bahrain',
+  country_code: 'BRN',
+  country_flag: '',
+  circuit_short_name: 'Sakhir',
+  date_start: '2025-03-14T00:00:00+00:00',
+  date_end: '2025-03-16T23:59:59+00:00',
+  year: 2025,
+  ...overrides,
+})
+
+const news = (overrides: Partial<NewsItem> = {}): NewsItem => ({
+  source: 'autosport-f1',
+  title: 'Headline',
+  url: `https://example.com/${Math.random()}`,
+  fetched_at: '2025-04-01T12:00:00Z',
+  ...overrides,
+})
+
+const driver = (over: Partial<ChampHubDriver>): ChampHubDriver => ({
+  driver_number: 1,
+  name_acronym: 'VER',
+  full_name: 'Max Verstappen',
+  team_name: 'Red Bull',
+  team_colour: '3671c6',
+  points: 100,
+  position: 1,
+  wins: 3,
+  podiums: 5,
+  poles: 2,
+  form: [25, 18, 25],
+  cumulative: [25, 43, 68, 100],
+  teammate_wins: 4,
+  teammate_losses: 1,
+  ...over,
+})
+
+const team = (over: Partial<ChampHubTeam>): ChampHubTeam => ({
+  team_name: 'Red Bull',
+  team_colour: '3671c6',
+  points: 150,
+  position: 1,
+  wins: 4,
+  ...over,
+})
+
+describe('gpWindows', () => {
+  const bahrain = meeting({ meeting_key: 1, meeting_name: 'Bahrain' })
+  const monaco = meeting({
+    meeting_key: 2,
+    meeting_name: 'Monaco',
+    date_start: '2025-05-23T00:00:00+00:00',
+    date_end: '2025-05-25T23:59:59+00:00',
+  })
+  const canada = meeting({
+    meeting_key: 3,
+    meeting_name: 'Canada',
+    date_start: '2025-06-13T00:00:00+00:00',
+    date_end: '2025-06-15T23:59:59+00:00',
+  })
+
+  it('derives inter-race windows mid-season', () => {
+    const now = new Date('2025-04-10T12:00:00Z')
+    const windows = gpWindows([bahrain, monaco, canada], now)
+
+    expect(windows).toHaveLength(3)
+    expect(windows[0].start).toBeNull()
+    expect(windows[0].end?.toISOString()).toBe(new Date('2025-05-23T00:00:00+00:00').toISOString())
+    expect(windows[1].start?.toISOString()).toBe(new Date('2025-03-16T23:59:59+00:00').toISOString())
+    expect(windows[1].end?.toISOString()).toBe(new Date('2025-06-13T00:00:00+00:00').toISOString())
+    expect(windows[2].start?.toISOString()).toBe(new Date('2025-05-25T23:59:59+00:00').toISOString())
+    expect(windows[2].end).toBeNull()
+  })
+
+  it('handles before the first race of the season', () => {
+    const now = new Date('2025-01-01T00:00:00Z')
+    const windows = gpWindows([bahrain, monaco], now)
+    expect(windows[0].start).toBeNull()
+    expect(activeDigestWindow(windows, [bahrain, monaco], now)?.meeting_name).toBe('Bahrain')
+    expect(sinceLastLabel([bahrain, monaco], now)).toBe('Before Bahrain')
+  })
+
+  it('handles after the final race of the season', () => {
+    const now = new Date('2025-12-01T00:00:00Z')
+    const windows = gpWindows([bahrain, monaco], now)
+    expect(activeDigestWindow(windows, [bahrain, monaco], now)?.meeting_name).toBe('Monaco')
+    expect(sinceLastLabel([bahrain, monaco], now)).toBe('Monaco')
+    expect(windows[1].end).toBeNull()
+  })
+})
+
+describe('groupByWindow', () => {
+  const bahrain = meeting({ meeting_key: 1 })
+  const monaco = meeting({
+    meeting_key: 2,
+    date_start: '2025-05-23T00:00:00+00:00',
+    date_end: '2025-05-25T23:59:59+00:00',
+  })
+  const windows = gpWindows([bahrain, monaco], new Date('2025-04-10T12:00:00Z'))
+
+  it('buckets dated items into the matching GP window', () => {
+    const items = [
+      news({ url: 'https://a', published_at: '2025-03-10T10:00:00Z', title: 'Pre-Bahrain' }),
+      news({ url: 'https://b', published_at: '2025-04-05T10:00:00Z', title: 'Between races' }),
+      news({ url: 'https://c', published_at: '2025-05-24T10:00:00Z', title: 'Monaco weekend' }),
+    ]
+
+    const grouped = groupByWindow(items, windows)
+    const bahrainItems = grouped.windows.find((entry) => entry.window.meeting_key === 1)?.items ?? []
+    const monacoItems = grouped.windows.find((entry) => entry.window.meeting_key === 2)?.items ?? []
+
+    expect(bahrainItems).toHaveLength(1)
+    expect(bahrainItems[0].title).toBe('Pre-Bahrain')
+    expect(monacoItems).toHaveLength(2)
+    expect(monacoItems.map((item) => item.title)).toEqual(['Between races', 'Monaco weekend'])
+  })
+
+  it('puts undated items in the recent bucket', () => {
+    const items = [
+      news({ url: 'https://u', title: 'Undated story' }),
+      news({ url: 'https://d', published_at: '2025-04-05T10:00:00Z' }),
+    ]
+    const grouped = groupByWindow(items, windows)
+    expect(grouped.recent).toHaveLength(1)
+    expect(grouped.recent[0].url).toBe('https://u')
+  })
+
+  it('sorts window buckets newest first for display', () => {
+    const items = [
+      news({ published_at: '2025-03-10T10:00:00Z' }),
+      news({ published_at: '2025-05-24T10:00:00Z' }),
+    ]
+    const grouped = groupByWindow(items, windows)
+    const sorted = sortWindowBucketsNewestFirst(grouped.windows)
+    expect(sorted[0].window.meeting_key).toBe(2)
+    expect(sorted[1].window.meeting_key).toBe(1)
+  })
+})
+
+describe('tagItems', () => {
+  const drivers = [
+    driver({ name_acronym: 'VER', full_name: 'Max Verstappen', team_name: 'Red Bull' }),
+    driver({
+      driver_number: 4,
+      name_acronym: 'NOR',
+      full_name: 'Lando Norris',
+      team_name: 'McLaren',
+      team_colour: 'ff8000',
+    }),
+  ]
+  const teams = [
+    team({ team_name: 'Red Bull' }),
+    team({ team_name: 'McLaren', team_colour: 'ff8000' }),
+  ]
+
+  it('tags drivers and teams case-insensitively', () => {
+    const [item] = tagItems(
+      [news({ title: 'ver leads mclaren in practice', summary: 'Norris close behind' })],
+      drivers,
+      teams,
+    )
+    const labels = item.tags.map((tag) => tag.label).sort()
+    expect(labels).toEqual(['McLaren', 'NOR', 'VER'])
+  })
+
+  it('returns no tags when nothing matches', () => {
+    const [item] = tagItems(
+      [news({ title: 'Generic paddock update' })],
+      drivers,
+      teams,
+    )
+    expect(item.tags).toEqual([])
+  })
+
+  it('prefers the longest overlapping match', () => {
+    const [item] = tagItems(
+      [news({ title: 'Max Verstappen extends championship lead' })],
+      drivers,
+      teams,
+    )
+    expect(item.tags).toHaveLength(1)
+    expect(item.tags[0].label).toBe('VER')
+  })
+
+  it('matches a driver last name inside prose', () => {
+    const [item] = tagItems(
+      [news({ title: 'Verstappen was untouchable in qualifying' })],
+      drivers,
+      teams,
+    )
+    expect(item.tags.some((tag) => tag.label === 'VER')).toBe(true)
+  })
+})
+
+describe('digest helpers', () => {
+  it('collects top tags by frequency', () => {
+    const tagged = tagItems(
+      [
+        news({ title: 'VER wins', url: 'https://a' }),
+        news({ title: 'VER dominates', url: 'https://b' }),
+        news({ title: 'Norris podium', url: 'https://c' }),
+      ],
+      [driver({}), driver({ driver_number: 4, name_acronym: 'NOR', full_name: 'Lando Norris', team_name: 'McLaren' })],
+      [team({}), team({ team_name: 'McLaren', team_colour: 'ff8000' })],
+    )
+    expect(topTags(tagged, 2).map((tag) => tag.label)).toEqual(['VER', 'NOR'])
+  })
+
+  it('filters items by tag key', () => {
+    const tagged = tagItems(
+      [
+        news({ title: 'VER wins', url: 'https://a' }),
+        news({ title: 'Neutral headline', url: 'https://b' }),
+      ],
+      [driver({})],
+      [team({})],
+    )
+    const filtered = filterByTag(tagged, 'driver:VER')
+    expect(filtered).toHaveLength(1)
+    expect(filtered[0].url).toBe('https://a')
+  })
+
+  it('selects items for the active digest window', () => {
+    const bahrain = meeting({ meeting_key: 1 })
+    const monaco = meeting({
+      meeting_key: 2,
+      date_start: '2025-05-23T00:00:00+00:00',
+      date_end: '2025-05-25T23:59:59+00:00',
+    })
+    const now = new Date('2025-04-10T12:00:00Z')
+    const windows = gpWindows([bahrain, monaco], now)
+    const active = activeDigestWindow(windows, [bahrain, monaco], now)
+    const tagged = tagItems(
+      [
+        news({ published_at: '2025-04-05T10:00:00Z', url: 'https://in' }),
+        news({ published_at: '2025-03-10T10:00:00Z', url: 'https://out' }),
+      ],
+      [],
+      [],
+    )
+    const inWindow = itemsForWindow(tagged, active)
+    expect(inWindow).toHaveLength(1)
+    expect(inWindow[0].url).toBe('https://in')
+    expect(windowForDate(windows, new Date('2025-04-05T10:00:00Z'))?.meeting_key).toBe(2)
+  })
+})
--- a/frontend/src/test/replay.test.ts
+++ b/frontend/src/test/replay.test.ts
@@ -1,33 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import type { ReplayFrame, TrackBounds } from '../types'
-import { interpolateReplayCars, lookupReplayFramePair, replayCarToSvg } from '../lib/replay'
-
-const frames: ReplayFrame[] = [
-  { t: 0, cars: { '1': { x: 0, y: 0 } } },
-  { t: 5000, cars: { '1': { x: 10, y: 20 }, '4': { x: 40, y: 80 } } },
-  { t: 10000, cars: { '1': { x: 20, y: 40 } } },
-]
-
-describe('replay helpers', () => {
-  it('looks up boundary frame pairs', () => {
-    expect(lookupReplayFramePair(frames, -1)).toEqual({ previous: frames[0], next: frames[0] })
-    expect(lookupReplayFramePair(frames, 10000)).toEqual({ previous: frames[2], next: frames[2] })
-    expect(lookupReplayFramePair([], 1000)).toEqual({ previous: null, next: null })
-  })
-
-  it('interpolates cars between frames and keeps one-sided samples visible', () => {
-    const cars = interpolateReplayCars(frames, 2500)
-    expect(cars['1']).toEqual({ x: 5, y: 10 })
-    expect(cars['4']).toEqual({ x: 40, y: 80 })
-  })
-
-  it('clamps interpolation outside the replay range', () => {
-    expect(interpolateReplayCars(frames, -500)['1']).toEqual({ x: 0, y: 0 })
-    expect(interpolateReplayCars(frames, 12000)['1']).toEqual({ x: 20, y: 40 })
-  })
-
-  it('maps replay GPS through the shared track-map coordinate transform', () => {
-    const bounds: TrackBounds = { minX: 0, maxX: 100, minY: 0, maxY: 200 }
-    expect(replayCarToSvg({ x: 50, y: 50 }, bounds)).toEqual({ x: 50, y: 75 })
-  })
-})
--- a/frontend/src/types.ts
+++ b/frontend/src/types.ts
@@ -360,23 +360,6 @@ export interface TrackOutline {
  bounds: TrackBounds
 }

-export interface ReplayCarPosition {
-  x: number
-  y: number
-}
-
-export interface ReplayFrame {
-  t: number
-  cars: Record<string, ReplayCarPosition>
-}
-
-export interface ReplayFramesResponse {
-  session_key: number
-  interval_ms: number
-  start_time: string
-  frames: ReplayFrame[]
-}
-
 export interface ChampHubDriver {
  driver_number: number
  name_acronym: string
--- a/internal/web/replay.go
+++ b/internal/web/replay.go
@@ -1,259 +0,0 @@
-package web
-
-import (
-	"context"
-	"errors"
-	"math"
-	"net/http"
-	"sort"
-	"strconv"
-	"sync"
-	"time"
-
-	"github.com/AmanTahiliani/box-box/internal/models"
-)
-
-const (
-	defaultReplayIntervalMS = 5000
-	maxReplayFrames         = 3000
-	replayFetchConcurrency  = 4
-)
-
-type replayDataClient interface {
-	GetDriversForSession(sessionKey int) ([]models.Driver, error)
-	GetLocation(sessionKey, driverNumber int) ([]models.Location, error)
-}
-
-type replayFramesResponse struct {
-	SessionKey int           `json:"session_key"`
-	Interval   int           `json:"interval_ms"`
-	StartTime  string        `json:"start_time"`
-	Frames     []replayFrame `json:"frames"`
-}
-
-type replayFrame struct {
-	T    int64                `json:"t"`
-	Cars map[string]replayCar `json:"cars"`
-}
-
-type replayCar struct {
-	X float64 `json:"x"`
-	Y float64 `json:"y"`
-}
-
-func (s *Server) handleReplayFrames(w http.ResponseWriter, r *http.Request) {
-	sessionKey, err := strconv.Atoi(r.URL.Query().Get("session_key"))
-	if err != nil || sessionKey == 0 {
-		http.Error(w, "session_key required", http.StatusBadRequest)
-		return
-	}
-
-	intervalMS := defaultReplayIntervalMS
-	rawInterval := r.URL.Query().Get("interval_ms")
-	if rawInterval != "" {
-		parsed, err := strconv.Atoi(rawInterval)
-		if err != nil {
-			http.Error(w, "invalid interval_ms", http.StatusBadRequest)
-			return
-		}
-		if parsed > intervalMS {
-			intervalMS = parsed
-		}
-	}
-
-	resp, err := assembleReplayFrames(r.Context(), s.client, sessionKey, intervalMS)
-	if err != nil {
-		writeError(w, err, http.StatusInternalServerError, s.client.LastResponseWasStale())
-		return
-	}
-	writeJSON(w, resp)
-}
-
-func assembleReplayFrames(ctx context.Context, client replayDataClient, sessionKey, intervalMS int) (replayFramesResponse, error) {
-	if intervalMS < defaultReplayIntervalMS {
-		intervalMS = defaultReplayIntervalMS
-	}
-
-	resp := replayFramesResponse{
-		SessionKey: sessionKey,
-		Interval:   intervalMS,
-		Frames:     []replayFrame{},
-	}
-
-	drivers, err := client.GetDriversForSession(sessionKey)
-	if err != nil {
-		return resp, err
-	}
-
-	driverNumbers := uniqueDriverNumbers(drivers)
-	if len(driverNumbers) == 0 {
-		return resp, nil
-	}
-
-	series, err := fetchReplayLocationSeries(ctx, client, sessionKey, driverNumbers)
-	if err != nil && len(series) == 0 {
-		return resp, err
-	}
-
-	start, ok := earliestReplayLocationTime(series)
-	if !ok {
-		return resp, nil
-	}
-	resp.StartTime = start.Format(time.RFC3339Nano)
-	resp.Frames = snapReplayFrames(series, start, intervalMS)
-	return resp, nil
-}
-
-func uniqueDriverNumbers(drivers []models.Driver) []int {
-	seen := make(map[int]bool, len(drivers))
-	numbers := make([]int, 0, len(drivers))
-	for _, driver := range drivers {
-		if driver.DriverNumber <= 0 || seen[driver.DriverNumber] {
-			continue
-		}
-		seen[driver.DriverNumber] = true
-		numbers = append(numbers, driver.DriverNumber)
-	}
-	sort.Ints(numbers)
-	return numbers
-}
-
-func fetchReplayLocationSeries(ctx context.Context, client replayDataClient, sessionKey int, driverNumbers []int) (map[int][]models.Location, error) {
-	type result struct {
-		driver int
-		locs   []models.Location
-		err    error
-	}
-
-	sem := make(chan struct{}, replayFetchConcurrency)
-	results := make(chan result, len(driverNumbers))
-	var wg sync.WaitGroup
-
-	for _, driverNumber := range driverNumbers {
-		driverNumber := driverNumber
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			select {
-			case sem <- struct{}{}:
-				defer func() { <-sem }()
-			case <-ctx.Done():
-				results <- result{driver: driverNumber, err: ctx.Err()}
-				return
-			}
-
-			locs, err := client.GetLocation(sessionKey, driverNumber)
-			results <- result{driver: driverNumber, locs: locs, err: err}
-		}()
-	}
-
-	wg.Wait()
-	close(results)
-
-	series := make(map[int][]models.Location, len(driverNumbers))
-	var joined error
-	for result := range results {
-		if result.err != nil {
-			joined = errors.Join(joined, result.err)
-			continue
-		}
-		if len(result.locs) > 0 {
-			series[result.driver] = result.locs
-		}
-	}
-	return series, joined
-}
-
-func earliestReplayLocationTime(series map[int][]models.Location) (time.Time, bool) {
-	var start time.Time
-	for _, locs := range series {
-		for _, loc := range locs {
-			t, err := time.Parse(time.RFC3339Nano, loc.Date)
-			if err != nil {
-				continue
-			}
-			if start.IsZero() || t.Before(start) {
-				start = t
-			}
-		}
-	}
-	if start.IsZero() {
-		return time.Time{}, false
-	}
-	return start, true
-}
-
-func snapReplayFrames(series map[int][]models.Location, start time.Time, intervalMS int) []replayFrame {
-	type accumulator struct {
-		t       int64
-		cars    map[string]replayCar
-		nearest map[string]int64
-	}
-
-	interval := int64(intervalMS)
-	framesByIndex := make(map[int]*accumulator)
-
-	for driverNumber, locs := range series {
-		driverKey := strconv.Itoa(driverNumber)
-		for _, loc := range locs {
-			if !isFiniteFloat(loc.X) || !isFiniteFloat(loc.Y) {
-				continue
-			}
-			t, err := time.Parse(time.RFC3339Nano, loc.Date)
-			if err != nil {
-				continue
-			}
-			offset := t.Sub(start).Milliseconds()
-			if offset < 0 {
-				continue
-			}
-			index := int((offset + interval/2) / interval)
-			if index < 0 || index >= maxReplayFrames {
-				continue
-			}
-			frameT := int64(index) * interval
-			distance := absInt64(offset - frameT)
-
-			acc, ok := framesByIndex[index]
-			if !ok {
-				acc = &accumulator{
-					t:       frameT,
-					cars:    make(map[string]replayCar),
-					nearest: make(map[string]int64),
-				}
-				framesByIndex[index] = acc
-			}
-			if prev, ok := acc.nearest[driverKey]; ok && prev <= distance {
-				continue
-			}
-			acc.nearest[driverKey] = distance
-			acc.cars[driverKey] = replayCar{X: loc.X, Y: loc.Y}
-		}
-	}
-
-	indexes := make([]int, 0, len(framesByIndex))
-	for index, acc := range framesByIndex {
-		if len(acc.cars) > 0 {
-			indexes = append(indexes, index)
-		}
-	}
-	sort.Ints(indexes)
-
-	frames := make([]replayFrame, 0, len(indexes))
-	for _, index := range indexes {
-		acc := framesByIndex[index]
-		frames = append(frames, replayFrame{T: acc.t, Cars: acc.cars})
-	}
-	return frames
-}
-
-func absInt64(v int64) int64 {
-	if v < 0 {
-		return -v
-	}
-	return v
-}
-
-func isFiniteFloat(v float64) bool {
-	return !math.IsNaN(v) && !math.IsInf(v, 0)
-}
--- a/internal/web/replay_test.go
+++ b/internal/web/replay_test.go
@@ -1,181 +0,0 @@
-package web
-
-import (
-	"context"
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/AmanTahiliani/box-box/internal/models"
-)
-
-type fakeReplayClient struct {
-	drivers []models.Driver
-	locs    map[int][]models.Location
-	err     error
-
-	mu          sync.Mutex
-	inFlight    int
-	maxInFlight int
-	delay       time.Duration
-}
-
-func (f *fakeReplayClient) GetDriversForSession(sessionKey int) ([]models.Driver, error) {
-	if f.err != nil {
-		return nil, f.err
-	}
-	return f.drivers, nil
-}
-
-func (f *fakeReplayClient) GetLocation(sessionKey, driverNumber int) ([]models.Location, error) {
-	f.mu.Lock()
-	f.inFlight++
-	if f.inFlight > f.maxInFlight {
-		f.maxInFlight = f.inFlight
-	}
-	f.mu.Unlock()
-
-	if f.delay > 0 {
-		time.Sleep(f.delay)
-	}
-
-	f.mu.Lock()
-	f.inFlight--
-	f.mu.Unlock()
-
-	return f.locs[driverNumber], nil
-}
-
-func TestAssembleReplayFramesSnapsNearestSamplesAndOmitsEmptyDrivers(t *testing.T) {
-	start := time.Date(2025, 5, 25, 13, 0, 0, 0, time.UTC)
-	client := &fakeReplayClient{
-		drivers: []models.Driver{
-			{DriverNumber: 1},
-			{DriverNumber: 4},
-			{DriverNumber: 16},
-		},
-		locs: map[int][]models.Location{
-			1: {
-				{Date: start.Add(1 * time.Second).Format(time.RFC3339Nano), X: 10, Y: 20},
-				{Date: start.Add(4 * time.Second).Format(time.RFC3339Nano), X: 40, Y: 80},
-				{Date: start.Add(6 * time.Second).Format(time.RFC3339Nano), X: 60, Y: 120},
-			},
-			4: {
-				{Date: start.Add(5 * time.Second).Format(time.RFC3339Nano), X: 100, Y: 200},
-			},
-			16: {},
-		},
-	}
-
-	resp, err := assembleReplayFrames(context.Background(), client, 99, 5000)
-	if err != nil {
-		t.Fatalf("assembleReplayFrames() error = %v", err)
-	}
-	if resp.SessionKey != 99 || resp.Interval != 5000 {
-		t.Fatalf("response metadata = %+v", resp)
-	}
-	if resp.StartTime != start.Add(1*time.Second).Format(time.RFC3339Nano) {
-		t.Fatalf("start_time = %q", resp.StartTime)
-	}
-	if len(resp.Frames) != 2 {
-		t.Fatalf("frames len = %d, want 2: %+v", len(resp.Frames), resp.Frames)
-	}
-	if _, ok := resp.Frames[0].Cars["16"]; ok {
-		t.Fatalf("empty driver included in frame: %+v", resp.Frames[0].Cars)
-	}
-	if got := resp.Frames[0].Cars["1"]; got.X != 10 || got.Y != 20 {
-		t.Fatalf("frame 0 car 1 = %+v, want first nearest sample", got)
-	}
-	if got := resp.Frames[1].Cars["1"]; got.X != 60 || got.Y != 120 {
-		t.Fatalf("frame 1 car 1 = %+v, want later nearest sample", got)
-	}
-	if got := resp.Frames[1].Cars["4"]; got.X != 100 || got.Y != 200 {
-		t.Fatalf("frame 1 car 4 = %+v", got)
-	}
-}
-
-func TestAssembleReplayFramesCapsFrameCount(t *testing.T) {
-	start := time.Date(2025, 5, 25, 13, 0, 0, 0, time.UTC)
-	locs := make([]models.Location, maxReplayFrames+250)
-	for i := range locs {
-		locs[i] = models.Location{
-			Date: start.Add(time.Duration(i*defaultReplayIntervalMS) * time.Millisecond).Format(time.RFC3339Nano),
-			X:    float64(i),
-			Y:    float64(i * 2),
-		}
-	}
-	client := &fakeReplayClient{
-		drivers: []models.Driver{{DriverNumber: 1}},
-		locs:    map[int][]models.Location{1: locs},
-	}
-
-	resp, err := assembleReplayFrames(context.Background(), client, 99, defaultReplayIntervalMS)
-	if err != nil {
-		t.Fatalf("assembleReplayFrames() error = %v", err)
-	}
-	if len(resp.Frames) > maxReplayFrames {
-		t.Fatalf("frames len = %d, want <= %d", len(resp.Frames), maxReplayFrames)
-	}
-	if len(resp.Frames) != maxReplayFrames {
-		t.Fatalf("frames len = %d, want hard cap %d", len(resp.Frames), maxReplayFrames)
-	}
-}
-
-func TestAssembleReplayFramesBoundsLocationFanOut(t *testing.T) {
-	drivers := make([]models.Driver, 10)
-	locs := make(map[int][]models.Location, len(drivers))
-	now := time.Date(2025, 5, 25, 13, 0, 0, 0, time.UTC)
-	for i := range drivers {
-		number := i + 1
-		drivers[i] = models.Driver{DriverNumber: number}
-		locs[number] = []models.Location{{Date: now.Format(time.RFC3339Nano), X: float64(number), Y: float64(number)}}
-	}
-	client := &fakeReplayClient{
-		drivers: drivers,
-		locs:    locs,
-		delay:   5 * time.Millisecond,
-	}
-
-	if _, err := assembleReplayFrames(context.Background(), client, 99, defaultReplayIntervalMS); err != nil {
-		t.Fatalf("assembleReplayFrames() error = %v", err)
-	}
-	if client.maxInFlight > replayFetchConcurrency {
-		t.Fatalf("max in-flight location calls = %d, want <= %d", client.maxInFlight, replayFetchConcurrency)
-	}
-}
-
-func TestHandleReplayFramesValidatesParamsAndFloorsInterval(t *testing.T) {
-	srv := testServer(t, nil)
-
-	req := httptest.NewRequest(http.MethodGet, "/api/v1/replay/frames", nil)
-	rec := httptest.NewRecorder()
-	srv.handleReplayFrames(rec, req)
-	if rec.Code != http.StatusBadRequest {
-		t.Fatalf("missing session_key status = %d, want 400", rec.Code)
-	}
-
-	req = httptest.NewRequest(http.MethodGet, "/api/v1/replay/frames?session_key=1&interval_ms=nope", nil)
-	rec = httptest.NewRecorder()
-	srv.handleReplayFrames(rec, req)
-	if rec.Code != http.StatusBadRequest {
-		t.Fatalf("invalid interval status = %d, want 400", rec.Code)
-	}
-
-	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)
-	if err != nil {
-		t.Fatalf("assembleReplayFrames() error = %v", err)
-	}
-	body, err := json.Marshal(resp)
-	if err != nil || len(body) == 0 {
-		t.Fatalf("marshal response = %d bytes, %v", len(body), err)
-	}
-	if resp.Interval != defaultReplayIntervalMS {
-		t.Fatalf("interval = %d, want floor %d", resp.Interval, defaultReplayIntervalMS)
-	}
-}
--- a/internal/web/server.go
+++ b/internal/web/server.go
@@ -75,7 +75,6 @@ func (s *Server) routes() (http.Handler, error) {
 	mux.HandleFunc("/api/v1/grid", s.handleGrid)
 	mux.HandleFunc("/api/v1/laps/comparison", s.handleLapsComparison)
 	mux.HandleFunc("/api/v1/laps", s.handleLaps)
-	mux.HandleFunc("/api/v1/replay/frames", s.handleReplayFrames)
 	mux.HandleFunc("/api/v1/weather", s.handleWeather)
 	mux.HandleFunc("/api/v1/race-control", s.handleRaceControl)
 	mux.HandleFunc("/api/v1/telemetry", s.handleTelemetry)