fix(race-hub): consume canonical weekend context for #75 review

Address PR #82 review blockers: drop the competing /weekend
default_analysis_session resolver, land bare /race-hub via
/api/v1/weekend-context, derive Live/preparing/partial/unavailable from
authoritative context with a moving clock, hide Local Coverage behind
Diagnostics, isolate the future-session fixture from the shared seed,
and strengthen return-to-Weekend context coverage.

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

internal/query/navigation.go

@@ -3,16 +3,11 @@ package query
 import (
 	"database/sql"
 	"errors"
-	"time"
 
 	"github.com/AmanTahiliani/box-box/internal/models"
 	"github.com/AmanTahiliani/box-box/internal/store"
 )
 
-// weekendNow is the clock used to decide whether a session has started. It is a
-// package var so tests can pin it deterministically.
-var weekendNow = time.Now
-
 // ErrMeetingNotFound is returned when a meeting is not in the local store.
 var ErrMeetingNotFound = errors.New("meeting not found")
 
@@ -24,16 +19,14 @@ type WeekendSession struct {
 }
 
 // Weekend is the local-first read model for one race weekend.
+// Fan-facing default analysis resolution lives on /api/v1/weekend-context
+// (DefaultAnalysisSession); this payload only supplies meeting rail + coverage.
 type Weekend struct {
 	Source            string           `json:"source"`
 	MeetingKey        int              `json:"meeting_key"`
 	Meeting           models.Meeting   `json:"meeting"`
 	Sessions          []WeekendSession `json:"sessions"`
 	DefaultSessionKey int              `json:"default_session_key,omitempty"`
-	// DefaultAnalysisSession is the session a fan-facing default landing should
-	// open. Unlike DefaultSessionKey it never resolves to a future session, so
-	// bare /race-hub never renders empty post-session analysis.
-	DefaultAnalysisSession int `json:"default_analysis_session,omitempty"`
 }
 
 // ListSeasons returns years with ingested meetings, newest first.
@@ -94,7 +87,6 @@ func (s *Service) GetWeekend(meetingKey int) (Weekend, error) {
 		out.Source = weekendSource(out.Sessions)
 	}
 	out.DefaultSessionKey = pickDefaultSession(out.Sessions)
-	out.DefaultAnalysisSession = pickDefaultAnalysisSession(out.Sessions, weekendNow())
 	return out, nil
 }
 
@@ -151,51 +143,6 @@ func pickDefaultSession(sessions []WeekendSession) int {
 	return sessions[bestIdx].Session.SessionKey
 }
 
-// pickDefaultAnalysisSession chooses the session a fan should land on by default.
-// It never returns a future session: among sessions that have already started
-// (or whose start time is unknown) it prefers the one with the richest local
-// dataset coverage, breaking ties toward the later session. When every session
-// is still upcoming it returns 0 so callers render a pre-session view instead of
-// empty analysis.
-func pickDefaultAnalysisSession(sessions []WeekendSession, now time.Time) int {
-	bestKey := 0
-	bestScore := -1
-	var bestStart time.Time
-	for _, sess := range sessions {
-		start, ok := parseSessionStart(sess.Session.DateStart)
-		// Skip sessions that are clearly in the future; unknown start times are
-		// treated as eligible so historical data without timestamps still works.
-		if ok && start.After(now) {
-			continue
-		}
-		score := datasetScore(sess.Datasets)
-		if score > bestScore || (score == bestScore && ok && start.After(bestStart)) {
-			bestScore = score
-			bestKey = sess.Session.SessionKey
-			if ok {
-				bestStart = start
-			}
-		}
-	}
-	return bestKey
-}
-
-func parseSessionStart(value string) (time.Time, bool) {
-	if value == "" {
-		return time.Time{}, false
-	}
-	if t, err := time.Parse(time.RFC3339, value); err == nil {
-		return t, true
-	}
-	if t, err := time.Parse("2006-01-02T15:04:05", value); err == nil {
-		return t, true
-	}
-	if t, err := time.Parse("2006-01-02", value[:min(len(value), 10)]); err == nil {
-		return t, true
-	}
-	return time.Time{}, false
-}
-
 func datasetScore(datasets map[string]DatasetInfo) int {
 	score := 0
 	for _, info := range datasets {

internal/query/query_test.go

@@ -5,7 +5,6 @@ import (
 	"errors"
 	"path/filepath"
 	"testing"
-	"time"
 
 	"github.com/AmanTahiliani/box-box/internal/models"
 	"github.com/AmanTahiliani/box-box/internal/store"
@@ -377,88 +376,6 @@ func TestGetWeekendWithSessions(t *testing.T) {
 	}
 }
 
-func TestPickDefaultAnalysisSessionSkipsFuture(t *testing.T) {
-	now := mustTime(t, "2025-05-24T18:00:00Z")
-	sessions := []WeekendSession{
-		{ // completed qualifying, partial coverage
-			Session:  models.Session{SessionKey: 100, DateStart: "2025-05-24T14:00:00+00:00"},
-			Datasets: map[string]DatasetInfo{"results": availableLocal(1)},
-		},
-		{ // future race with the richest coverage — must NOT be selected
-			Session: models.Session{SessionKey: 200, DateStart: "2025-05-25T13:00:00+00:00"},
-			Datasets: map[string]DatasetInfo{
-				"results": availableLocal(1),
-				"laps":    availableLocal(1),
-				"stints":  availableLocal(1),
-			},
-		},
-	}
-
-	got := pickDefaultAnalysisSession(sessions, now)
-	if got != 100 {
-		t.Fatalf("pickDefaultAnalysisSession() = %d, want 100 (never a future session)", got)
-	}
-}
-
-func TestPickDefaultAnalysisSessionAllFuture(t *testing.T) {
-	now := mustTime(t, "2025-05-20T00:00:00Z")
-	sessions := []WeekendSession{
-		{Session: models.Session{SessionKey: 100, DateStart: "2025-05-24T14:00:00+00:00"}},
-		{Session: models.Session{SessionKey: 200, DateStart: "2025-05-25T13:00:00+00:00"}},
-	}
-
-	if got := pickDefaultAnalysisSession(sessions, now); got != 0 {
-		t.Fatalf("pickDefaultAnalysisSession() = %d, want 0 (everything upcoming)", got)
-	}
-}
-
-func TestPickDefaultAnalysisSessionPrefersRichestCompleted(t *testing.T) {
-	now := mustTime(t, "2025-05-26T00:00:00Z")
-	sessions := []WeekendSession{
-		{
-			Session:  models.Session{SessionKey: 100, DateStart: "2025-05-24T14:00:00+00:00"},
-			Datasets: map[string]DatasetInfo{"results": availableLocal(1)},
-		},
-		{
-			Session: models.Session{SessionKey: 200, DateStart: "2025-05-25T13:00:00+00:00"},
-			Datasets: map[string]DatasetInfo{
-				"results": availableLocal(1),
-				"laps":    availableLocal(1),
-			},
-		},
-	}
-
-	if got := pickDefaultAnalysisSession(sessions, now); got != 200 {
-		t.Fatalf("pickDefaultAnalysisSession() = %d, want 200 (richest completed)", got)
-	}
-}
-
-func TestGetWeekendSetsDefaultAnalysisSession(t *testing.T) {
-	prev := weekendNow
-	weekendNow = func() time.Time { return mustTime(t, "2025-05-26T00:00:00Z") }
-	t.Cleanup(func() { weekendNow = prev })
-
-	svc := openTestService(t)
-	seedRaceHubData(t, svc.store)
-
-	weekend, err := svc.GetWeekend(1229)
-	if err != nil {
-		t.Fatalf("GetWeekend() error = %v", err)
-	}
-	if weekend.DefaultAnalysisSession != 9472 {
-		t.Fatalf("DefaultAnalysisSession = %d, want 9472", weekend.DefaultAnalysisSession)
-	}
-}
-
-func mustTime(t *testing.T, value string) time.Time {
-	t.Helper()
-	parsed, err := time.Parse(time.RFC3339, value)
-	if err != nil {
-		t.Fatalf("parse time %q: %v", value, err)
-	}
-	return parsed
-}
-
 func TestGetChampionshipInputsIncludesSprintPoints(t *testing.T) {
 	// Regression for #57: Race-only aggregation dropped Sprint points.
 	// Setup: same meeting 1229 has Race (9472) 25pts + Sprint (9473) 8pts => total 33.