Health Dashboard: Sub-pages, Training Page, Full Activity Cache, All-Time Bests

Overview

Redesign the health dashboard (/health) into a multi-page layout and add a new Training sub-page with performance metrics.

Four main changes: 1. Reorganize existing monolithic page into sub-pages 2. New "Training" sub-page with CTL/ATL/TSB chart, EF charts, rolling means, all-time bests 3. Cache full intervals.icu activity payloads (not just the stripped Exercise type) 4. All-time bests section on the training page

Files to modify

• Omni/Health/Web.hs — main change: split into sub-page routing + render functions
• Omni/Health/Intervals.hs — expand to cache full API payloads, backfill history
• Omni/Health/Analyze.hs — add Training data types and analysis functions (EF computation, all-time bests)
• Omni/Health/Style.hs — may need minor updates for new pages

1. Sub-page Structure

Current: single monolithic page renders all 10+ sections. New: landing page with links to sub-pages.

Routing in app:

• GET /health → Overview (landing page with streak, recent days, stale warnings, nav links)
• GET /health/nutrition → Nutrition (food rankings, meal spike rankings, hypo crash rankings, post-workout nutrition, correlations)
• GET /health/training → Training (new — see below)
• GET /health/labs → Lab Results (bloodwork)
• POST /health/upload/cgm → unchanged

Each sub-page should use the same shared shell (WebStyle.sharedShell) and have a simple nav bar or breadcrumb linking between the sub-pages.

The existing render functions (renderFoodRankings, renderMealRankings, etc.) can be reused; they just get composed differently per sub-page instead of all dumped on one page.

2. Training Sub-page (/health/training)

CTL/ATL/TSB Chart

• Line chart (Chart.js) showing CTL (42-day), ATL (7-day), and TSB (CTL-ATL) over time
• The intervals.icu API returns icu_ctl and icu_atl per activity — use those directly
• X-axis: date, Y-axis: load units
• TSB can be a bar chart or a separate line (it goes negative)

Efficiency Factor Charts

Two separate charts:

Bike EF (watts/HR):

• Source: icu_efficiency_factor field from intervals.icu (non-null for Ride/VirtualRide activities with power)
• Filter to Z2/easy rides only for the rolling mean. Heuristic: activities where name contains "Z2" or average HR is below zone 3 threshold. (The icu_hr_zones field in the activity gives zone boundaries — zone 2 upper is the first element.)
• Show individual data points + 7-ride rolling mean

Run EF (speed/HR):

• intervals.icu does NOT compute EF for runs (it's null). Compute it ourselves: average_speed / average_heartrate * 1000
• Filter to easy runs: name contains "Easy" or HR below zone 3
• Show individual data points + 7-run rolling mean

Rolling Means

For each EF chart, overlay a rolling mean line (7-activity window, same sport type, easy efforts only).

All-Time Bests Section

Render as a table/card grid. Include:

Running:

• Best Run EF (speed/HR × 1000, easy runs only) — date + value
• Fastest 5K pace (best average_speed for runs with distance >= 5000m)
• Lowest avg HR at conversational pace (easy runs, HR)
• Longest run (distance)

Cycling:

• Best Bike EF (watts/HR, Z2 rides only) — date + value
• Highest normalized power (icu_weighted_avg_watts for any ride)
• Best 7-day rolling bike EF — value + end date
• Longest ride (distance)

General:

• Highest CTL ever reached — value + date
• Longest training streak (consecutive days with activities)
• Highest single-session training load

3. Full Activity Cache

Current problem

Intervals.hs only extracts 6 fields into the Exercise type and discards 100+ fields the API returns. We need the rich data for EF, CTL/ATL, HR zones, power, pace, etc.

Solution

New cache file: /var/health/training-cache.json

• Store the FULL JSON payload from intervals.icu API, not parsed into Haskell types
• Array of raw Aeson.Value objects
• Each activity is stored as-is from the API

New Haskell type TrainingActivity in Analyze.hs (or a new Training.hs module):

data TrainingActivity = TrainingActivity
  { taId :: Text
  , taDate :: Day
  , taType :: Text              -- "Run", "VirtualRide", etc.
  , taName :: Text
  , taMovingTime :: Int         -- seconds
  , taDistance :: Maybe Double   -- meters
  , taCalories :: Maybe Int
  , taAvgHR :: Maybe Int
  , taMaxHR :: Maybe Int
  , taAvgWatts :: Maybe Int
  , taNormalizedPower :: Maybe Int  -- icu_weighted_avg_watts
  , taAvgSpeed :: Maybe Double  -- m/s
  , taPace :: Maybe Double      -- m/s (GAP for runs)
  , taAvgCadence :: Maybe Double
  , taEF :: Maybe Double        -- icu_efficiency_factor (null for runs)
  , taTrainingLoad :: Maybe Int -- icu_training_load
  , taCTL :: Maybe Double       -- icu_ctl (snapshot at activity time)
  , taATL :: Maybe Double       -- icu_atl
  , taHRZones :: Maybe [Int]    -- icu_hr_zones (zone boundaries)
  , taHRZoneTimes :: Maybe [Int]  -- icu_hr_zone_times (seconds per zone)
  , taTrimp :: Maybe Double
  , taIntensity :: Maybe Double -- icu_intensity
  } deriving (Show, Eq, Generic)

Cache strategy:

• Keep the old exercise-cache.json and Exercise type working (don't break existing nutrition analysis)
• New training-cache.json is the rich cache
• On first load / backfill: fetch ALL activities from 2025-01-01 to now
• intervals.icu API supports oldest and newest params
• May need to paginate or batch by month if the response is large
• Incremental updates: on subsequent loads, only fetch activities newer than the most recent cached activity
• Cache TTL: 1 hour (same as current)

Backfill on first run:

fetchAndCacheTraining :: FilePath -> IO [TrainingActivity]
-- If training-cache.json doesn't exist or is empty:
--   Fetch all from 2025-01-01 to today
-- If it exists and is fresh (< 1h):
--   Return cached
-- If it exists but stale:
--   Fetch only activities newer than max date in cache
--   Merge with existing cache
--   Write updated cache

4. Keep backward compat

The existing Exercise type and exercise-cache.json are used by the nutrition analysis (post-workout nutrition, etc.). Keep those working. The training page uses the new TrainingActivity type and training-cache.json.

Optionally, you could derive Exercise from TrainingActivity to avoid double-fetching, but that's a nice-to-have — correctness first.

API Reference

intervals.icu activities endpoint:

GET https://intervals.icu/api/v1/athlete/{id}/activities?oldest=YYYY-MM-DD&newest=YYYY-MM-DD
Authorization: Basic base64(API_KEY:{key})

Key fields in response (per activity):

• id, start_date_local, type, name
• moving_time (seconds), distance (meters), calories
• average_heartrate, max_heartrate, average_speed, average_cadence
• icu_average_watts, icu_weighted_avg_watts (normalized power)
• icu_efficiency_factor (watts/HR for cycling, null for running)
• icu_training_load, icu_ctl, icu_atl
• icu_hr_zones (array of HR zone boundaries)
• icu_hr_zone_times (array of seconds spent in each zone)
• trimp, icu_intensity
• pace (m/s for running)

Auth is via env vars: INTERVALS_API_KEY, INTERVALS_ATHLETE_ID

Acceptance Criteria

• [ ] /health shows overview page with nav links to sub-pages
• [ ] /health/nutrition shows food rankings, meal spikes, hypo risk, post-workout nutrition, correlations
• [ ] /health/training shows CTL/ATL/TSB chart, bike EF chart, run EF chart, all-time bests
• [ ] /health/labs shows bloodwork
• [ ] Training data cached to /var/health/training-cache.json with full API payload
• [ ] Historical backfill from 2025-01-01 on first load
• [ ] Incremental cache updates on subsequent loads
• [ ] EF charts filter to easy/Z2 efforts for rolling mean
• [ ] All-time bests show correct values from cached data
• [ ] Existing nutrition analysis still works (Exercise type unchanged)
• [ ] nix build passes