fix(#74): settle on just-finished session and coherent feed health

Prefer previous_completed_session for Live settling link/poll/readiness so an
older ready default cannot short-circuit handoff; show reconnecting when phase
is disconnected even if browser SSE stays open; refresh Live visuals and add
active responsive snapshots against the Weekend shell.

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

frontend/src/test/LiveHandoff.test.tsx

@@ -1,6 +1,11 @@
 import { render, screen } from '@testing-library/react'
 import { describe, expect, it, vi } from 'vitest'
-import { LiveHandoff, analysisIsReady } from '../components/live/LiveHandoff'
+import {
+  LiveHandoff,
+  analysisIsReady,
+  handoffAnalysisSession,
+  shouldPollHandoffAnalysis,
+} from '../components/live/LiveHandoff'
 import type { LiveTimingRow } from '../lib/live'
 import type { ContextSession, WeekendContext } from '../types'
 
@@ -54,6 +59,18 @@ const baseContext: WeekendContext = {
   total_championship_rounds: 1,
 }
 
+/** Canonical contract: archive-only just-finished Race vs older ready Practice. */
+function archiveOnlySettlingContext(previousAnalysis: string): WeekendContext {
+  return {
+    ...baseContext,
+    // Older already-ingested session remains the default analysis target.
+    default_analysis_session: contextSession(10, 'Practice 1', 'complete'),
+    // Just-finished Race is archive-complete but not yet analysis-ready.
+    previous_completed_session: contextSession(99, 'Race', previousAnalysis),
+    next_session: contextSession(12, 'Qualifying', 'not_applicable'),
+  }
+}
+
 const rows: LiveTimingRow[] = [
   { RacingNumber: '1', Position: 1, Driver: { RacingNumber: '1', Position: 1 } as never, Info: { Tla: 'VER' } as never },
   { RacingNumber: '4', Position: 2, Driver: { RacingNumber: '4', Position: 2 } as never, Info: { Tla: 'NOR' } as never },
@@ -68,13 +85,51 @@ describe('analysisIsReady', () => {
   })
 })
 
+describe('handoffAnalysisSession', () => {
+  it('settling prefers previous_completed_session over an older default', () => {
+    const ctx = archiveOnlySettlingContext('pending')
+    const analysis = handoffAnalysisSession(ctx, 'settling')
+    expect(analysis?.session.session_key).toBe(99)
+    expect(analysis?.session.session_name).toBe('Race')
+    expect(analysisIsReady(analysis)).toBe(false)
+  })
+
+  it('inactive prefers default_analysis_session (shared analysisSessionKey)', () => {
+    const ctx = archiveOnlySettlingContext('pending')
+    const analysis = handoffAnalysisSession(ctx, 'inactive')
+    expect(analysis?.session.session_key).toBe(10)
+    expect(analysis?.session.session_name).toBe('Practice 1')
+  })
+
+  it('settling falls back to default when previous is absent', () => {
+    const ctx = {
+      ...baseContext,
+      default_analysis_session: contextSession(11, 'Race', 'pending'),
+    }
+    expect(handoffAnalysisSession(ctx, 'settling')?.session.session_key).toBe(11)
+  })
+})
+
+describe('shouldPollHandoffAnalysis', () => {
+  it('keeps polling when previous is pending even if default is already complete', () => {
+    expect(shouldPollHandoffAnalysis(archiveOnlySettlingContext('pending'))).toBe(true)
+  })
+
+  it('stops polling once the just-finished previous session is ready', () => {
+    expect(shouldPollHandoffAnalysis(archiveOnlySettlingContext('complete'))).toBe(false)
+  })
+})
+
 describe('LiveHandoff settling', () => {
   it('shows SESSION SETTLING with a pending analysis action while ingesting', () => {
     render(
       <LiveHandoff
         phase="settling"
         transport="connected"
-        context={{ ...baseContext, default_analysis_session: contextSession(11, 'Race', 'pending') }}
+        context={{
+          ...baseContext,
+          previous_completed_session: contextSession(11, 'Race', 'pending'),
+        }}
         rows={rows}
         capturedAt="2026-07-05T16:02:00Z"
         hasArchive
@@ -94,12 +149,37 @@ describe('LiveHandoff settling', () => {
     expect(screen.getByTestId('live-handoff-snapshot')).toHaveTextContent('VER')
   })
 
+  it('links/labels/readiness follow archive-only previous, not an older ready default', () => {
+    render(
+      <LiveHandoff
+        phase="settling"
+        transport="connected"
+        context={archiveOnlySettlingContext('pending')}
+        rows={rows}
+        capturedAt="2026-07-05T16:02:00Z"
+        hasArchive
+        onViewArchive={vi.fn()}
+      />,
+    )
+
+    const action = screen.getByTestId('live-handoff-analysis')
+    expect(action).toHaveAttribute('href', '/race-hub?session_key=99')
+    expect(action).toHaveAttribute('data-ready', 'false')
+    expect(action).toHaveTextContent('Open Race analysis')
+    expect(action).toHaveTextContent(/Settling — analysis will fill in as data ingests/i)
+    expect(action).not.toHaveTextContent('Practice 1')
+    expect(action).not.toHaveTextContent(/full timing, strategy & story ready/i)
+  })
+
   it('flips to analysis-ready once local ingestion completes', () => {
     render(
       <LiveHandoff
         phase="settling"
         transport="connected"
-        context={{ ...baseContext, default_analysis_session: contextSession(11, 'Race', 'complete') }}
+        context={{
+          ...baseContext,
+          previous_completed_session: contextSession(11, 'Race', 'complete'),
+        }}
         rows={rows}
         capturedAt="2026-07-05T16:02:00Z"
         hasArchive={false}
@@ -116,7 +196,10 @@ describe('LiveHandoff settling', () => {
       <LiveHandoff
         phase="settling"
         transport="connected"
-        context={{ ...baseContext, default_analysis_session: contextSession(11, 'Race', 'complete') }}
+        context={{
+          ...baseContext,
+          previous_completed_session: contextSession(11, 'Race', 'complete'),
+        }}
         rows={rows}
         capturedAt="2026-07-05T16:02:00Z"
         hasArchive

frontend/src/test/LiveTimingPage.test.tsx

@@ -103,7 +103,7 @@ function weekendContext(localAnalysis: string): WeekendContext {
       date_end: '2026-07-05T16:00:00Z',
       year: 2026,
     },
-    default_analysis_session: {
+    previous_completed_session: {
       session: {
         session_key: 99,
         session_name: 'Race',
@@ -128,6 +128,33 @@ function weekendContext(localAnalysis: string): WeekendContext {
   }
 }
 
+/** Just-finished archive-only Race + older already-ready Practice default. */
+function archiveOnlySettlingContext(previousAnalysis: string): WeekendContext {
+  return {
+    ...weekendContext(previousAnalysis),
+    default_analysis_session: {
+      session: {
+        session_key: 10,
+        session_name: 'Practice 1',
+        session_type: 'Practice',
+        meeting_key: 1,
+        date_start: '2026-07-04T12:00:00Z',
+        date_end: '2026-07-04T13:00:00Z',
+        gmt_offset: '',
+      },
+      availability: {
+        schedule: 'available',
+        live_transport: 'unknown',
+        live_session: 'inactive',
+        archive: 'available',
+        local_analysis: 'complete',
+        freshness: 'fresh',
+        limitations: [],
+      },
+    },
+  }
+}
+
 function renderPage(
   response: LiveStateResponse,
   context?: WeekendContext,
@@ -191,7 +218,7 @@ describe('LiveTimingPage', () => {
     const settling = await screen.findByTestId('live-settling')
     expect(settling).toBeInTheDocument()
     expect(screen.getByTestId('live-page')).toHaveAttribute('data-phase', 'settling')
-    // Canonical default-analysis session drives the primary action target.
+    // Just-finished previous_completed_session drives the primary action target.
     await waitFor(() =>
       expect(screen.getByTestId('live-handoff-analysis')).toHaveAttribute(
         'href',
@@ -202,6 +229,44 @@ describe('LiveTimingPage', () => {
     expect(screen.queryByText('Timing Tower')).not.toBeInTheDocument()
   })
 
+  it('settles against archive-only previous, not an older ready default_analysis_session', async () => {
+    vi.useFakeTimers({ shouldAdvanceTime: true })
+    mockFetchWeekendContext
+      .mockResolvedValueOnce(archiveOnlySettlingContext('pending'))
+      .mockResolvedValue(archiveOnlySettlingContext('complete'))
+
+    renderPage(
+      {
+        is_live: false,
+        data: null,
+        last_snapshot: { ...raceSnapshot, SessionStatus: 'Finished' },
+        last_snapshot_at: '2026-07-05T16:02:00Z',
+      },
+      undefined,
+      { setWeekendContext: false },
+    )
+
+    const action = await screen.findByTestId('live-handoff-analysis')
+    expect(action).toHaveAttribute('href', '/race-hub?session_key=99')
+    expect(action).toHaveAttribute('data-ready', 'false')
+    expect(action).toHaveTextContent('Open Race analysis')
+    expect(action).not.toHaveTextContent('Practice 1')
+
+    // Older default is already complete — polling must continue for previous.
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(WEEKEND_CONTEXT_POLL_MS + 500)
+    })
+
+    await waitFor(() =>
+      expect(screen.getByTestId('live-handoff-analysis')).toHaveAttribute('data-ready', 'true'),
+    )
+    expect(screen.getByTestId('live-handoff-analysis')).toHaveAttribute(
+      'href',
+      '/race-hub?session_key=99',
+    )
+    expect(mockFetchWeekendContext.mock.calls.length).toBeGreaterThan(1)
+  })
+
   it('flips settling → analysis-ready when polling sees ingestion complete', async () => {
     vi.useFakeTimers({ shouldAdvanceTime: true })
     // First fetch: pending. Subsequent polls: complete.
@@ -257,6 +322,11 @@ describe('LiveTimingPage', () => {
     expect(screen.getByText('Timing Tower')).toBeInTheDocument()
     expect(screen.queryByTestId('live-settling')).not.toBeInTheDocument()
     expect(screen.queryByTestId('live-archive-strip')).not.toBeInTheDocument()
+    // SSE may still be open (MockEventSource opens) — health must not say healthy.
+    await waitFor(() =>
+      expect(screen.getByTestId('live-feed-health')).toHaveTextContent(/reconnecting/i),
+    )
+    expect(screen.getByTestId('live-feed-health')).not.toHaveTextContent(/feed healthy/i)
   })
 
   it('keeps the settled snapshot behind an explicit read-only archive action', async () => {

frontend/src/test/liveState.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it } from 'vitest'
 import {
   allowsLiveInterpretations,
   deriveLivePhase,
+  effectiveFeedHealth,
   isReadOnlyPhase,
   rendersSnapshot,
   terminalSessionStatus,
@@ -167,3 +168,16 @@ describe('phase capability helpers', () => {
     expect(isReadOnlyPhase('disconnected')).toBe(false)
   })
 })
+
+describe('effectiveFeedHealth', () => {
+  it('downgrades a still-open SSE to reconnecting while phase is disconnected', () => {
+    expect(effectiveFeedHealth('connected', 'disconnected')).toBe('disconnected')
+    expect(effectiveFeedHealth('connecting', 'disconnected')).toBe('disconnected')
+  })
+
+  it('preserves transport when the session phase is live or settling', () => {
+    expect(effectiveFeedHealth('connected', 'live')).toBe('connected')
+    expect(effectiveFeedHealth('connected', 'settling')).toBe('connected')
+    expect(effectiveFeedHealth('error', 'disconnected')).toBe('error')
+  })
+})