From 99624f67bbe50d75eb5ba1155336bca47b99aac5 Mon Sep 17 00:00:00 2001
From: twfarley <mot.yelraf@gmail.com>
Date: Fri, 18 Sep 2026 10:49:05 -0600
Subject: [PATCH 1/2] Add historical rain gauge scales and Caelus daily
 averages

---
 docs/user_guide.md                       |  79 +++++++-
 sensorius/__init__.py                    |   2 +-
 sensorius/saiHtml.py                     |  11 +-
 sensorius/saiRainClimate.py              | 227 +++++++++++++++++++++++
 sensorius/saiWeatherClimate.py           |  88 +++++++++
 sensorius/saiWebRoutes.py                |  29 +++
 testApparatus/playwright_host.py         |  27 +++
 testApparatus/test_rain_climate.py       | 197 ++++++++++++++++++++
 testApparatus/test_weather_climate.py    | 142 ++++++++++++++
 tests/rain-gauges.spec.js                |  63 +++++++
 tests/weather-forecast.spec.js           |  24 +++
 ui_static/js/rain_gauges.js              |  60 ++++++
 ui_static/weather_forecast/app.css       |   5 +
 ui_static/weather_forecast/app.js        |  55 ++++++
 ui_templates/weather_forecast/index.html |   4 +
 15 files changed, 1010 insertions(+), 3 deletions(-)
 create mode 100644 sensorius/saiRainClimate.py
 create mode 100644 sensorius/saiWeatherClimate.py
 create mode 100644 testApparatus/test_rain_climate.py
 create mode 100644 testApparatus/test_weather_climate.py
 create mode 100644 tests/rain-gauges.spec.js
 create mode 100644 ui_static/js/rain_gauges.js

diff --git a/docs/user_guide.md b/docs/user_guide.md
index e40a851..b0bb296 100644
--- a/docs/user_guide.md
+++ b/docs/user_guide.md
@@ -188,6 +188,59 @@ Colored backgrounds use that metric's gauge zones. The colors are metric-specifi
 
 The boundaries come from Sensorius's gauge-zone configuration for each metric. Changing a zone boundary in that configuration changes where the corresponding background color begins and ends. The standard UI currently exposes gauge size and display style, but not gauge-zone boundary editing. An automation's **Threshold** and **Hysteresis** control when its rule runs; they do not change graph or gauge colors.
 
+#### Rain Gauge Colors And Historical Limits
+
+Rain accumulation gauges use light blue (`#add8e6`) from 0–20% of the scale,
+medium blue (`#66b2ff`) from 20–60%, and dark blue (`#0033cc`) from 60–100%.
+These bands indicate increasing rain amounts, not alarm thresholds.
+
+**Rain and location:** Check the hub's coordinates in **General Settings >
+Astral**. Sensorius uses those coordinates for all rain-gauge climate scales
+on that hub. A sensor's location label (for example, Greenhouse or Garden)
+does not select a different climate location. GeoIP provides an approximate
+location; enter the site's latitude and longitude manually when that estimate
+does not represent where the rain gauge is installed. Changing the hub's
+coordinates updates the historical scale, not the measured rainfall or stored
+sensor readings.
+
+Using the hub's Astral latitude/longitude and timezone (manual or GeoIP),
+Sensorius retrieves daily rainfall from [Open-Meteo's Historical Weather
+API](https://open-meteo.com/en/docs/historical-weather-api), using ERA5 for the
+period from January 1, 1991 through the latest available data (normally five
+days behind today, or earlier if the latest days are not yet published). The gauge maximum is the wettest corresponding period:
+
+| Gauge | Historical period used for maximum |
+| --- | --- |
+| Rain, Rain Last 24h, Rain Day | Wettest local calendar day |
+| Rain Week | Wettest seven consecutive days, including across year boundaries |
+| Rain Month | Wettest complete calendar month |
+| Rain Year | Wettest complete calendar year |
+
+Daily history approximates the rolling 24-hour gauge; it is not a historical
+rolling hourly record. `Rain` retains its existing station/interval meaning.
+The historical series is gridded outdoor rainfall, excludes snowfall, and is
+not a record measured by your own station. It works independently of the
+selected forecast provider. Rain Event and Rain Total get the same blue bands
+but retain their fixed limits; Rain Rate retains its existing scale.
+
+Limits and ticks follow the selected mm/in display units. A completely dry
+baseline uses a minimum 1 mm span. The needle stops at the scale maximum if a
+reading exceeds it; the full measured value remains visible numerically.
+Min/Avg/Max statistics still describe the sensor's last 24 hours, not climate
+history.
+
+Historical data loads in the background, using default limits while loading
+or unavailable. Scales update without a page reload or extra text inside the
+tiles, preserving their original height. A compact location-specific cache
+survives restarts; on Linux its default path is `/home/<user>/Sensorius/weather_cache/rain_climate.json`
+(`/Users/<user>/Sensorius/weather_cache/rain_climate.json` on macOS).
+The cache is checked hourly and refreshed when the historical end date advances.
+Only complete months and years contribute to their respective maxima; daily
+and seven-day maxima include recent complete days. Changing the hub location
+invalidates the active scale. Missing or incomplete history retries later;
+a previously cached summary for the same location remains usable during a
+refresh failure, otherwise the existing default limits apply.
+
 #### Metric Ordering
 
 The system-wide **Metric Set** in **General Settings > Display** controls the initial Sensor Group state. In **Pick 6** mode, the dashboard follows **Metric 1** through **Metric 6** exactly from left to right and initially collapses each Sensor Group after those six Sensor Tiles. Use the disclosure triangle beside the connection indicator to reveal or hide the Sensor Group's remaining known metrics. Sensor Groups with six or fewer Sensor Tiles do not show the triangle. You can therefore establish the operational summary order in **Sensor Settings**. Factory defaults are selected by sensor type and generally put the device's primary measurement first: for example, CO2 is first for a CO2 sensor and Air Quality is first for an AQI sensor. The remaining positions favor closely related temperature, humidity, VPD, dew-risk, pressure, plant, light, or soil measurements for that device.
@@ -1205,9 +1258,33 @@ next seasonal event, and up to three solar or lunar eclipses visible from the
 configured Astral location during the next twelve months. A full-width Windy
 map opens in radar view below that row, followed by
 the current Moon and phase cycle at the bottom. The display also provides
-theme-matched six-day details. It does not run a separate weather service or
+theme-matched six-day details. It reuses the Sensorius forecast and does not
 maintain a separate settings file or readings database.
 
+Today's forecast includes a compact **Historical daily average** row
+beneath its expected ranges, with temperature, RH, wind, and rain in the same
+column order. These are averages for the same calendar date at the hub's
+Astral location, using Open-Meteo/ERA5 historical data independently of the
+selected forecast provider. Temperature, RH, and wind are averages of daily
+means; rain is the average daily rainfall total, including dry days, **not a
+rain probability**. Units follow the selected Metric or Imperial display.
+
+The date follows the hub's timezone. History starts in 1991 and extends through
+the latest available data, allowing for ERA5's roughly five-day publication
+delay; unpublished trailing days are excluded. Each calendar date uses its available daily samples, including recent
+years; February 29 uses only leap years. The label shows the actual year range and hub-local date, for example
+**Historical daily average 1991–2026 for 18-Sep-2026**,
+and its tooltip gives the exact historical cutoff and sample count. These are
+regional climate estimates, not readings from the selected station. The source link and tooltip
+explain the baseline without adding a separate note or increasing the card's
+height. Dashes mean history is still loading or unavailable, never zero.
+Retrieval is non-blocking. The cache is checked hourly and refreshed as the
+historical end date advances; a compact calendar-day cache survives restarts
+at `/home/<user>/Sensorius/weather_cache/weather_climate.json` on Linux or
+`/Users/<user>/Sensorius/weather_cache/weather_climate.json` on macOS. Updating
+the hub's location invalidates the active history. The displayed date and
+averages refresh automatically, including after the hourly forecast refresh.
+
 The Windy map is initially interaction-locked so the mouse wheel continues to
 scroll the Caelus page. Select **Click to interact with map** on the map's top
 border to enable its zoom and pan controls; move the pointer outside the map
diff --git a/sensorius/__init__.py b/sensorius/__init__.py
index a15fd26..4f5d076 100644
--- a/sensorius/__init__.py
+++ b/sensorius/__init__.py
@@ -4,4 +4,4 @@
 release notes, and supporting tooling can report a consistent build identity.
 """
 
-__version__ = "v0.26.259.1"
+__version__ = "v0.26.261.6"
diff --git a/sensorius/saiHtml.py b/sensorius/saiHtml.py
index 85ca539..1056dd0 100644
--- a/sensorius/saiHtml.py
+++ b/sensorius/saiHtml.py
@@ -11,6 +11,7 @@
 from .saiBiodynamics import get_biodynamic_payload, get_skyfield_runtime_if_installed
 from .sensor_modules.station_weewx import DEFAULT_SENSOR_ID as WEEWX_DEFAULT_SENSOR_ID, WEEWX_GAUGE_CONFIG
 from .sensor_modules.station_ecowitt import ECOWITT_GAUGE_CONFIG, ecowitt_gauge_config_for_metric
+from .saiRainClimate import style_rain_gauges
 from .saiDisplayUnits import convert_display_value
 from collections import defaultdict
 from pathlib import Path
@@ -142,7 +143,7 @@ def get_gauge_config():
     }
     gauge_config.update(WEEWX_GAUGE_CONFIG)
     gauge_config.update(ECOWITT_GAUGE_CONFIG)
-    return gauge_config
+    return style_rain_gauges(gauge_config)
 
 
 def extend_gauge_config_for_metrics(gauge_config: dict, metric_names) -> dict:
@@ -2323,6 +2324,7 @@ def _format_stat_value(stat_value):
     
     yield "<script type='module'>"
     yield "\"use strict\";"
+    yield f"import {{ startRainGauges }} from '/ui_static/js/rain_gauges.js?v={APP_VERSION}';"
     
     yield "let stepCount = 0;"
     yield f"const gaugeConfig = {json.dumps(gauge_config)};"
@@ -4879,6 +4881,11 @@ def _format_stat_value(stat_value):
     yield "    const gaugeValue = convertForDisplay(value, config);"
     yield "    const existingGauge = window[`${safe}_gauge`];"
     yield "    if (existingGauge && existingGauge.__sensoriusCanvas === canvas && typeof existingGauge.set === 'function') {"
+    yield "      if (config.rain_period && existingGauge.maxValue !== config.max) {"
+    yield "        existingGauge.maxValue = config.max;"
+    yield "        existingGauge.setMinValue(config.min);"
+    yield "        existingGauge.setOptions({...existingGauge.options, staticZones: config.zones, staticLabels: {...existingGauge.options.staticLabels, labels: config.ticks}});"
+    yield "      }"
     yield "      existingGauge.set(gaugeValue ?? 0);"
     yield "      label.innerText = isNull ? '--' : formatCurrentValue(value, config);"
     yield "      if (window.registerContainerStyle) {"
@@ -4891,6 +4898,7 @@ def _format_stat_value(stat_value):
     yield "      angle: -0.2, lineWidth: 0.25, radiusScale: 0.9,"
     yield "      pointer: { length: 0.5, strokeWidth: 0.035, color: '#000000' },"
     yield "      staticZones: config.zones || [],"
+    yield "      limitMax: Boolean(config.rain_period),"
     yield "      staticLabels: {"
     yield "        font: '12px sans-serif',"
     yield "        labels: config.ticks, color: '#000', fractionDigits: 1"
@@ -8155,6 +8163,7 @@ def _format_stat_value(stat_value):
     yield "  setTimeout(checkAndRetryIfNoGauges, 1000);"
 
     yield "  initGauge();"
+    yield "  startRainGauges(gaugeConfig, initGauge);"
     yield "  initializeDashboardThemePreview();"
     yield "  initializeTrendArrows();"
     yield "  initSwitchTimersFromDom();"
diff --git a/sensorius/saiRainClimate.py b/sensorius/saiRainClimate.py
new file mode 100644
index 0000000..c3bac0b
--- /dev/null
+++ b/sensorius/saiRainClimate.py
@@ -0,0 +1,227 @@
+"""Cache location-specific rainfall history for dashboard gauge scales.
+
+Only daily ERA5 rain totals are downloaded. A compact summary survives restarts;
+network and location lookups run outside the dashboard request path.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import copy
+from collections import defaultdict, deque
+from datetime import date, datetime, timedelta, timezone
+import json
+import math
+from pathlib import Path
+import time
+
+import httpx
+
+from .saiUtils import printDM
+
+ARCHIVE_URL = "https://archive-api.open-meteo.com/v1/archive"
+START = date(1991, 1, 1)
+
+RAIN_PERIODS = {
+    "Rain": "day", "Rain Last 24h": "day", "Rain Day": "day",
+    "Rain Week": "week", "Rain Month": "month", "Rain Year": "year",
+}
+RAIN_COLORS = ("#add8e6", "#66b2ff", "#0033cc")
+
+
+def latest_history_date() -> date:
+    """Allow for ERA5's five-day publication delay using a UTC cutoff."""
+    return datetime.now(timezone.utc).date() - timedelta(days=5)
+
+
+def rain_gauge_scale(maximum: float) -> dict:
+    """Build the screenshot's blue bands and proportional ticks in gauge units."""
+    return {
+        "min": 0, "max": maximum,
+        "ticks": [maximum * fraction for fraction in (0, .2, .4, .6, .8, 1)],
+        "zones": [
+            {"strokeStyle": color, "min": maximum * low, "max": maximum * high}
+            for color, low, high in zip(RAIN_COLORS, (0, .2, .6), (.2, .6, 1))
+        ],
+    }
+
+
+def style_rain_gauges(config: dict) -> dict:
+    """Apply consistent rain colors and identify climate-scaled accumulation metrics."""
+    config = copy.deepcopy(config)
+    for metric, gauge in config.items():
+        if metric in RAIN_PERIODS or metric in {"Rain Event", "Rain Total"}:
+            gauge.update(rain_gauge_scale(gauge["max"]))
+            if metric in RAIN_PERIODS:
+                gauge["rain_period"] = RAIN_PERIODS[metric]
+    return config
+
+
+def summarize_rain_history(payload: dict, end: date) -> dict[str, float]:
+    """Return wettest day, rolling seven days, calendar month and year in mm.
+
+    Require every baseline day to prevent missing rainfall from lowering limits.
+    Daily values approximate the rolling 24-hour gauge with local calendar days.
+    """
+    daily = payload.get("daily") or {}
+    dates, values = daily.get("time", []), daily.get("rain_sum", [])
+    count = (end - START).days + 1
+    if len(dates) != count or len(values) != count:
+        raise ValueError("Rain history does not cover the complete requested range")
+    months, years = defaultdict(float), defaultdict(float)
+    window = deque(maxlen=7)
+    max_day = max_week = 0.0
+    for index, (day_text, value) in enumerate(zip(dates, values)):
+        day = START + timedelta(days=index)
+        if day_text != day.isoformat() or isinstance(value, bool) or value is None:
+            raise ValueError("Rain history contains a missing or invalid day")
+        rain = float(value)
+        if not math.isfinite(rain) or rain < 0:
+            raise ValueError("Rain history contains an invalid rain total")
+        window.append(rain)
+        max_day = max(max_day, rain)
+        if len(window) == 7:
+            max_week = max(max_week, sum(window))
+        months[(day.year, day.month)] += rain
+        years[day.year] += rain
+    return {key: round(value, 3) for key, value in {
+        "day": max_day, "week": max_week, "month": max(total for (year, month), total in months.items()
+                     if (year, month) < (end.year, end.month) or (end + timedelta(days=1)).month != end.month),
+        "year": max(total for year, total in years.items()
+                    if year < end.year or (end.month, end.day) == (12, 31))
+    }.items()}
+
+
+class RainClimateService:
+    """Serve a non-blocking climate summary with a bounded persistent cache."""
+
+    daily_variables = "rain_sum"
+    expected_units = {"rain_sum": "mm"}
+
+    def __init__(self, settings_factory, cache_path: Path):
+        self.settings_factory = settings_factory
+        self.cache_path = Path(cache_path)
+        self.payload = {"status": "warming"}
+        self.task = None
+        self.next_check = 0.0
+
+    def snapshot(self) -> dict:
+        """Return current status and start background work when necessary."""
+        if (self.task is None or self.task.done()) and time.monotonic() >= self.next_check:
+            self.task = asyncio.create_task(self._load(), name="RainClimate")
+        return dict(self.payload)
+
+    def invalidate(self) -> None:
+        """Discard the old location immediately after system settings change."""
+        if self.task is not None:
+            self.task.cancel()
+        self.task = None
+        self.payload = {"status": "warming"}
+        self.next_check = 0.0
+
+    async def close(self) -> None:
+        """Cancel climate retrieval during application shutdown."""
+        if self.task is not None:
+            self.task.cancel()
+            await asyncio.gather(self.task, return_exceptions=True)
+
+    def _location(self) -> dict:
+        settings = self.settings_factory()
+        resolved = settings.resolve_astral_location(persist_if_auto=False, timeout_sec=2.5)
+        lat, lon = float(resolved["lat"]), float(resolved["lon"])
+        if not math.isfinite(lat) or not math.isfinite(lon) or not -90 <= lat <= 90 or not -180 <= lon <= 180:
+            raise ValueError("Rain climate location is unavailable")
+        return {"latitude": round(lat, 4), "longitude": round(lon, 4), "timezone": resolved.get("tz") or "UTC"}
+
+    def _read_cache(self, location: dict) -> dict | None:
+        try:
+            cached = json.loads(self.cache_path.read_text())
+        except FileNotFoundError:
+            return None
+        if cached.get("schema") != 2 or cached.get("location") != location:
+            return None
+        try:
+            end = date.fromisoformat(cached["end_date"])
+            requested_end = date.fromisoformat(cached["requested_end_date"])
+        except (KeyError, ValueError, TypeError):
+            return None
+        if cached.get("start_date") != START.isoformat() or not START <= end <= requested_end <= latest_history_date():
+            return None
+        return cached if self._valid_summary(cached) else None
+
+    def _valid_summary(self, payload: dict) -> bool:
+        maxima = payload.get("maxima_mm", {})
+        return (set(maxima) == {"day", "week", "month", "year"}
+                and all(not isinstance(v, bool) and isinstance(v, (int, float))
+                        and math.isfinite(v) and v >= 0 for v in maxima.values()))
+
+    def _summarize(self, data: dict, end: date) -> dict:
+        return {"maxima_mm": summarize_rain_history(data, end)}
+
+    def _available_history(self, data: dict, end: date) -> tuple[dict, date]:
+        """Trim unpublished trailing days, while rejecting gaps inside the history."""
+        daily = data.get("daily") or {}
+        keys = ("time", *self.expected_units)
+        count = (end - START).days + 1
+        if any(len(daily.get(key, [])) != count for key in keys):
+            raise ValueError("Climate history does not cover the requested dates")
+        available = count
+        while available and any(daily[key][available - 1] is None for key in self.expected_units):
+            available -= 1
+        # Allow an additional week of publication lag; longer gaps need a retry.
+        if count - available > 7:
+            raise ValueError("Climate archive is missing more than a week of recent data")
+        return {**data, "daily": {key: daily[key][:available] for key in keys}}, end - timedelta(days=count - available)
+
+    def _write_cache(self, payload: dict) -> None:
+        self.cache_path.parent.mkdir(parents=True, exist_ok=True)
+        temporary = self.cache_path.with_suffix(".tmp")
+        temporary.write_text(json.dumps(payload, separators=(",", ":")), encoding="utf-8")
+        temporary.replace(self.cache_path)
+
+    async def _load(self) -> None:
+        try:
+            location = await asyncio.to_thread(self._location)
+            if self.payload.get("location") != location:
+                self.payload = {"status": "warming", "location": location}
+            try:
+                cached = await asyncio.to_thread(self._read_cache, location)
+            except (OSError, ValueError, TypeError, AttributeError) as exc:
+                printDM(f"Rain climate cache read failed: {exc}", location="saiRainClimate")
+                cached = None
+            if cached is not None:
+                self.payload = cached
+            end = latest_history_date()
+            if cached is None or cached["requested_end_date"] != end.isoformat():
+                async with httpx.AsyncClient(timeout=45.0) as client:
+                    response = await client.get(ARCHIVE_URL, params={
+                        **location, "start_date": START.isoformat(), "end_date": end.isoformat(),
+                        "daily": self.daily_variables, "models": "era5",
+                        "precipitation_unit": "mm", "temperature_unit": "celsius", "wind_speed_unit": "kmh",
+                    })
+                    response.raise_for_status()
+                    data = response.json()
+                if any(data.get("daily_units", {}).get(key) != unit for key, unit in self.expected_units.items()):
+                    raise ValueError("Climate history has unexpected units")
+                requested_end = end
+                data, end = await asyncio.to_thread(self._available_history, data, end)
+                summary = await asyncio.to_thread(self._summarize, data, end)
+                self.payload = {
+                    "schema": 2, "status": "ready", "location": location,
+                    "start_date": START.isoformat(), "end_date": end.isoformat(),
+                    "requested_end_date": requested_end.isoformat(),
+                    "baseline": f"1991–{end.year}", "source": "Open-Meteo / ERA5",
+                    **summary,
+                }
+                try:
+                    await asyncio.to_thread(self._write_cache, self.payload)
+                except OSError as exc:
+                    printDM(f"Rain climate cache write failed: {exc}", location="saiRainClimate")
+            self.next_check = time.monotonic() + 3600
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:
+            if self.payload.get("status") != "ready":
+                self.payload = {"status": "unavailable", "reason": "Historical climate data unavailable"}
+            self.next_check = time.monotonic() + 300
+            printDM(f"Rain climate unavailable: {exc}", location="saiRainClimate")
diff --git a/sensorius/saiWeatherClimate.py b/sensorius/saiWeatherClimate.py
new file mode 100644
index 0000000..a7019da
--- /dev/null
+++ b/sensorius/saiWeatherClimate.py
@@ -0,0 +1,88 @@
+"""Provide same-calendar-date climate averages for the Caelus forecast card.
+
+Reuse the rainfall service's background loading and location-specific disk cache,
+keeping one compact 366-day climatology instead of the downloaded daily history.
+"""
+
+from datetime import date, datetime, timedelta, timezone
+import math
+from zoneinfo import ZoneInfo
+
+from .saiRainClimate import START, RainClimateService
+
+VARIABLES = {
+    "temperature_2m_mean": "temperature_c",
+    "relative_humidity_2m_mean": "humidity_pct",
+    "wind_speed_10m_mean": "wind_kmh",
+    "rain_sum": "rain_mm",
+}
+DAY_KEYS = {(date(2000, 1, 1) + timedelta(days=i)).strftime("%m-%d") for i in range(366)}
+
+
+def _valid_value(key: str, value) -> bool:
+    return (not isinstance(value, bool) and isinstance(value, (int, float))
+            and math.isfinite(value)
+            and (key == "temperature_c" or value >= 0)
+            and (key != "humidity_pct" or value <= 100))
+
+
+def summarize_weather_history(payload: dict, end: date) -> dict:
+    """Average daily temperature, RH, wind and rain by calendar date over the requested range."""
+    daily = payload.get("daily") or {}
+    count = (end - START).days + 1
+    if any(len(daily.get(key, [])) != count for key in ("time", *VARIABLES)):
+        raise ValueError("Weather history does not cover the complete baseline")
+    totals, samples = {}, {}
+    for index in range(count):
+        day = START + timedelta(days=index)
+        if daily["time"][index] != day.isoformat():
+            raise ValueError("Weather history has missing or duplicate dates")
+        key = day.strftime("%m-%d")
+        sums = totals.setdefault(key, dict.fromkeys(VARIABLES.values(), 0.0))
+        for variable, field in VARIABLES.items():
+            value = daily[variable][index]
+            if not _valid_value(field, value):
+                raise ValueError(f"Weather history contains invalid {variable}")
+            sums[field] += value
+        samples[key] = samples.get(key, 0) + 1
+    return {key: {**{field: round(value / samples[key], 3) for field, value in sums.items()},
+                  "samples": samples[key]} for key, sums in totals.items()}
+
+
+class WeatherClimateService(RainClimateService):
+    """Cache weather averages and select today's date in the hub's timezone."""
+
+    daily_variables = ",".join(VARIABLES)
+    expected_units = {"temperature_2m_mean": "°C", "relative_humidity_2m_mean": "%",
+                      "wind_speed_10m_mean": "km/h", "rain_sum": "mm"}
+
+    def _location(self) -> dict:
+        location = super()._location()
+        ZoneInfo(location["timezone"])
+        return location
+
+    def _summarize(self, data: dict, end: date) -> dict:
+        return {"calendar_averages": summarize_weather_history(data, end)}
+
+    def _valid_summary(self, payload: dict) -> bool:
+        averages = payload.get("calendar_averages", {})
+        if set(averages) != DAY_KEYS:
+            return False
+        end = date.fromisoformat(payload["end_date"])
+        samples = dict.fromkeys(DAY_KEYS, 0)
+        for offset in range((end - START).days + 1):
+            samples[(START + timedelta(days=offset)).strftime("%m-%d")] += 1
+        return all(isinstance(row, dict)
+                   and row.get("samples") == samples[key]
+                   and all(_valid_value(field, row.get(field)) for field in VARIABLES.values())
+                   for key, row in averages.items())
+
+    def snapshot(self, *, now: datetime | None = None) -> dict:
+        """Return today's four averages, keeping the full climatology server-side."""
+        payload = super().snapshot()
+        calendar = payload.pop("calendar_averages", {})
+        if payload.get("status") == "ready":
+            current = (now or datetime.now(timezone.utc)).astimezone(ZoneInfo(payload["location"]["timezone"]))
+            payload["date"] = current.date().isoformat()
+            payload["averages"] = calendar[current.strftime("%m-%d")]
+        return payload
diff --git a/sensorius/saiWebRoutes.py b/sensorius/saiWebRoutes.py
index 1effdd1..75af837 100644
--- a/sensorius/saiWebRoutes.py
+++ b/sensorius/saiWebRoutes.py
@@ -115,6 +115,8 @@
 from .saiNodusOTA import NodusOTAError, NodusOTAService
 from .saiEmailNotifications import EmailConfig, SMTPEmailSender, normalize_notification_rules
 from .saiWeatherForecast import get_weather_forecast_payload, normalize_weather_forecast_provider
+from .saiRainClimate import RainClimateService
+from .saiWeatherClimate import WeatherClimateService
 from .saiWeatherForecastApp import build_weather_display_forecast
 from .saiWeatherForecastApp import WEATHER_THEMES, normalize_weather_theme
 from .saiThemeManager import (
@@ -682,6 +684,31 @@ async def register_routes(app, settings, net_mgr, gc_mgr, mqtt_ingest):
     astro_payload_cache_lock = threading.Lock()
     astro_payload_cache_generation = 0
     main_loop = asyncio.get_running_loop()
+    rain_climate_service = RainClimateService(
+        lambda: saiSettings(make_startup_backup=False, apply_live=False),
+        resolve_runtime_base_dir(getattr(saiSettings, "DEFAULT_BASE_DIR", "system_settings")).parent
+        / "weather_cache" / "rain_climate.json",
+    )
+    app.state.rain_climate_service = rain_climate_service
+    app.add_event_handler("shutdown", rain_climate_service.close)
+
+    @router.get("/api/rain-climate")
+    async def api_rain_climate():
+        """Return cached rain gauge limits while history loads in the background."""
+        return rain_climate_service.snapshot()
+
+    weather_climate_service = WeatherClimateService(
+        lambda: saiSettings(make_startup_backup=False, apply_live=False),
+        rain_climate_service.cache_path.with_name("weather_climate.json"),
+    )
+    app.state.weather_climate_service = weather_climate_service
+    app.add_event_handler("shutdown", weather_climate_service.close)
+
+    @router.get("/api/weather-climate")
+    async def api_weather_climate():
+        """Return historical daily averages for today's date at the hub location."""
+        return weather_climate_service.snapshot()
+
     daily_summary_service = DailySummaryService(settings=settings, data_logger=data_logger)
     app.state.daily_summary_service = daily_summary_service
     ota_service = getattr(app.state, "nodus_ota_service", None)
@@ -711,6 +738,8 @@ def _invalidate_dashboard_caches() -> None:
         nonlocal biodynamic_payload_cache_generation, astro_payload_cache_generation
         global _DASHBOARD_INVENTORY_CACHE, _DASHBOARD_DISPLAY_SETTINGS_CACHE, _ASTRO_PAYLOAD_CACHE
         global _sensor_ids_cache_payload, _sensor_ids_cache_until
+        rain_climate_service.invalidate()
+        weather_climate_service.invalidate()
         _DASHBOARD_JSON_CACHE.clear()
         _DASHBOARD_HTML_CACHE.clear()
         _DASHBOARD_INVENTORY_CACHE = None
diff --git a/testApparatus/playwright_host.py b/testApparatus/playwright_host.py
index 4d15bf4..2949f90 100644
--- a/testApparatus/playwright_host.py
+++ b/testApparatus/playwright_host.py
@@ -181,3 +181,30 @@ def ac1100_dashboard() -> HTMLResponse:
         switch_controllers={sid: controller}, gauge_config=get_gauge_config(),
         expected_gauge_map={}, expected_display_style_map={},
     )))
+
+
+@app.get("/rain-gauges", response_class=HTMLResponse)
+def rain_gauges(unit_system: str = "Metric") -> HTMLResponse:
+    """Render rain accumulation gauges with deterministic readings for UI checks."""
+    from sensorius.saiDisplayUnits import apply_display_units_to_gauge_config
+    from sensorius.saiRainClimate import RAIN_PERIODS
+
+    sensor_id = "rain-pr-check"
+    metrics = {metric: .25 for metric in RAIN_PERIODS}
+    html = "".join(render_dashboard(
+        "All", None, [sensor_id], {sensor_id: metrics}, {},
+        SimpleNamespace(expected_gauge_map={}),
+        gauge_config=apply_display_units_to_gauge_config(get_gauge_config(), unit_system),
+        expected_gauge_map={sensor_id: list(metrics)},
+        expected_display_style_map={sensor_id: {}}, display_style="Gauge",
+    ))
+    return HTMLResponse(html)
+
+
+@app.get("/api/weather-climate")
+def weather_climate() -> dict:
+    """Supply deterministic historical averages without external network access."""
+    return {"status": "ready", "date": "2026-09-18", "baseline": "1991–2026",
+            "start_date": "1991-01-01", "end_date": "2026-09-13", "averages": {
+        "temperature_c": 20, "humidity_pct": 55, "wind_kmh": 16.09344, "rain_mm": 2.54, "samples": 35,
+    }}
diff --git a/testApparatus/test_rain_climate.py b/testApparatus/test_rain_climate.py
new file mode 100644
index 0000000..33ca5d9
--- /dev/null
+++ b/testApparatus/test_rain_climate.py
@@ -0,0 +1,197 @@
+"""Verify rain climate aggregation, caching, failures, and gauge unit compatibility."""
+
+from datetime import date, timedelta
+from types import SimpleNamespace
+import asyncio
+import json
+
+import httpx
+import pytest
+
+from sensorius import saiRainClimate as climate
+from sensorius.saiDisplayUnits import apply_display_units_to_gauge_config
+from sensorius.saiHtml import get_gauge_config
+
+
+END = date(2020, 12, 31)
+
+
+@pytest.fixture(autouse=True)
+def cutoff(monkeypatch):
+    monkeypatch.setattr(climate, 'latest_history_date', lambda: END)
+
+
+def history(value=1.0):
+    days = (END - climate.START).days + 1
+    return {"daily_units": {"rain_sum": "mm"}, "daily": {
+        "time": [(climate.START + timedelta(days=i)).isoformat() for i in range(days)],
+        "rain_sum": [value] * days,
+    }}
+
+
+def test_complete_baseline_includes_leap_days_and_calendar_periods():
+    assert climate.summarize_rain_history(history(), END) == {
+        "day": 1, "week": 7, "month": 31, "year": 366,
+    }
+
+
+def test_rolling_week_crosses_month_and_year_boundaries():
+    data = history(0)
+    for day in ('1999-12-30', '1999-12-31', '2000-01-01', '2000-01-02'):
+        data['daily']['rain_sum'][data['daily']['time'].index(day)] = 10
+    assert climate.summarize_rain_history(data, END) == {"day": 10, "week": 40, "month": 20, "year": 20}
+
+
+@pytest.mark.parametrize('value', [None, -1, float('nan'), float('inf'), True, 'invalid'])
+def test_invalid_rain_is_not_treated_as_dry_weather(value):
+    data = history()
+    data['daily']['rain_sum'][100] = value
+    with pytest.raises((ValueError, TypeError)):
+        climate.summarize_rain_history(data, END)
+
+
+def test_missing_or_duplicate_days_rejected():
+    data = history()
+    data['daily']['time'][1] = data['daily']['time'][0]
+    with pytest.raises(ValueError):
+        climate.summarize_rain_history(data, END)
+    data = history()
+    data['daily']['rain_sum'].pop()
+    with pytest.raises(ValueError):
+        climate.summarize_rain_history(data, END)
+
+
+def test_blue_bands_preserve_metric_units_and_source_values():
+    base = get_gauge_config()
+    for metric, period in climate.RAIN_PERIODS.items():
+        gauge = base[metric]
+        assert gauge['rain_period'] == period
+        assert [z['strokeStyle'] for z in gauge['zones']] == list(climate.RAIN_COLORS)
+        assert gauge['zones'][0]['max'] == pytest.approx(gauge['max'] * .2)
+        assert gauge['zones'][1]['max'] == pytest.approx(gauge['max'] * .6)
+        metric_gauge = apply_display_units_to_gauge_config(base, 'Metric')[metric]
+        assert metric_gauge['max'] == pytest.approx(gauge['max'] * 25.4)
+        assert metric_gauge['source_unit'] == 'in'
+
+
+@pytest.mark.asyncio
+async def test_background_download_cache_restart_and_changed_location(monkeypatch, tmp_path):
+    location = {'lat': 40, 'lon': -105, 'tz': 'America/Denver'}
+    factory = lambda: SimpleNamespace(resolve_astral_location=lambda **kwargs: location.copy())
+    requests = []
+    def respond(request):
+        requests.append(request)
+        assert request.url.params['daily'] == 'rain_sum'
+        assert request.url.params['models'] == 'era5'
+        assert request.url.params['start_date'] == '1991-01-01'
+        return httpx.Response(200, json=history())
+    client = httpx.AsyncClient
+    monkeypatch.setattr(climate.httpx, 'AsyncClient', lambda **kwargs: client(transport=httpx.MockTransport(respond), **kwargs))
+    path = tmp_path / 'weather_cache' / 'rain_climate.json'
+    service = climate.RainClimateService(factory, path)
+    assert service.snapshot()['status'] == 'warming'
+    task = service.task
+    service.snapshot()
+    assert service.task is task
+    await task
+    assert service.snapshot()['maxima_mm']['week'] == 7
+    assert len(requests) == 1
+    assert path.exists()
+    restored = climate.RainClimateService(factory, path)
+    restored.snapshot()
+    await restored.task
+    assert restored.payload['status'] == 'ready'
+    assert len(requests) == 1
+    location['lon'] = -106
+    restored.invalidate()
+    assert 'maxima_mm' not in restored.snapshot()
+    await restored.task
+    assert len(requests) == 2
+    assert restored.payload['location']['longitude'] == -106
+    await service.close()
+    await restored.close()
+
+
+@pytest.mark.asyncio
+async def test_network_failure_keeps_default_status_and_backs_off(monkeypatch, tmp_path):
+    client = httpx.AsyncClient
+    monkeypatch.setattr(climate.httpx, 'AsyncClient', lambda **kwargs: client(
+        transport=httpx.MockTransport(lambda request: httpx.Response(503)), **kwargs))
+    factory = lambda: SimpleNamespace(resolve_astral_location=lambda **kwargs: {'lat': 0, 'lon': 0, 'tz': 'UTC'})
+    service = climate.RainClimateService(factory, tmp_path / 'cache.json')
+    service.snapshot()
+    await service.task
+    task = service.task
+    assert service.snapshot()['status'] == 'unavailable'
+    assert service.task is task
+    await service.close()
+
+
+@pytest.mark.asyncio
+async def test_cancelled_load_does_not_publish_old_location(tmp_path):
+    service = climate.RainClimateService(lambda: None, tmp_path / 'cache.json')
+    service.task = asyncio.create_task(asyncio.sleep(100))
+    task = service.task
+    service.payload = {'status': 'ready', 'maxima_mm': {'day': 100}}
+    service.invalidate()
+    await asyncio.gather(task, return_exceptions=True)
+    assert service.payload == {'status': 'warming'}
+    assert task.cancelled()
+
+
+def extended_history(end, value=1.0):
+    count = (end - climate.START).days + 1
+    return {'daily_units': {'rain_sum': 'mm'}, 'daily': {
+        'time': [(climate.START + timedelta(days=i)).isoformat() for i in range(count)],
+        'rain_sum': [value] * count,
+    }}
+
+
+def test_recent_extremes_include_complete_days_but_exclude_partial_month_and_year():
+    end = date(2026, 9, 13)
+    data = extended_history(end)
+    data['daily']['rain_sum'][-1] = 1000
+    assert climate.summarize_rain_history(data, end) == {
+        'day': 1000, 'week': 1006, 'month': 31, 'year': 366,
+    }
+    for end in (date(2026, 9, 30), date(2026, 12, 31)):
+        data = extended_history(end)
+        data['daily']['rain_sum'][-1] = 1000
+        result = climate.summarize_rain_history(data, end)
+        assert result['month'] == (1029 if end.month == 9 else 1030)
+        assert result['year'] == (366 if end.month == 9 else 1364)
+
+
+@pytest.mark.asyncio
+async def test_expanding_cache_refresh_and_failure_preserves_previous_summary(monkeypatch, tmp_path):
+    cutoff = date(2026, 9, 12)
+    monkeypatch.setattr(climate, 'latest_history_date', lambda: cutoff)
+    requests = []
+    fail = False
+    def respond(request):
+        requests.append(request)
+        assert request.url.params['end_date'] == cutoff.isoformat()
+        return httpx.Response(503) if fail else httpx.Response(200, json=extended_history(cutoff))
+    client = httpx.AsyncClient
+    monkeypatch.setattr(climate.httpx, 'AsyncClient', lambda **kwargs: client(
+        transport=httpx.MockTransport(respond), **kwargs))
+    factory = lambda: SimpleNamespace(resolve_astral_location=lambda **kwargs: {'lat': 0, 'lon': 0, 'tz': 'UTC'})
+    path = tmp_path / 'climate.json'
+    # The previous fixed-range schema must not be reused.
+    path.write_text(json.dumps({'schema': 1, 'location': {'latitude': 0, 'longitude': 0, 'timezone': 'UTC'},
+                                'maxima_mm': dict.fromkeys(('day', 'week', 'month', 'year'), 9999)}))
+    service = climate.RainClimateService(factory, path)
+    await service._load()
+    assert service.payload['end_date'] == '2026-09-12'
+    assert service.payload['baseline'] == '1991–2026'
+    await service._load()
+    assert len(requests) == 1
+    cutoff += timedelta(days=1)
+    await service._load()
+    assert len(requests) == 2
+    assert service.payload['end_date'] == '2026-09-13'
+    cutoff += timedelta(days=1)
+    fail = True
+    await service._load()
+    assert service.payload['status'] == 'ready'
+    assert service.payload['end_date'] == '2026-09-13'
diff --git a/testApparatus/test_weather_climate.py b/testApparatus/test_weather_climate.py
new file mode 100644
index 0000000..ca802d2
--- /dev/null
+++ b/testApparatus/test_weather_climate.py
@@ -0,0 +1,142 @@
+"""Check daily weather climatology, local-date selection and persistent caching."""
+
+import asyncio
+from datetime import date, datetime, timedelta, timezone
+from types import SimpleNamespace
+
+import httpx
+import pytest
+
+from sensorius.saiRainClimate import START
+from sensorius import saiRainClimate as climate
+
+END = date(2020, 12, 31)
+from sensorius.saiWeatherClimate import WeatherClimateService, summarize_weather_history
+
+
+@pytest.fixture(autouse=True)
+def cutoff(monkeypatch):
+    monkeypatch.setattr(climate, 'latest_history_date', lambda: END)
+
+
+def history():
+    days = [START + timedelta(days=i) for i in range((END - START).days + 1)]
+    return {"daily_units": WeatherClimateService.expected_units, "daily": {
+        "time": [d.isoformat() for d in days],
+        "temperature_2m_mean": [d.year - 1990 for d in days],
+        "relative_humidity_2m_mean": [50.0] * len(days),
+        "wind_speed_10m_mean": [10.0] * len(days),
+        "rain_sum": [4.0 if d.year % 2 == 0 else 0.0 for d in days],
+    }}
+
+
+def test_calendar_date_means_include_dry_days_and_leap_day_samples():
+    averages = summarize_weather_history(history(), END)
+    assert len(averages) == 366
+    assert averages['09-18'] == {'temperature_c': 15.5, 'humidity_pct': 50,
+                                'wind_kmh': 10, 'rain_mm': 2, 'samples': 30}
+    assert averages['02-29']['samples'] == 8
+    assert averages['02-29']['temperature_c'] == 16
+
+
+@pytest.mark.parametrize('variable,value', [('rain_sum', None), ('relative_humidity_2m_mean', 101),
+                                          ('wind_speed_10m_mean', -1), ('temperature_2m_mean', float('nan'))])
+def test_missing_or_invalid_values_do_not_become_zero(variable, value):
+    data = history()
+    data['daily'][variable][0] = value
+    with pytest.raises(ValueError):
+        summarize_weather_history(data, END)
+
+
+def test_incomplete_calendar_rejected():
+    data = history()
+    data['daily']['time'][10] = data['daily']['time'][9]
+    with pytest.raises(ValueError):
+        summarize_weather_history(data, END)
+
+
+@pytest.mark.asyncio
+async def test_cache_reuse_and_selection_in_station_timezone(monkeypatch, tmp_path):
+    calls = []
+    def respond(request):
+        calls.append(request)
+        assert request.url.params['daily'] == WeatherClimateService.daily_variables
+        assert request.url.params['wind_speed_unit'] == 'kmh'
+        return httpx.Response(200, json=history())
+    client = httpx.AsyncClient
+    monkeypatch.setattr(httpx, 'AsyncClient', lambda **kwargs: client(transport=httpx.MockTransport(respond), **kwargs))
+    location = {'lat': 40, 'lon': -105, 'tz': 'America/Denver'}
+    factory = lambda: SimpleNamespace(resolve_astral_location=lambda **kwargs: location)
+    path = tmp_path / 'weather_climate.json'
+    service = WeatherClimateService(factory, path)
+    assert service.snapshot()['status'] == 'warming'
+    await service.task
+    utc = datetime(2026, 9, 19, 1, tzinfo=timezone.utc)
+    result = service.snapshot(now=utc)
+    assert result['date'] == '2026-09-18'
+    assert result['averages']['rain_mm'] == 2
+    assert 'calendar_averages' not in result
+    assert service.snapshot(now=utc + timedelta(hours=8))['date'] == '2026-09-19'
+    restored = WeatherClimateService(factory, path)
+    restored.snapshot()
+    await restored.task
+    assert restored.snapshot(now=utc)['averages'] == result['averages']
+    assert len(calls) == 1
+    restored.invalidate()
+    assert restored.payload == {'status': 'warming'}
+    await service.close()
+    await restored.close()
+
+
+def test_extended_averages_use_available_samples_and_validate_new_cache():
+    end = date(2026, 9, 13)
+    days = [START + timedelta(days=i) for i in range((end - START).days + 1)]
+    data = {'daily': {
+        'time': [day.isoformat() for day in days],
+        'temperature_2m_mean': [day.year - 1990 for day in days],
+        'relative_humidity_2m_mean': [50] * len(days),
+        'wind_speed_10m_mean': [10] * len(days),
+        'rain_sum': [1] * len(days),
+    }}
+    averages = summarize_weather_history(data, end)
+    assert averages['09-13']['samples'] == 36
+    assert averages['09-13']['temperature_c'] == 18.5
+    assert averages['09-14']['samples'] == 35
+    assert averages['09-14']['temperature_c'] == 18
+    assert averages['02-29']['samples'] == 9
+    service = WeatherClimateService(None, 'unused.json')
+    payload = {'end_date': end.isoformat(), 'calendar_averages': averages}
+    assert service._valid_summary(payload)
+    averages['09-14']['samples'] = 36
+    assert not service._valid_summary(payload)
+
+
+@pytest.mark.asyncio
+async def test_unpublished_tail_uses_actual_cutoff_and_reuses_cache(monkeypatch, tmp_path):
+    calls = []
+    def respond(request):
+        calls.append(request)
+        data = history()
+        for field in WeatherClimateService.expected_units:
+            data['daily'][field][-2:] = [None, None]
+        return httpx.Response(200, json=data)
+    client = httpx.AsyncClient
+    monkeypatch.setattr(httpx, 'AsyncClient', lambda **kwargs: client(transport=httpx.MockTransport(respond), **kwargs))
+    factory = lambda: SimpleNamespace(resolve_astral_location=lambda **kwargs: {'lat': 0, 'lon': 0, 'tz': 'UTC'})
+    service = WeatherClimateService(factory, tmp_path / 'cache.json')
+    await service._load()
+    assert service.payload['status'] == 'ready'
+    assert service.payload['end_date'] == '2020-12-29'
+    assert service.payload['requested_end_date'] == '2020-12-31'
+    assert service.payload['calendar_averages']['12-30']['samples'] == 29
+    await service._load()
+    assert len(calls) == 1
+    data = history()
+    data['daily']['rain_sum'][100] = None
+    trimmed, end = service._available_history(data, END)
+    with pytest.raises(ValueError):
+        service._summarize(trimmed, end)
+    data = history()
+    data['daily']['rain_sum'][-8:] = [None] * 8
+    with pytest.raises(ValueError):
+        service._available_history(data, END)
diff --git a/tests/rain-gauges.spec.js b/tests/rain-gauges.spec.js
new file mode 100644
index 0000000..1f3faa2
--- /dev/null
+++ b/tests/rain-gauges.spec.js
@@ -0,0 +1,63 @@
+import { test, expect } from '@playwright/test';
+
+const maxima = { day: 50.8, week: 127, month: 254, year: 1016 };
+
+for (const units of ['Metric', 'Imperial']) {
+  test(`rain gauges load historical limits and blue bands in ${units}`, async ({ page }, testInfo) => {
+    await page.route('https://cdn.jsdelivr.net/**', route => route.fulfill({ contentType: 'application/javascript', body: '' }));
+    let calls = 0;
+    await page.route('**/api/rain-climate', route => route.fulfill({ json: ++calls === 1
+      ? { status: 'warming' }
+      : { status: 'ready', maxima_mm: maxima } }));
+    await page.goto(`/rain-gauges?unit_system=${units}`, { waitUntil: 'domcontentloaded' });
+    const cards = page.locator('.metric-container');
+    await expect(cards).toHaveCount(6);
+    await expect(cards.first()).toHaveAttribute('data-rain-climate-status', 'ready', { timeout: 10000 });
+    await expect(page.locator('.rain-climate-note')).toHaveCount(0);
+    const scales = await cards.evaluateAll(nodes => nodes.map(node => ({max: Number(node.dataset.rainGaugeMax), period: node.dataset.rainGaugePeriod})));
+    for (const config of scales) {
+      const expected = maxima[config.period] / (units === 'Metric' ? 1 : 25.4);
+      expect(config.max).toBeCloseTo(expected);
+    }
+    await expect(cards.nth(1).locator('.metric-current-value')).toContainText(units === 'Metric' ? '6.35 mm' : '0.25 in');
+    await page.screenshot({ path: testInfo.outputPath(`rain-${units}.png`), fullPage: true });
+  });
+}
+
+test('rain gauges retain defaults when climate history fails', async ({ page }) => {
+  await page.route('https://cdn.jsdelivr.net/**', route => route.fulfill({ contentType: 'application/javascript', body: '' }));
+  await page.route('**/api/rain-climate', route => route.fulfill({ status: 503, body: '' }));
+  await page.goto('/rain-gauges', { waitUntil: 'domcontentloaded' });
+  await expect(page.locator('.metric-container').first()).toHaveAttribute('data-rain-climate-status', 'unavailable');
+  await expect(page.locator('.rain-climate-note')).toHaveCount(0);
+  await expect(page.locator('.metric-container[data-metric="Rain Day"]')).toHaveAttribute('data-rain-gauge-max', '508');
+  await expect(page.locator('.metric-current-value').nth(1)).toContainText('6.35 mm');
+});
+
+test('an existing GaugeJS instance receives new limits and labels', async ({ page }) => {
+  await page.route('https://cdn.jsdelivr.net/**', route => route.fulfill({ contentType: 'application/javascript', body: '' }));
+  await page.addInitScript(() => {
+    window.rainTestGauges = [];
+    window.Gauge = class {
+      constructor(canvas) { this.canvas = canvas; window.rainTestGauges.push(this); }
+      setOptions(options) { this.options = options; return this; }
+      setMinValue(value) { this.minValue = value; }
+      set(value) { this.value = value; }
+      render() {}
+    };
+  });
+  let calls = 0;
+  await page.route('**/api/rain-climate', route => route.fulfill({ json: ++calls === 1
+    ? { status: 'warming' } : { status: 'ready', maxima_mm: maxima } }));
+  await page.goto('/rain-gauges', { waitUntil: 'domcontentloaded' });
+  await expect(page.locator('.metric-container').first()).toHaveAttribute('data-rain-climate-status', 'ready', { timeout: 10000 });
+  await expect(page.locator('.rain-climate-note')).toHaveCount(0);
+  const gauges = await page.evaluate(() => window.rainTestGauges.map(g => ({ max: g.maxValue, labels: g.options.staticLabels.labels, colors: g.options.staticZones.map(z => z.strokeStyle), limited: g.options.limitMax })));
+  expect(gauges).toHaveLength(6);
+  expect(gauges.map(g => g.max)).toEqual([50.8, 50.8, 50.8, 127, 254, 1016]);
+  for (const gauge of gauges) {
+    expect(gauge.limited).toBe(true);
+    expect(gauge.labels.at(-1)).toBe(gauge.max);
+    expect(gauge.colors).toEqual(['#add8e6', '#66b2ff', '#0033cc']);
+  }
+});
diff --git a/tests/weather-forecast.spec.js b/tests/weather-forecast.spec.js
index c6648c9..d81767f 100644
--- a/tests/weather-forecast.spec.js
+++ b/tests/weather-forecast.spec.js
@@ -18,7 +18,17 @@ for (const budget of cardBudgets) {
       await expect(card.locator('.forecast-synopsis')).toContainText('then rain showers around 8 PM');
       await expect(card.locator('.forecast-hour:visible').first()).toContainText('RH 55%');
       await expect(card.locator('.forecast-hour:visible').first()).toContainText(units === 'Metric' ? 'Wind 14 km/h' : 'Wind 9 mph');
+      const initialHeight = (await card.boundingBox()).height;
+      const history = card.locator('[data-weather-history]');
+      await expect(history).toHaveAttribute('data-status', 'ready');
+      await expect(history).toContainText('Historical daily average 1991–2026 for 18-Sep-2026');
+      await expect(history).toHaveAttribute('title', /through 2026-09-13.*35 samples/);
+      await expect(history.locator('[data-history-value="temperature_c"]')).toHaveText(units === 'Metric' ? '20.0°C' : '68.0°F');
+      await expect(history.locator('[data-history-value="humidity_pct"]')).toHaveText('55%');
+      await expect(history.locator('[data-history-value="wind_kmh"]')).toHaveText(units === 'Metric' ? '16.1 km/h' : '10.0 mph');
+      await expect(history.locator('[data-history-value="rain_mm"]')).toHaveText(units === 'Metric' ? '2.5 mm' : '0.10 in');
       const originalHeight = (await card.boundingBox()).height;
+      expect(originalHeight).toBe(initialHeight);
       const days = card.locator('.forecast-day');
       await expect(days).toHaveCount(6);
       for (const day of await days.all()) {
@@ -60,3 +70,17 @@ test('all nine bundled glyphs render without remote assets or emoji fonts', asyn
   }
   await page.screenshot({ path: testInfo.outputPath('nine-weather-glyphs.png') });
 });
+
+
+test('historical averages load asynchronously and show missing values without changing card height', async ({ page }) => {
+  let calls = 0;
+  await page.route('**/api/weather-climate', route => route.fulfill({ json: ++calls === 1
+    ? { status: 'warming' } : { status: 'unavailable' } }));
+  await page.goto('/weather-forecast', { waitUntil: 'domcontentloaded' });
+  const row = page.locator('[data-weather-history]');
+  await expect(row).toHaveAttribute('data-status', 'warming');
+  const height = (await page.locator('.forecast-panel').boundingBox()).height;
+  await expect(row).toHaveAttribute('data-status', 'unavailable', { timeout: 10000 });
+  await expect(row.locator('[data-history-value]')).toHaveText(['—', '—', '—', '—']);
+  expect((await page.locator('.forecast-panel').boundingBox()).height).toBe(height);
+});
diff --git a/ui_static/js/rain_gauges.js b/ui_static/js/rain_gauges.js
new file mode 100644
index 0000000..5772101
--- /dev/null
+++ b/ui_static/js/rain_gauges.js
@@ -0,0 +1,60 @@
+/* Location-based rain limits are loaded independently of sensor readings. */
+"use strict";
+export function startRainGauges(gaugeConfig, initGauge) {
+  const defaults = new Map(Object.entries(gaugeConfig)
+    .filter(([, config]) => config.rain_period)
+    .map(([metric, config]) => [metric, JSON.parse(JSON.stringify(config))]));
+  let timer;
+  let stopped = false;
+
+  function apply(payload) {
+    let changed = false;
+    for (const [metric, original] of defaults) {
+      const config = gaugeConfig[metric];
+      const maximumMM = payload.maxima_mm?.[config.rain_period];
+      const ready = payload.status === "ready" && Number.isFinite(maximumMM) && maximumMM >= 0;
+      // Keep a usable axis even where the baseline contains no rain.
+      const maximum = ready ? Math.round(Math.max(1, maximumMM) / 25.4 * (config.display_factor || 1) * 1e6) / 1e6 : original.max;
+      if (config.max !== maximum) {
+        changed = true;
+        config.min = 0;
+        config.max = maximum;
+        config.ticks = ready ? [0, .2, .4, .6, .8, 1].map(f => f * maximum) : original.ticks;
+        config.zones = ready ? [
+          { strokeStyle: "#add8e6", min: 0, max: maximum * .2 },
+          { strokeStyle: "#66b2ff", min: maximum * .2, max: maximum * .6 },
+          { strokeStyle: "#0033cc", min: maximum * .6, max: maximum },
+        ] : original.zones;
+      }
+      for (const container of document.querySelectorAll('.metric-container')) {
+        if (container.dataset.metric !== metric) continue;
+        container.dataset.rainGaugeMax = String(maximum);
+        container.dataset.rainGaugePeriod = config.rain_period;
+        container.dataset.rainClimateStatus = ready ? 'ready' : payload.status;
+      }
+    }
+    if (changed && typeof initGauge === 'function') initGauge();
+  }
+
+  async function refresh() {
+    if (stopped) return;
+    const hasRain = [...document.querySelectorAll('.metric-container')].some(node => defaults.has(node.dataset.metric));
+    let delay = 300000;
+    if (hasRain) {
+      try {
+        const response = await fetch('/api/rain-climate', { signal: AbortSignal.timeout(10000), cache: 'no-store' });
+        if (!response.ok) throw new Error('Rain climate request failed');
+        const payload = await response.json();
+        apply(payload);
+        if (payload.status === 'warming') delay = 3000;
+      } catch (_) {
+        apply({ status: 'unavailable' });
+      }
+    }
+    if (!stopped) timer = setTimeout(refresh, delay);
+  }
+  addEventListener('pagehide', () => { stopped = true; clearTimeout(timer); });
+  addEventListener('pageshow', event => { if (event.persisted) { stopped = false; refresh(); } });
+  apply({ status: 'warming' });
+  refresh();
+}
diff --git a/ui_static/weather_forecast/app.css b/ui_static/weather_forecast/app.css
index 7b8c2db..c71cb2c 100644
--- a/ui_static/weather_forecast/app.css
+++ b/ui_static/weather_forecast/app.css
@@ -533,6 +533,11 @@ body.caelus-theme-preview-mode .dashboard-return { opacity: 0; pointer-events: n
 .forecast-ranges { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 0.3rem; }
 .forecast-ranges > span { color: var(--muted); font-size: 0.52rem; text-align: center; }
 .forecast-ranges strong { display: block; color: var(--ink); font-size: 0.68rem; }
+.forecast-history { margin-top: 0.3rem; text-align: center; }
+.forecast-history-label { display: block; color: var(--muted); font-size: 0.46rem; line-height: 1.25; text-decoration: none; }
+.forecast-history-label:hover { text-decoration: underline; }
+.forecast-history .forecast-ranges > span { color: var(--ink); font-size: 0.58rem; line-height: 1.4; }
+.forecast-history + .forecast-synopsis { margin-top: 0.3rem; }
 .forecast-synopsis { height: 3.4rem; overflow: auto; margin: 0.6rem 0 0; font-size: 0.66rem; line-height: 1.3; }
 .forecast-synopsis:focus-visible { outline: 1px solid var(--accent-2); }
 .hourly-carousel { display: grid; grid-template-columns: 1.15rem minmax(0, 1fr) 1.15rem; align-items: stretch; gap: 0.25rem; margin-top: 1rem; }
diff --git a/ui_static/weather_forecast/app.js b/ui_static/weather_forecast/app.js
index d70e29b..0e00cbb 100644
--- a/ui_static/weather_forecast/app.js
+++ b/ui_static/weather_forecast/app.js
@@ -206,6 +206,60 @@
     readingsTimer = window.setTimeout(refreshCurrentReadings, seconds * 1000);
   }
 
+  let historyTimer;
+  let historyInFlight = false;
+  let historyStopped = false;
+  async function refreshHistoricalAverages() {
+    if (historyInFlight || historyStopped) return;
+    clearTimeout(historyTimer);
+    let delay = 300000;
+    historyInFlight = true;
+    try {
+      if (!document.hidden && document.querySelector('[data-weather-history]')) {
+        const response = await fetch('/api/weather-climate', { cache: 'no-store', signal: AbortSignal.timeout(10000) });
+        if (!response.ok) throw new Error('Historical daily averages unavailable');
+        const payload = await response.json();
+        renderHistoricalAverages(payload);
+        if (payload.status === 'warming') delay = 3000;
+      }
+    } catch (_) {
+      renderHistoricalAverages({ status: 'unavailable' });
+    } finally {
+      historyInFlight = false;
+      if (!historyStopped) historyTimer = setTimeout(refreshHistoricalAverages, delay);
+    }
+  }
+
+  function renderHistoricalAverages(payload) {
+    const row = document.querySelector('[data-weather-history]');
+    if (!row) return;
+    const ready = payload.status === 'ready';
+    const imperial = row.dataset.unitSystem === 'Imperial';
+    const averages = ready ? payload.averages || {} : {};
+    const format = (value, factor, offset, digits, unit) => Number.isFinite(value)
+      ? (value * factor + offset).toFixed(digits) + unit : '—';
+    const values = {
+      temperature_c: format(averages.temperature_c, imperial ? 1.8 : 1, imperial ? 32 : 0, 1, imperial ? '°F' : '°C'),
+      humidity_pct: format(averages.humidity_pct, 1, 0, 0, '%'),
+      wind_kmh: format(averages.wind_kmh, imperial ? 1 / 1.609344 : 1, 0, 1, imperial ? ' mph' : ' km/h'),
+      rain_mm: format(averages.rain_mm, imperial ? 1 / 25.4 : 1, 0, imperial ? 2 : 1, imperial ? ' in' : ' mm'),
+    };
+    row.querySelectorAll('[data-history-value]').forEach(node => { node.textContent = values[node.dataset.historyValue]; });
+    row.dataset.status = payload.status;
+    const dateParts = /^(\d{4})-(\d{2})-(\d{2})$/.exec(payload.date || '');
+    const monthNames = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+    const displayDate = dateParts && monthNames[Number(dateParts[2]) - 1]
+      ? `${dateParts[3]}-${monthNames[Number(dateParts[2]) - 1]}-${dateParts[1]}` : '';
+    row.querySelector('.forecast-history-label').textContent = ready && payload.baseline && displayDate
+      ? `Historical daily average ${payload.baseline} for ${displayDate}` : 'Historical daily average since 1991';
+    row.title = ready
+      ? `Daily average for the same calendar date as ${payload.date} across available years, using history from ${payload.start_date || "1991-01-01"} through ${payload.end_date || "the latest available date"} at the hub location (${averages.samples || "available"} samples). Open-Meteo / ERA5. Rain is a daily amount, not a probability; dry days are included.`
+      : (payload.status === 'warming' ? 'Historical daily averages are loading' : 'Historical daily averages are unavailable');
+  }
+  refreshHistoricalAverages();
+  window.addEventListener('pagehide', () => { historyStopped = true; clearTimeout(historyTimer); });
+  window.addEventListener('pageshow', event => { if (event.persisted) { historyStopped = false; refreshHistoricalAverages(); } });
+
   let forecastHour = Math.floor(Date.now() / (60 * 60 * 1000));
   let forecastTimer = 0;
   async function refreshHourlyForecast() {
@@ -220,6 +274,7 @@
             currentPanel.replaceWith(nextPanel);
             initializeHourlyCarousels(nextPanel);
             initializeForecastButtons(nextPanel);
+            refreshHistoricalAverages();
           }
           forecastHour = Math.floor(Date.now() / (60 * 60 * 1000));
         }
diff --git a/ui_templates/weather_forecast/index.html b/ui_templates/weather_forecast/index.html
index 6b64226..be4d73b 100644
--- a/ui_templates/weather_forecast/index.html
+++ b/ui_templates/weather_forecast/index.html
@@ -60,6 +60,10 @@ <h1 id="station-title">{{ location.name or 'Your weather, alive.' }}</h1>
             <span class="forecast-main-icon">{{ weather_icon(forecast.icon_key, forecast.condition) }}</span>
             <div class="forecast-summary-content">
               <div class="forecast-ranges"><span><strong>{{ reading(forecast.low, forecast.temperature_unit) }}–{{ reading(forecast.high, forecast.temperature_unit) }}</strong>Temperature</span><span><strong>{{ forecast.rh_range }}</strong>RH</span><span><strong>{{ forecast.wind_range }}</strong>Wind</span><span><strong>{{ reading(forecast.precip_probability, '%') }}</strong> {{ forecast.precip_label }}</span></div>
+              <div class="forecast-history" data-weather-history data-unit-system="{{ forecast.unit_system }}" aria-label="Historical daily averages">
+                <a class="forecast-history-label" href="https://open-meteo.com/en/docs/historical-weather-api" target="_blank" rel="noopener noreferrer">Historical daily average since 1991</a>
+                <div class="forecast-ranges"><span data-history-value="temperature_c" aria-label="Historical daily average temperature">—</span><span data-history-value="humidity_pct" aria-label="Historical daily average relative humidity">—</span><span data-history-value="wind_kmh" aria-label="Historical daily average wind speed">—</span><span data-history-value="rain_mm" aria-label="Historical daily average rainfall amount">—</span></div>
+              </div>
               <p class="forecast-synopsis" tabindex="0" aria-label="Forecast synopsis">{{ forecast.synopsis }}</p>
             </div>
           </div>

From d7e34400706019605f99aa16c21785fc32f49917 Mon Sep 17 00:00:00 2001
From: twfarley <mot.yelraf@gmail.com>
Date: Fri, 18 Sep 2026 10:49:43 -0600
Subject: [PATCH 2/2] Update project overview and integration highlights

---
 README.md | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 0ea0cbe..edf9bc9 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 **Environmental Sensing + Automation Hub**
 
-Sensorius is a Raspberry Pi-first sensor and automation hub with a full web UI, MQTT ingestion, and optional Home Assistant and farmOS integrations. It auto-detects local sensors, discovers Nodus devices over MQTT, and turns those signals into live dashboards, historical data, switch control, and optional farmOS telemetry export.
+Sensorius is a sensor, relay-switch automation hub with a robust web UI, MQTT ingestion, and optional Home Assistant and farmOS integrations, with a focus on gardening, farming, greenhouse monitor and control. When using Raspberry Pi's it can auto-detects directly-connected sensors, relay-switch(es) and on all supported platforms it automatically discovers Nodus WiFi/MQTT devices, and turns those data into live dashboards, automation controls, historical data; the application also includes integrated weather forecast and biodynamic calendar .
 
 For illustrated setup and operating instructions, see the
 [Sensorius AI User Guide](docs/user_guide.md).
@@ -10,7 +10,7 @@ For illustrated setup and operating instructions, see the
 ## What It Does
 
 - Auto-detects locally attached sensors (Raspberry Pi deployments)
-- Discovers Nodus sensors and switches via MQTT and retained `nodus/<device_id>/meta` metadata (`/itaot-meta` fallback for AP-mode/diagnostics)
+- Discovers Nodus sensors and switches via MQTT and retained `nodus/<device_id>/meta` metadata 
 - Stores sensor readings and switch events in a local SQLite database
 - Provides live dashboards, historical graphing, and location-based views
 - Shows Astral-based sun position and moon phase cards in the dashboard when location/timezone are available
@@ -18,6 +18,8 @@ For illustrated setup and operating instructions, see the
 - Supports calibration workflows for sensors
 - Can publish discovery/state for Home Assistant
 - Can export sensor telemetry to farmOS log entries
+- Integrated Caelus weather forecast
+- Integrated Biodynamic Calendar with hints, planting tracking and notes
 
 ## Deployment Modes