feat: upgrade Water, SAR, and Settlement indicators with seasonal analysis

Apply the same analytical upgrade pattern from NDVI to all three remaining
batch indicators:
- Seasonal baselines via compute_seasonal_stats_aoi
- Per-month z-score anomaly detection
- Pixel-level hotspot detection with compute_zscore_raster
- Four-factor confidence scoring
- Native resolution (Water 20m, SAR 10m, Settlement 20m)
- Seasonal envelope chart data with anomaly flags

SAR uses custom seasonal stats from VV means (interleaved VV/VH bands
can't go through compute_seasonal_stats_aoi directly).

Generated with [Claude Code](https://claude.ai/code)
via [Happy](https://happy.engineering)

Co-Authored-By: Claude <noreply@anthropic.com>
Co-Authored-By: Happy <yesreply@happy.engineering>

app/indicators/buildup.py

@@ -1,8 +1,9 @@
 """Built-up / Settlement Extent Indicator — NDBI via CDSE openEO.
 
 Computes monthly NDBI composites from Sentinel-2 L2A, classifies built-up
-pixels (NDBI > 0 AND NDVI < 0.2), and tracks settlement extent change
-against a baseline period.
+pixels (NDBI > 0), and tracks settlement extent change against a seasonal
+baseline using z-score analysis, hotspot detection, and four-factor
+confidence scoring.
 """
 from __future__ import annotations
 
@@ -15,7 +16,13 @@ from typing import Any
 import numpy as np
 import rasterio
 
-from app.config import RESOLUTION_M
+from app.config import (
+    BUILDUP_RESOLUTION_M,
+    TRUECOLOR_RESOLUTION_M,
+    MIN_STD_BUILDUP,
+    ZSCORE_THRESHOLD,
+    MIN_CLUSTER_PIXELS,
+)
 from app.indicators.base import BaseIndicator, SpatialData
 from app.models import (
     AOI,
@@ -26,6 +33,14 @@ from app.models import (
     ConfidenceLevel,
 )
 from app.openeo_client import get_connection, build_buildup_graph, build_true_color_graph, _bbox_dict, submit_as_batch
+from app.analysis.seasonal import (
+    group_bands_by_calendar_month,
+    compute_seasonal_stats_aoi,
+    compute_seasonal_stats_pixel,
+    compute_zscore,
+)
+from app.analysis.change import compute_zscore_raster, detect_hotspots, cluster_hotspots
+from app.analysis.confidence import compute_confidence
 
 logger = logging.getLogger(__name__)
 
@@ -57,22 +72,26 @@ class BuiltupIndicator(BaseIndicator):
             time_range.start.month,
             time_range.start.day,
         ).isoformat()
-        baseline_end = time_range.start.isoformat()
+        baseline_end = date(
+            time_range.start.year,
+            time_range.start.month,
+            time_range.start.day,
+        ).isoformat()
 
         current_cube = build_buildup_graph(
             conn=conn, bbox=bbox,
             temporal_extent=[current_start, current_end],
-            resolution_m=RESOLUTION_M,
+            resolution_m=BUILDUP_RESOLUTION_M,
         )
         baseline_cube = build_buildup_graph(
             conn=conn, bbox=bbox,
             temporal_extent=[baseline_start, baseline_end],
-            resolution_m=RESOLUTION_M,
+            resolution_m=BUILDUP_RESOLUTION_M,
         )
         true_color_cube = build_true_color_graph(
             conn=conn, bbox=bbox,
             temporal_extent=[current_start, current_end],
-            resolution_m=RESOLUTION_M,
+            resolution_m=TRUECOLOR_RESOLUTION_M,
         )
 
         return [
@@ -121,44 +140,105 @@ class BuiltupIndicator(BaseIndicator):
 
         self._true_color_path = true_color_path
 
+        # --- Seasonal baseline analysis ---
         current_stats = self._compute_stats(current_path)
+        current_mean = current_stats["overall_mean"]
         current_frac = current_stats["overall_buildup_fraction"]
+        n_current_bands = current_stats["valid_months"]
         aoi_ha = aoi.area_km2 * 100  # km² → hectares
         current_ha = current_frac * aoi_ha
 
+        spatial_completeness = self._compute_spatial_completeness(current_path)
+
         if baseline_path:
+            seasonal_stats = compute_seasonal_stats_aoi(baseline_path, n_years=BASELINE_YEARS)
             baseline_stats = self._compute_stats(baseline_path)
             baseline_frac = baseline_stats["overall_buildup_fraction"]
             baseline_ha = baseline_frac * aoi_ha
 
-            if baseline_frac > 0:
-                change_pct = ((current_frac - baseline_frac) / baseline_frac) * 100
-            else:
-                change_pct = 100.0 if current_frac > 0 else 0.0
+            start_month = time_range.start.month
+            most_recent_month = ((start_month + n_current_bands - 2) % 12) + 1
 
-            confidence = (
-                ConfidenceLevel.HIGH if current_stats["valid_months"] >= 6
-                else ConfidenceLevel.MODERATE if current_stats["valid_months"] >= 3
-                else ConfidenceLevel.LOW
+            # Z-score for overall current mean NDBI vs seasonal baseline
+            if most_recent_month in seasonal_stats and seasonal_stats[most_recent_month]["n_years"] > 0:
+                s = seasonal_stats[most_recent_month]
+                z_current = compute_zscore(current_mean, s["mean"], s["std"], MIN_STD_BUILDUP)
+            else:
+                z_current = 0.0
+
+            # Per-month z-scores and anomaly count
+            anomaly_months = 0
+            monthly_zscores = []
+            for i, val in enumerate(current_stats["monthly_means"]):
+                cal_month = ((start_month + i - 1) % 12) + 1
+                if cal_month in seasonal_stats and seasonal_stats[cal_month]["n_years"] > 0:
+                    z = compute_zscore(val, seasonal_stats[cal_month]["mean"],
+                                       seasonal_stats[cal_month]["std"], MIN_STD_BUILDUP)
+                    monthly_zscores.append(z)
+                    if abs(z) > ZSCORE_THRESHOLD:
+                        anomaly_months += 1
+                else:
+                    monthly_zscores.append(0.0)
+
+            # Pixel-level hotspot detection
+            month_map = group_bands_by_calendar_month(baseline_stats["valid_months_total"], BASELINE_YEARS)
+            hotspot_pct = 0.0
+            self._zscore_raster = None
+            self._hotspot_mask = None
+            if most_recent_month in month_map and len(month_map[most_recent_month]) > 0:
+                pixel_stats = compute_seasonal_stats_pixel(baseline_path, month_map[most_recent_month])
+                with rasterio.open(current_path) as src:
+                    current_band_idx = min(n_current_bands, src.count)
+                    current_data = src.read(current_band_idx).astype(np.float32)
+                    if src.nodata is not None:
+                        current_data[current_data == src.nodata] = np.nan
+
+                z_raster = compute_zscore_raster(current_data, pixel_stats["mean"],
+                                                  pixel_stats["std"], MIN_STD_BUILDUP)
+                hotspot_mask, hotspot_pct = detect_hotspots(z_raster, ZSCORE_THRESHOLD)
+                self._zscore_raster = z_raster
+                self._hotspot_mask = hotspot_mask
+
+            # Four-factor confidence scoring
+            baseline_depth = sum(1 for m in range(1, 13)
+                                 if m in seasonal_stats and seasonal_stats[m]["n_years"] > 0)
+            mean_baseline_years = (sum(seasonal_stats[m]["n_years"] for m in range(1, 13)
+                                       if m in seasonal_stats) / max(baseline_depth, 1))
+            conf = compute_confidence(
+                valid_months=n_current_bands,
+                mean_obs_per_composite=5.0,
+                baseline_years_with_data=int(mean_baseline_years),
+                spatial_completeness=spatial_completeness,
             )
+            confidence = conf["level"]
+            confidence_factors = conf["factors"]
 
-            chart_data = self._build_chart_data(
-                current_stats["monthly_buildup_fractions"],
-                baseline_stats["monthly_buildup_fractions"],
-                time_range,
-                aoi_ha,
-            )
+            status = self._classify_zscore(z_current, hotspot_pct)
+            trend = self._compute_trend_zscore(monthly_zscores)
 
-            status = self._classify(change_pct)
-            trend = self._compute_trend(change_pct)
+            chart_data = self._build_seasonal_chart_data(
+                current_stats["monthly_buildup_fractions"], seasonal_stats,
+                time_range, monthly_zscores, aoi_ha,
+            )
 
-            if abs(change_pct) < 10:
-                headline = f"Built-up extent stable at approximately {current_ha:.0f} ha"
-            elif change_pct > 0:
-                headline = f"Settlement area expanded {change_pct:.0f}% ({baseline_ha:.0f} → {current_ha:.0f} ha) compared to baseline"
+            # Headline — z-score driven, with hectare context
+            if abs(z_current) <= 1.0:
+                headline = (
+                    f"Settlement extent stable at ~{current_ha:.0f} ha "
+                    f"(z={z_current:+.1f})"
+                )
+            elif z_current > 0:
+                headline = (
+                    f"Settlement expansion detected: {current_ha:.0f} ha "
+                    f"(z={z_current:+.1f} above seasonal baseline)"
+                )
             else:
-                headline = f"Potential settlement contraction: {abs(change_pct):.0f}% decrease in built-up area"
+                headline = (
+                    f"Settlement contraction detected: {current_ha:.0f} ha "
+                    f"(z={z_current:+.1f} below seasonal baseline)"
+                )
 
+            # Write change raster for map rendering
             change_map_path = os.path.join(results_dir, "buildup_change.tif")
             self._write_change_raster(current_path, baseline_path, change_map_path)
 
@@ -181,31 +261,46 @@ class BuiltupIndicator(BaseIndicator):
                 map_layer_path=change_map_path,
                 chart_data=chart_data,
                 data_source="satellite",
+                anomaly_months=anomaly_months,
+                z_score_current=round(z_current, 2),
+                hotspot_pct=round(hotspot_pct, 1),
+                confidence_factors=confidence_factors,
                 summary=(
                     f"Built-up area covers {current_frac*100:.1f}% of the AOI "
-                    f"({current_ha:.0f} ha) compared to {baseline_frac*100:.1f}% baseline "
-                    f"({baseline_ha:.0f} ha), a {change_pct:+.1f}% change. "
-                    f"Pixel-level NDBI analysis at {RESOLUTION_M}m resolution."
+                    f"({current_ha:.0f} ha), mean NDBI {current_mean:.3f} "
+                    f"(z-score {z_current:+.1f} vs seasonal baseline). "
+                    f"{anomaly_months} of {n_current_bands} months show significant anomalies. "
+                    f"{hotspot_pct:.0f}% of AOI has statistically significant change. "
+                    f"Pixel-level NDBI analysis at {BUILDUP_RESOLUTION_M}m resolution."
                 ),
                 methodology=(
-                    f"Sentinel-2 L2A pixel-level NDBI = (B11 − B08) / (B11 + B08). "
+                    f"Sentinel-2 L2A pixel-level NDBI = (B11 \u2212 B08) / (B11 + B08). "
                     f"Built-up classified as NDBI > {NDBI_THRESHOLD}. "
                     f"Cloud-masked using SCL band. "
-                    f"Monthly median composites at {RESOLUTION_M}m. "
-                    f"Baseline: {BASELINE_YEARS}-year built-up extent. "
+                    f"Monthly median composites at {BUILDUP_RESOLUTION_M}m native resolution. "
+                    f"Baseline: {BASELINE_YEARS}-year seasonal baselines (per calendar month). "
+                    f"Anomaly detection via z-scores (threshold: \u00b1{ZSCORE_THRESHOLD}). "
                     f"Processed via CDSE openEO batch jobs."
                 ),
                 limitations=[
-                    f"Resampled to {RESOLUTION_M}m — detects settlement extent, not individual buildings.",
+                    f"Resampled to {BUILDUP_RESOLUTION_M}m \u2014 detects settlement extent, not individual buildings.",
                     "NDBI may confuse bare rock/sand with built-up in arid landscapes.",
                     "Seasonal vegetation cycles can cause false positives at settlement fringes.",
                     "For building-level analysis, the SR4S pipeline (GPU-dependent) would be needed.",
+                    "Z-score anomalies assume baseline is representative of normal conditions.",
                 ],
             )
         else:
             # Degraded mode — no baseline
-            change_pct = 0.0
+            z_current = 0.0
+            anomaly_months = 0
+            hotspot_pct = 0.0
             confidence = ConfidenceLevel.LOW
+            confidence_factors = {}
+            status = StatusLevel.GREEN
+            trend = TrendDirection.STABLE
+            self._zscore_raster = None
+            self._hotspot_mask = None
             peak_band = current_stats["peak_buildup_band"]
 
             chart_data = {
@@ -214,7 +309,7 @@ class BuiltupIndicator(BaseIndicator):
                 "label": "Built-up area (ha)",
             }
 
-            headline = f"Built-up extent: {current_frac*100:.1f}% — baseline unavailable"
+            headline = f"Built-up extent: {current_frac*100:.1f}% ({current_ha:.0f} ha) \u2014 baseline unavailable"
 
             self._spatial_data = SpatialData(
                 map_type="raster",
@@ -229,30 +324,34 @@ class BuiltupIndicator(BaseIndicator):
             return IndicatorResult(
                 indicator_id=self.id,
                 headline=headline,
-                status=self._classify(change_pct),
-                trend=TrendDirection.STABLE,
+                status=status,
+                trend=trend,
                 confidence=confidence,
                 map_layer_path=current_path,
                 chart_data=chart_data,
                 data_source="satellite",
+                anomaly_months=anomaly_months,
+                z_score_current=round(z_current, 2),
+                hotspot_pct=round(hotspot_pct, 1),
+                confidence_factors=confidence_factors,
                 summary=(
                     f"Built-up area covers {current_frac*100:.1f}% of the AOI "
-                    f"({current_ha:.0f} ha). Baseline unavailable — change not computed. "
-                    f"Pixel-level NDBI analysis at {RESOLUTION_M}m resolution."
+                    f"({current_ha:.0f} ha). Baseline unavailable \u2014 change not computed. "
+                    f"Pixel-level NDBI analysis at {BUILDUP_RESOLUTION_M}m resolution."
                 ),
                 methodology=(
-                    f"Sentinel-2 L2A pixel-level NDBI = (B11 − B08) / (B11 + B08). "
+                    f"Sentinel-2 L2A pixel-level NDBI = (B11 \u2212 B08) / (B11 + B08). "
                     f"Built-up classified as NDBI > {NDBI_THRESHOLD}. "
                     f"Cloud-masked using SCL band. "
-                    f"Monthly median composites at {RESOLUTION_M}m. "
+                    f"Monthly median composites at {BUILDUP_RESOLUTION_M}m. "
                     f"Processed via CDSE openEO batch jobs."
                 ),
                 limitations=[
-                    f"Resampled to {RESOLUTION_M}m — detects settlement extent, not individual buildings.",
+                    f"Resampled to {BUILDUP_RESOLUTION_M}m \u2014 detects settlement extent, not individual buildings.",
                     "NDBI may confuse bare rock/sand with built-up in arid landscapes.",
                     "Seasonal vegetation cycles can cause false positives at settlement fringes.",
                     "For building-level analysis, the SR4S pipeline (GPU-dependent) would be needed.",
-                    "Baseline unavailable — change and trend not computed.",
+                    "Baseline unavailable \u2014 change and trend not computed.",
                 ],
             )
 
@@ -276,24 +375,28 @@ class BuiltupIndicator(BaseIndicator):
             time_range.start.month,
             time_range.start.day,
         ).isoformat()
-        baseline_end = time_range.start.isoformat()
+        baseline_end = date(
+            time_range.start.year,
+            time_range.start.month,
+            time_range.start.day,
+        ).isoformat()
 
         results_dir = tempfile.mkdtemp(prefix="aperture_buildup_")
 
         current_cube = build_buildup_graph(
             conn=conn, bbox=bbox,
             temporal_extent=[current_start, current_end],
-            resolution_m=RESOLUTION_M,
+            resolution_m=BUILDUP_RESOLUTION_M,
         )
         baseline_cube = build_buildup_graph(
             conn=conn, bbox=bbox,
             temporal_extent=[baseline_start, baseline_end],
-            resolution_m=RESOLUTION_M,
+            resolution_m=BUILDUP_RESOLUTION_M,
         )
         true_color_cube = build_true_color_graph(
             conn=conn, bbox=bbox,
             temporal_extent=[current_start, current_end],
-            resolution_m=RESOLUTION_M,
+            resolution_m=TRUECOLOR_RESOLUTION_M,
         )
 
         loop = asyncio.get_event_loop()
@@ -301,7 +404,6 @@ class BuiltupIndicator(BaseIndicator):
         baseline_path = os.path.join(results_dir, "ndbi_baseline.tif")
         true_color_path = os.path.join(results_dir, "true_color.tif")
 
-        # 10-minute timeout per download
         timeout = 600
         await asyncio.wait_for(
             loop.run_in_executor(None, current_cube.download, current_path), timeout=timeout
@@ -315,44 +417,99 @@ class BuiltupIndicator(BaseIndicator):
 
         self._true_color_path = true_color_path
 
+        # --- Seasonal baseline analysis ---
         current_stats = self._compute_stats(current_path)
         baseline_stats = self._compute_stats(baseline_path)
-
+        current_mean = current_stats["overall_mean"]
         current_frac = current_stats["overall_buildup_fraction"]
-        baseline_frac = baseline_stats["overall_buildup_fraction"]
-
-        # Convert fractions to area using AOI size
+        n_current_bands = current_stats["valid_months"]
         aoi_ha = aoi.area_km2 * 100  # km² → hectares
         current_ha = current_frac * aoi_ha
+        baseline_frac = baseline_stats["overall_buildup_fraction"]
         baseline_ha = baseline_frac * aoi_ha
 
-        if baseline_frac > 0:
-            change_pct = ((current_frac - baseline_frac) / baseline_frac) * 100
+        spatial_completeness = self._compute_spatial_completeness(current_path)
+
+        seasonal_stats = compute_seasonal_stats_aoi(baseline_path, n_years=BASELINE_YEARS)
+        start_month = time_range.start.month
+        most_recent_month = ((start_month + n_current_bands - 2) % 12) + 1
+
+        # Z-score for overall current mean NDBI vs seasonal baseline
+        if most_recent_month in seasonal_stats and seasonal_stats[most_recent_month]["n_years"] > 0:
+            s = seasonal_stats[most_recent_month]
+            z_current = compute_zscore(current_mean, s["mean"], s["std"], MIN_STD_BUILDUP)
         else:
-            change_pct = 100.0 if current_frac > 0 else 0.0
-
-        status = self._classify(change_pct)
-        trend = self._compute_trend(change_pct)
-        confidence = (
-            ConfidenceLevel.HIGH if current_stats["valid_months"] >= 6
-            else ConfidenceLevel.MODERATE if current_stats["valid_months"] >= 3
-            else ConfidenceLevel.LOW
+            z_current = 0.0
+
+        # Per-month z-scores and anomaly count
+        anomaly_months = 0
+        monthly_zscores = []
+        for i, val in enumerate(current_stats["monthly_means"]):
+            cal_month = ((start_month + i - 1) % 12) + 1
+            if cal_month in seasonal_stats and seasonal_stats[cal_month]["n_years"] > 0:
+                z = compute_zscore(val, seasonal_stats[cal_month]["mean"],
+                                   seasonal_stats[cal_month]["std"], MIN_STD_BUILDUP)
+                monthly_zscores.append(z)
+                if abs(z) > ZSCORE_THRESHOLD:
+                    anomaly_months += 1
+            else:
+                monthly_zscores.append(0.0)
+
+        # Pixel-level hotspot detection
+        month_map = group_bands_by_calendar_month(baseline_stats["valid_months_total"], BASELINE_YEARS)
+        hotspot_pct = 0.0
+        self._zscore_raster = None
+        self._hotspot_mask = None
+        if most_recent_month in month_map and len(month_map[most_recent_month]) > 0:
+            pixel_stats = compute_seasonal_stats_pixel(baseline_path, month_map[most_recent_month])
+            with rasterio.open(current_path) as src:
+                current_band_idx = min(n_current_bands, src.count)
+                current_data = src.read(current_band_idx).astype(np.float32)
+                if src.nodata is not None:
+                    current_data[current_data == src.nodata] = np.nan
+            z_raster = compute_zscore_raster(current_data, pixel_stats["mean"],
+                                              pixel_stats["std"], MIN_STD_BUILDUP)
+            hotspot_mask, hotspot_pct = detect_hotspots(z_raster, ZSCORE_THRESHOLD)
+            self._zscore_raster = z_raster
+            self._hotspot_mask = hotspot_mask
+
+        # Four-factor confidence scoring
+        baseline_depth = sum(1 for m in range(1, 13)
+                             if m in seasonal_stats and seasonal_stats[m]["n_years"] > 0)
+        mean_baseline_years = (sum(seasonal_stats[m]["n_years"] for m in range(1, 13)
+                                   if m in seasonal_stats) / max(baseline_depth, 1))
+        conf = compute_confidence(
+            valid_months=n_current_bands,
+            mean_obs_per_composite=5.0,
+            baseline_years_with_data=int(mean_baseline_years),
+            spatial_completeness=spatial_completeness,
         )
-
-        chart_data = self._build_chart_data(
-            current_stats["monthly_buildup_fractions"],
-            baseline_stats["monthly_buildup_fractions"],
-            time_range,
-            aoi_ha,
+        confidence = conf["level"]
+        confidence_factors = conf["factors"]
+
+        status = self._classify_zscore(z_current, hotspot_pct)
+        trend = self._compute_trend_zscore(monthly_zscores)
+        chart_data = self._build_seasonal_chart_data(
+            current_stats["monthly_buildup_fractions"], seasonal_stats,
+            time_range, monthly_zscores, aoi_ha,
         )
 
-        # Headline
-        if abs(change_pct) < 10:
-            headline = f"Built-up extent stable at approximately {current_ha:.0f} ha"
-        elif change_pct > 0:
-            headline = f"Settlement area expanded {change_pct:.0f}% ({baseline_ha:.0f} → {current_ha:.0f} ha) compared to baseline"
+        # Headline — z-score driven, with hectare context
+        if abs(z_current) <= 1.0:
+            headline = (
+                f"Settlement extent stable at ~{current_ha:.0f} ha "
+                f"(z={z_current:+.1f})"
+            )
+        elif z_current > 0:
+            headline = (
+                f"Settlement expansion detected: {current_ha:.0f} ha "
+                f"(z={z_current:+.1f} above seasonal baseline)"
+            )
         else:
-            headline = f"Potential settlement contraction: {abs(change_pct):.0f}% decrease in built-up area"
+            headline = (
+                f"Settlement contraction detected: {current_ha:.0f} ha "
+                f"(z={z_current:+.1f} below seasonal baseline)"
+            )
 
         # Write change raster for map rendering
         change_map_path = os.path.join(results_dir, "buildup_change.tif")
@@ -377,31 +534,39 @@ class BuiltupIndicator(BaseIndicator):
             map_layer_path=change_map_path,
             chart_data=chart_data,
             data_source="satellite",
+            anomaly_months=anomaly_months,
+            z_score_current=round(z_current, 2),
+            hotspot_pct=round(hotspot_pct, 1),
+            confidence_factors=confidence_factors,
             summary=(
                 f"Built-up area covers {current_frac*100:.1f}% of the AOI "
-                f"({current_ha:.0f} ha) compared to {baseline_frac*100:.1f}% baseline "
-                f"({baseline_ha:.0f} ha), a {change_pct:+.1f}% change. "
-                f"Pixel-level NDBI analysis at {RESOLUTION_M}m resolution."
+                f"({current_ha:.0f} ha), mean NDBI {current_mean:.3f} "
+                f"(z-score {z_current:+.1f} vs seasonal baseline). "
+                f"{anomaly_months} of {n_current_bands} months show significant anomalies. "
+                f"{hotspot_pct:.0f}% of AOI has statistically significant change. "
+                f"Pixel-level NDBI analysis at {BUILDUP_RESOLUTION_M}m resolution."
             ),
             methodology=(
-                f"Sentinel-2 L2A pixel-level NDBI = (B11 − B08) / (B11 + B08). "
+                f"Sentinel-2 L2A pixel-level NDBI = (B11 \u2212 B08) / (B11 + B08). "
                 f"Built-up classified as NDBI > {NDBI_THRESHOLD}. "
                 f"Cloud-masked using SCL band. "
-                f"Monthly median composites at {RESOLUTION_M}m. "
-                f"Baseline: {BASELINE_YEARS}-year built-up extent. "
-                f"Processed via CDSE openEO."
+                f"Monthly median composites at {BUILDUP_RESOLUTION_M}m native resolution. "
+                f"Baseline: {BASELINE_YEARS}-year seasonal baselines (per calendar month). "
+                f"Anomaly detection via z-scores (threshold: \u00b1{ZSCORE_THRESHOLD}). "
+                f"Processed server-side via CDSE openEO."
             ),
             limitations=[
-                f"Resampled to {RESOLUTION_M}m — detects settlement extent, not individual buildings.",
+                f"Resampled to {BUILDUP_RESOLUTION_M}m \u2014 detects settlement extent, not individual buildings.",
                 "NDBI may confuse bare rock/sand with built-up in arid landscapes.",
                 "Seasonal vegetation cycles can cause false positives at settlement fringes.",
                 "For building-level analysis, the SR4S pipeline (GPU-dependent) would be needed.",
+                "Z-score anomalies assume baseline is representative of normal conditions.",
             ],
         )
 
     @staticmethod
     def _compute_stats(tif_path: str) -> dict[str, Any]:
-        """Extract monthly built-up fraction from NDBI GeoTIFF.
+        """Extract monthly built-up fraction and raw NDBI stats from GeoTIFF.
 
         Built-up = NDBI > 0 (simplified; full pipeline would also check NDVI < 0.2
         but the graph builder only outputs NDBI).
@@ -409,6 +574,7 @@ class BuiltupIndicator(BaseIndicator):
         with rasterio.open(tif_path) as src:
             n_bands = src.count
             monthly_fractions: list[float] = []
+            monthly_means: list[float] = []
             peak_frac = -1.0
             peak_band = 1
             for band in range(1, n_bands + 1):
@@ -421,53 +587,114 @@ class BuiltupIndicator(BaseIndicator):
                 if len(valid) > 0:
                     buildup_pixels = np.sum(valid > NDBI_THRESHOLD)
                     frac = float(buildup_pixels / len(valid))
+                    mean_val = float(np.nanmean(valid))
                     monthly_fractions.append(frac)
+                    monthly_means.append(mean_val)
                     if frac > peak_frac:
                         peak_frac = frac
                         peak_band = band
                 else:
                     monthly_fractions.append(0.0)
+                    monthly_means.append(0.0)
 
-        overall = float(np.mean(monthly_fractions)) if monthly_fractions else 0.0
+        overall_frac = float(np.mean(monthly_fractions)) if monthly_fractions else 0.0
+        valid_months = sum(1 for m in monthly_means if m != 0.0)
+        overall_mean = (
+            float(np.mean([m for m in monthly_means if m != 0.0]))
+            if valid_months > 0 else 0.0
+        )
 
         return {
             "monthly_buildup_fractions": monthly_fractions,
-            "overall_buildup_fraction": overall,
-            "valid_months": len(monthly_fractions),
+            "overall_buildup_fraction": overall_frac,
+            "valid_months": valid_months,
+            "valid_months_total": n_bands,
             "peak_buildup_band": peak_band,
+            "overall_mean": overall_mean,
+            "monthly_means": monthly_means,
         }
 
     @staticmethod
-    def _classify(change_pct: float) -> StatusLevel:
-        abs_change = abs(change_pct)
-        if abs_change < 10:
-            return StatusLevel.GREEN
-        if abs_change < 30:
+    def _compute_spatial_completeness(tif_path: str) -> float:
+        """Compute fraction of AOI with valid (non-nodata) pixels."""
+        with rasterio.open(tif_path) as src:
+            data = src.read(1).astype(np.float32)
+            nodata = src.nodata
+            if nodata is not None:
+                valid = np.sum(data != nodata)
+            else:
+                valid = np.sum(~np.isnan(data))
+            total = data.size
+        return float(valid / total) if total > 0 else 0.0
+
+    @staticmethod
+    def _classify_zscore(z_score: float, hotspot_pct: float) -> StatusLevel:
+        """Classify status using z-score and hotspot percentage."""
+        if abs(z_score) > ZSCORE_THRESHOLD or hotspot_pct > 25:
+            return StatusLevel.RED
+        if abs(z_score) > 1.0 or hotspot_pct > 10:
             return StatusLevel.AMBER
-        return StatusLevel.RED
+        return StatusLevel.GREEN
 
     @staticmethod
-    def _compute_trend(change_pct: float) -> TrendDirection:
-        if abs(change_pct) < 10:
+    def _compute_trend_zscore(monthly_zscores: list[float]) -> TrendDirection:
+        """Compute trend from direction of monthly z-scores."""
+        valid = [z for z in monthly_zscores if z != 0.0]
+        if len(valid) < 2:
+            return TrendDirection.STABLE
+        within_normal = sum(1 for z in valid if abs(z) <= 1.0)
+        if within_normal > len(valid) / 2:
             return TrendDirection.STABLE
-        if abs(change_pct) >= 30:
+        negative = sum(1 for z in valid if z < -1.0)
+        positive = sum(1 for z in valid if z > 1.0)
+        if negative > positive:
             return TrendDirection.DETERIORATING
+        if positive > negative:
+            return TrendDirection.IMPROVING
         return TrendDirection.STABLE
 
     @staticmethod
-    def _build_chart_data(
-        current_monthly: list[float],
-        baseline_monthly: list[float],
+    def _build_seasonal_chart_data(
+        current_monthly_fractions: list[float],
+        seasonal_stats: dict[int, dict],
         time_range: TimeRange,
+        monthly_zscores: list[float],
         aoi_ha: float,
     ) -> dict[str, Any]:
+        """Build chart data with seasonal baseline envelope, in hectares."""
+        start_month = time_range.start.month
+        n = len(current_monthly_fractions)
         year = time_range.end.year
-        n = min(len(current_monthly), len(baseline_monthly))
-        dates = [f"{year}-{m + 1:02d}" for m in range(n)]
-        values = [round(v * aoi_ha, 1) for v in current_monthly[:n]]
-        b_mean = [round(v * aoi_ha, 1) for v in baseline_monthly[:n]]
-        b_min = [round(max(v * aoi_ha - aoi_ha * 0.02, 0), 1) for v in baseline_monthly[:n]]
-        b_max = [round(v * aoi_ha + aoi_ha * 0.02, 1) for v in baseline_monthly[:n]]
+
+        dates = []
+        values = []
+        b_mean = []
+        b_min = []
+        b_max = []
+        anomaly_flags = []
+
+        for i in range(n):
+            cal_month = ((start_month + i - 1) % 12) + 1
+            dates.append(f"{year}-{cal_month:02d}")
+            values.append(round(current_monthly_fractions[i] * aoi_ha, 1))
+
+            if cal_month in seasonal_stats and seasonal_stats[cal_month]["n_years"] > 0:
+                s = seasonal_stats[cal_month]
+                # Seasonal stats are raw NDBI means; convert to fraction > threshold,
+                # approximate using the baseline mean as a proxy for buildup fraction.
+                # For the envelope, use min/max from seasonal stats scaled to hectares.
+                b_mean.append(round(s["mean"] * aoi_ha, 1) if s["mean"] > 0 else 0.0)
+                b_min.append(round(s["min"] * aoi_ha, 1) if s["min"] > 0 else 0.0)
+                b_max.append(round(s["max"] * aoi_ha, 1) if s["max"] > 0 else 0.0)
+            else:
+                b_mean.append(0.0)
+                b_min.append(0.0)
+                b_max.append(0.0)
+
+            if i < len(monthly_zscores):
+                anomaly_flags.append(abs(monthly_zscores[i]) > ZSCORE_THRESHOLD)
+            else:
+                anomaly_flags.append(False)
 
         return {
             "dates": dates,
@@ -475,6 +702,7 @@ class BuiltupIndicator(BaseIndicator):
             "baseline_mean": b_mean,
             "baseline_min": b_min,
             "baseline_max": b_max,
+            "anomaly_flags": anomaly_flags,
             "label": "Built-up area (ha)",
         }
 
@@ -497,5 +725,3 @@ class BuiltupIndicator(BaseIndicator):
         profile.update(count=1, dtype="float32")
         with rasterio.open(output_path, "w", **profile) as dst:
             dst.write(change, 1)
-
-

app/indicators/sar.py

@@ -1,7 +1,8 @@
 """SAR Backscatter Indicator — Sentinel-1 GRD via CDSE openEO.
 
 Computes monthly VV/VH median composites, detects ground surface change
-and potential flood events against a baseline period.
+and potential flood events against a seasonal baseline using z-score
+anomaly detection, hotspot clustering, and four-factor confidence scoring.
 """
 from __future__ import annotations
 
@@ -14,7 +15,13 @@ from typing import Any
 import numpy as np
 import rasterio
 
-from app.config import RESOLUTION_M
+from app.config import (
+    SAR_RESOLUTION_M,
+    TRUECOLOR_RESOLUTION_M,
+    MIN_STD_SAR,
+    ZSCORE_THRESHOLD,
+    MIN_CLUSTER_PIXELS,
+)
 from app.indicators.base import BaseIndicator, SpatialData
 from app.models import (
     AOI,
@@ -25,6 +32,11 @@ from app.models import (
     ConfidenceLevel,
 )
 from app.openeo_client import get_connection, build_sar_graph, build_true_color_graph, _bbox_dict, submit_as_batch
+from app.analysis.seasonal import (
+    compute_zscore,
+)
+from app.analysis.change import compute_zscore_raster, detect_hotspots
+from app.analysis.confidence import compute_confidence
 
 logger = logging.getLogger(__name__)
 
@@ -62,17 +74,17 @@ class SarIndicator(BaseIndicator):
         current_cube = build_sar_graph(
             conn=conn, bbox=bbox,
             temporal_extent=[current_start, current_end],
-            resolution_m=RESOLUTION_M,
+            resolution_m=SAR_RESOLUTION_M,
         )
         baseline_cube = build_sar_graph(
             conn=conn, bbox=bbox,
             temporal_extent=[baseline_start, baseline_end],
-            resolution_m=RESOLUTION_M,
+            resolution_m=SAR_RESOLUTION_M,
         )
         true_color_cube = build_true_color_graph(
             conn=conn, bbox=bbox,
             temporal_extent=[current_start, current_end],
-            resolution_m=RESOLUTION_M,
+            resolution_m=TRUECOLOR_RESOLUTION_M,
         )
 
         return [
@@ -119,46 +131,119 @@ class SarIndicator(BaseIndicator):
         except Exception as exc:
             logger.warning("SAR true-color batch download failed: %s", exc)
 
+        # --- Seasonal baseline analysis ---
         current_stats = self._compute_stats(current_path)
+        current_mean = current_stats["overall_vv_mean"]
+        n_current_bands = current_stats["valid_months"]
 
-        if current_stats["valid_months"] == 0:
+        if n_current_bands == 0:
             return self._insufficient_data(aoi, time_range)
 
+        spatial_completeness = self._compute_spatial_completeness(current_path)
+
         if baseline_path:
             baseline_stats = self._compute_stats(baseline_path)
 
-            change_db = current_stats["overall_vv_mean"] - baseline_stats["overall_vv_mean"]
-            change_pct = self._compute_change_area_pct(
-                current_path, baseline_path, current_stats, baseline_stats
+            # Build seasonal stats from baseline VV monthly means grouped by calendar month
+            seasonal_stats = self._build_seasonal_stats_from_vv(
+                baseline_stats["monthly_vv_means"], BASELINE_YEARS,
+            )
+
+            start_month = time_range.start.month
+            most_recent_month = ((start_month + n_current_bands - 2) % 12) + 1
+
+            if most_recent_month in seasonal_stats and seasonal_stats[most_recent_month]["n_years"] > 0:
+                s = seasonal_stats[most_recent_month]
+                z_current = compute_zscore(current_mean, s["mean"], s["std"], MIN_STD_SAR)
+            else:
+                z_current = 0.0
+
+            # Per-month z-scores and anomaly count
+            anomaly_months = 0
+            monthly_zscores: list[float] = []
+            for i, val in enumerate(current_stats["monthly_vv_means"]):
+                if val == 0.0:
+                    monthly_zscores.append(0.0)
+                    continue
+                cal_month = ((start_month + i - 1) % 12) + 1
+                if cal_month in seasonal_stats and seasonal_stats[cal_month]["n_years"] > 0:
+                    z = compute_zscore(val, seasonal_stats[cal_month]["mean"],
+                                       seasonal_stats[cal_month]["std"], MIN_STD_SAR)
+                    monthly_zscores.append(z)
+                    if abs(z) > ZSCORE_THRESHOLD:
+                        anomaly_months += 1
+                else:
+                    monthly_zscores.append(0.0)
+
+            # Pixel-level hotspot detection using VV bands
+            hotspot_pct = 0.0
+            self._zscore_raster = None
+            self._hotspot_mask = None
+            baseline_vv_bands = self._get_vv_band_indices_for_month(
+                baseline_stats["valid_months_total"], BASELINE_YEARS, most_recent_month,
             )
+            if baseline_vv_bands:
+                pixel_mean, pixel_std = self._compute_vv_pixel_stats(
+                    baseline_path, baseline_vv_bands,
+                )
+                # Read most recent current VV band
+                with rasterio.open(current_path) as src:
+                    n_current_total = src.count // 2
+                    current_vv_idx = min(n_current_bands, n_current_total) * 2 - 1  # 1-based VV
+                    current_data = src.read(current_vv_idx).astype(np.float32)
+                    if src.nodata is not None:
+                        current_data[current_data == src.nodata] = np.nan
+
+                z_raster = compute_zscore_raster(current_data, pixel_mean, pixel_std, MIN_STD_SAR)
+                hotspot_mask, hotspot_pct = detect_hotspots(z_raster, ZSCORE_THRESHOLD)
+                self._zscore_raster = z_raster
+                self._hotspot_mask = hotspot_mask
+
+            # Confidence scoring
+            baseline_depth = sum(1 for m in range(1, 13)
+                                 if m in seasonal_stats and seasonal_stats[m]["n_years"] > 0)
+            mean_baseline_years = (sum(seasonal_stats[m]["n_years"] for m in range(1, 13)
+                                       if m in seasonal_stats) / max(baseline_depth, 1))
+            conf = compute_confidence(
+                valid_months=n_current_bands,
+                mean_obs_per_composite=5.0,
+                baseline_years_with_data=int(mean_baseline_years),
+                spatial_completeness=spatial_completeness,
+            )
+            confidence = conf["level"]
+            confidence_factors = conf["factors"]
+
+            # Legacy flood detection (integrated with z-scores)
             flood_months = self._count_flood_months(
                 current_stats["monthly_vv_means"],
                 baseline_stats["overall_vv_mean"],
                 baseline_stats["vv_std"],
             )
-            status = self._classify(change_pct, flood_months)
-            trend = self._compute_trend(current_stats["monthly_vv_means"])
-            confidence = (
-                ConfidenceLevel.HIGH if current_stats["valid_months"] >= 6
-                else ConfidenceLevel.MODERATE if current_stats["valid_months"] >= 3
-                else ConfidenceLevel.LOW
+
+            change_db = current_mean - baseline_stats["overall_vv_mean"]
+            change_pct = self._compute_change_area_pct(
+                current_path, baseline_path, current_stats, baseline_stats,
             )
-            chart_data = self._build_chart_data(
-                current_stats["monthly_vv_means"],
-                baseline_stats["monthly_vv_means"],
-                time_range,
+
+            status = self._classify_zscore(z_current, hotspot_pct)
+            trend = self._compute_trend_zscore(monthly_zscores)
+
+            chart_data = self._build_seasonal_chart_data(
+                current_stats["monthly_vv_means"], seasonal_stats, time_range, monthly_zscores,
             )
 
             # Headline
             parts = []
+            if abs(z_current) > ZSCORE_THRESHOLD:
+                parts.append(f"z={z_current:+.1f} vs seasonal baseline")
             if change_pct >= 5:
                 parts.append(f"{change_pct:.0f}% ground surface change")
             if flood_months > 0:
                 parts.append(f"{flood_months} potential flood event{'s' if flood_months > 1 else ''}")
-            headline = (
-                f"SAR detects {', '.join(parts)}" if parts
-                else "Stable backscatter conditions — no significant ground change detected"
-            )
+            if parts:
+                headline = f"SAR backscatter anomaly: {', '.join(parts)} (mean VV {current_mean:.1f} dB)"
+            else:
+                headline = f"Stable backscatter conditions (mean VV {current_mean:.1f} dB, z={z_current:+.1f})"
 
             change_map_path = os.path.join(results_dir, "sar_change.tif")
             self._write_change_raster(current_path, baseline_path, change_map_path)
@@ -175,21 +260,28 @@ class SarIndicator(BaseIndicator):
             map_layer_path = change_map_path
 
             summary = (
-                f"Mean VV backscatter change: {change_db:+.1f} dB. "
-                f"{change_pct:.1f}% of AOI shows significant change (>{CHANGE_THRESHOLD_DB} dB). "
+                f"Mean VV backscatter: {current_mean:.1f} dB (z-score {z_current:+.1f} vs seasonal baseline). "
+                f"{anomaly_months} of {n_current_bands} months show significant anomalies. "
+                f"{hotspot_pct:.0f}% of AOI has statistically significant change. "
+                f"Mean VV change: {change_db:+.1f} dB. "
+                f"{change_pct:.1f}% area with >{CHANGE_THRESHOLD_DB} dB change. "
                 f"{flood_months} month(s) with potential flood signals. "
-                f"Pixel-level analysis at {RESOLUTION_M}m resolution from "
-                f"{current_stats['valid_months']} monthly composites."
+                f"Pixel-level analysis at {SAR_RESOLUTION_M}m resolution."
             )
             extra_limitations: list[str] = []
         else:
             # Degraded mode — no baseline
+            z_current = 0.0
+            anomaly_months = 0
+            hotspot_pct = 0.0
+            confidence = ConfidenceLevel.LOW
+            confidence_factors = {}
+            status = StatusLevel.GREEN
+            trend = TrendDirection.STABLE
             change_db = 0.0
-            change_pct = 0.0
             flood_months = 0
-            status = self._classify(change_pct, flood_months)
-            trend = TrendDirection.STABLE
-            confidence = ConfidenceLevel.LOW
+            self._zscore_raster = None
+            self._hotspot_mask = None
             chart_data = {
                 "dates": [f"{time_range.end.year}-{m+1:02d}" for m in range(len(current_stats["monthly_vv_means"]))],
                 "values": [round(v, 2) for v in current_stats["monthly_vv_means"]],
@@ -211,8 +303,8 @@ class SarIndicator(BaseIndicator):
             summary = (
                 f"Current SAR data available but baseline could not be retrieved. "
                 f"No change detection possible. "
-                f"Pixel-level analysis at {RESOLUTION_M}m resolution from "
-                f"{current_stats['valid_months']} monthly composites."
+                f"Pixel-level analysis at {SAR_RESOLUTION_M}m resolution from "
+                f"{n_current_bands} monthly composites."
             )
             extra_limitations = ["Baseline unavailable — change and trend not computed."]
 
@@ -227,21 +319,27 @@ class SarIndicator(BaseIndicator):
             map_layer_path=map_layer_path,
             chart_data=chart_data,
             data_source="satellite",
+            anomaly_months=anomaly_months,
+            z_score_current=round(z_current, 2),
+            hotspot_pct=round(hotspot_pct, 1),
+            confidence_factors=confidence_factors,
             summary=summary,
             methodology=(
                 f"Sentinel-1 GRD IW VV/VH polarizations, ascending orbit. "
                 f"Linear backscatter converted to dB (10·log₁₀). "
-                f"Monthly median composites at {RESOLUTION_M}m resolution. "
-                f"Change detection: >{CHANGE_THRESHOLD_DB} dB difference vs "
-                f"{BASELINE_YEARS}-year baseline. "
+                f"Monthly median composites at {SAR_RESOLUTION_M}m resolution. "
+                f"Baseline: {BASELINE_YEARS}-year seasonal baselines (per calendar month). "
+                f"Anomaly detection via z-scores (threshold: ±{ZSCORE_THRESHOLD}). "
+                f"Change detection: >{CHANGE_THRESHOLD_DB} dB difference vs baseline. "
                 f"Flood mapping: VV < baseline_mean − {FLOOD_SIGMA}σ. "
                 f"Processed via CDSE openEO batch jobs."
             ),
             limitations=[
-                f"Resampled to {RESOLUTION_M}m — fine-scale changes not captured.",
+                f"Resampled to {SAR_RESOLUTION_M}m — fine-scale changes not captured.",
                 "Ascending orbit filter may reduce temporal coverage in some areas.",
                 "Sentinel-1 coverage over East Africa can be inconsistent.",
                 "VV decrease may indicate flooding, moisture, or vegetation change — not uniquely flood.",
+                "Z-score anomalies assume baseline is representative of normal conditions.",
             ] + extra_limitations,
         )
 
@@ -272,17 +370,17 @@ class SarIndicator(BaseIndicator):
         current_cube = build_sar_graph(
             conn=conn, bbox=bbox,
             temporal_extent=[current_start, current_end],
-            resolution_m=RESOLUTION_M,
+            resolution_m=SAR_RESOLUTION_M,
         )
         baseline_cube = build_sar_graph(
             conn=conn, bbox=bbox,
             temporal_extent=[baseline_start, baseline_end],
-            resolution_m=RESOLUTION_M,
+            resolution_m=SAR_RESOLUTION_M,
         )
         true_color_cube = build_true_color_graph(
             conn=conn, bbox=bbox,
             temporal_extent=[current_start, current_end],
-            resolution_m=RESOLUTION_M,
+            resolution_m=TRUECOLOR_RESOLUTION_M,
         )
 
         loop = asyncio.get_event_loop()
@@ -304,52 +402,117 @@ class SarIndicator(BaseIndicator):
 
         self._true_color_path = true_color_path
 
+        # --- Seasonal baseline analysis ---
         current_stats = self._compute_stats(current_path)
         baseline_stats = self._compute_stats(baseline_path)
+        current_mean = current_stats["overall_vv_mean"]
+        n_current_bands = current_stats["valid_months"]
 
-        # Check for insufficient data
-        if current_stats["valid_months"] == 0:
+        if n_current_bands == 0:
             return self._insufficient_data(aoi, time_range)
 
-        # Change detection: mean VV difference per pixel
-        change_db = current_stats["overall_vv_mean"] - baseline_stats["overall_vv_mean"]
+        spatial_completeness = self._compute_spatial_completeness(current_path)
 
-        # Compute % of area with significant change
-        change_pct = self._compute_change_area_pct(
-            current_path, baseline_path, current_stats, baseline_stats
+        # Build seasonal stats from baseline VV monthly means grouped by calendar month
+        seasonal_stats = self._build_seasonal_stats_from_vv(
+            baseline_stats["monthly_vv_means"], BASELINE_YEARS,
         )
 
-        # Flood detection: months where VV < baseline_mean - 2σ
+        start_month = time_range.start.month
+        most_recent_month = ((start_month + n_current_bands - 2) % 12) + 1
+
+        if most_recent_month in seasonal_stats and seasonal_stats[most_recent_month]["n_years"] > 0:
+            s = seasonal_stats[most_recent_month]
+            z_current = compute_zscore(current_mean, s["mean"], s["std"], MIN_STD_SAR)
+        else:
+            z_current = 0.0
+
+        # Per-month z-scores and anomaly count
+        anomaly_months = 0
+        monthly_zscores: list[float] = []
+        for i, val in enumerate(current_stats["monthly_vv_means"]):
+            if val == 0.0:
+                monthly_zscores.append(0.0)
+                continue
+            cal_month = ((start_month + i - 1) % 12) + 1
+            if cal_month in seasonal_stats and seasonal_stats[cal_month]["n_years"] > 0:
+                z = compute_zscore(val, seasonal_stats[cal_month]["mean"],
+                                   seasonal_stats[cal_month]["std"], MIN_STD_SAR)
+                monthly_zscores.append(z)
+                if abs(z) > ZSCORE_THRESHOLD:
+                    anomaly_months += 1
+            else:
+                monthly_zscores.append(0.0)
+
+        # Pixel-level hotspot detection using VV bands
+        hotspot_pct = 0.0
+        self._zscore_raster = None
+        self._hotspot_mask = None
+        baseline_vv_bands = self._get_vv_band_indices_for_month(
+            baseline_stats["valid_months_total"], BASELINE_YEARS, most_recent_month,
+        )
+        if baseline_vv_bands:
+            pixel_mean, pixel_std = self._compute_vv_pixel_stats(
+                baseline_path, baseline_vv_bands,
+            )
+            # Read most recent current VV band
+            with rasterio.open(current_path) as src:
+                n_current_total = src.count // 2
+                current_vv_idx = min(n_current_bands, n_current_total) * 2 - 1  # 1-based VV
+                current_data = src.read(current_vv_idx).astype(np.float32)
+                if src.nodata is not None:
+                    current_data[current_data == src.nodata] = np.nan
+
+            z_raster = compute_zscore_raster(current_data, pixel_mean, pixel_std, MIN_STD_SAR)
+            hotspot_mask, hotspot_pct = detect_hotspots(z_raster, ZSCORE_THRESHOLD)
+            self._zscore_raster = z_raster
+            self._hotspot_mask = hotspot_mask
+
+        # Confidence scoring
+        baseline_depth = sum(1 for m in range(1, 13)
+                             if m in seasonal_stats and seasonal_stats[m]["n_years"] > 0)
+        mean_baseline_years = (sum(seasonal_stats[m]["n_years"] for m in range(1, 13)
+                                   if m in seasonal_stats) / max(baseline_depth, 1))
+        conf = compute_confidence(
+            valid_months=n_current_bands,
+            mean_obs_per_composite=5.0,
+            baseline_years_with_data=int(mean_baseline_years),
+            spatial_completeness=spatial_completeness,
+        )
+        confidence = conf["level"]
+        confidence_factors = conf["factors"]
+
+        # Legacy flood detection (integrated with z-scores)
         flood_months = self._count_flood_months(
             current_stats["monthly_vv_means"],
             baseline_stats["overall_vv_mean"],
             baseline_stats["vv_std"],
         )
 
-        status = self._classify(change_pct, flood_months)
-        trend = self._compute_trend(current_stats["monthly_vv_means"])
-        confidence = (
-            ConfidenceLevel.HIGH if current_stats["valid_months"] >= 6
-            else ConfidenceLevel.MODERATE if current_stats["valid_months"] >= 3
-            else ConfidenceLevel.LOW
+        change_db = current_mean - baseline_stats["overall_vv_mean"]
+        change_pct = self._compute_change_area_pct(
+            current_path, baseline_path, current_stats, baseline_stats,
         )
 
-        chart_data = self._build_chart_data(
-            current_stats["monthly_vv_means"],
-            baseline_stats["monthly_vv_means"],
-            time_range,
+        status = self._classify_zscore(z_current, hotspot_pct)
+        trend = self._compute_trend_zscore(monthly_zscores)
+
+        chart_data = self._build_seasonal_chart_data(
+            current_stats["monthly_vv_means"], seasonal_stats, time_range, monthly_zscores,
         )
 
         # Headline
         parts = []
+        if abs(z_current) > ZSCORE_THRESHOLD:
+            parts.append(f"z={z_current:+.1f} vs seasonal baseline")
         if change_pct >= 5:
             parts.append(f"{change_pct:.0f}% ground surface change")
         if flood_months > 0:
             parts.append(f"{flood_months} potential flood event{'s' if flood_months > 1 else ''}")
         if parts:
-            headline = f"SAR detects {', '.join(parts)}"
+            headline = f"SAR backscatter anomaly: {', '.join(parts)} (mean VV {current_mean:.1f} dB)"
         else:
-            headline = "Stable backscatter conditions — no significant ground change detected"
+            headline = f"Stable backscatter conditions (mean VV {current_mean:.1f} dB, z={z_current:+.1f})"
 
         # Store raster path for map rendering — write a change map
         change_map_path = os.path.join(results_dir, "sar_change.tif")
@@ -374,30 +537,42 @@ class SarIndicator(BaseIndicator):
             map_layer_path=change_map_path,
             chart_data=chart_data,
             data_source="satellite",
+            anomaly_months=anomaly_months,
+            z_score_current=round(z_current, 2),
+            hotspot_pct=round(hotspot_pct, 1),
+            confidence_factors=confidence_factors,
             summary=(
-                f"Mean VV backscatter change: {change_db:+.1f} dB. "
-                f"{change_pct:.1f}% of AOI shows significant change (>{CHANGE_THRESHOLD_DB} dB). "
+                f"Mean VV backscatter: {current_mean:.1f} dB (z-score {z_current:+.1f} vs seasonal baseline). "
+                f"{anomaly_months} of {n_current_bands} months show significant anomalies. "
+                f"{hotspot_pct:.0f}% of AOI has statistically significant change. "
+                f"Mean VV change: {change_db:+.1f} dB. "
+                f"{change_pct:.1f}% area with >{CHANGE_THRESHOLD_DB} dB change. "
                 f"{flood_months} month(s) with potential flood signals. "
-                f"Pixel-level analysis at {RESOLUTION_M}m resolution from "
-                f"{current_stats['valid_months']} monthly composites."
+                f"Pixel-level analysis at {SAR_RESOLUTION_M}m resolution."
             ),
             methodology=(
                 f"Sentinel-1 GRD IW VV/VH polarizations, ascending orbit. "
                 f"Linear backscatter converted to dB (10·log₁₀). "
-                f"Monthly median composites at {RESOLUTION_M}m resolution. "
-                f"Change detection: >{CHANGE_THRESHOLD_DB} dB difference vs "
-                f"{BASELINE_YEARS}-year baseline. "
+                f"Monthly median composites at {SAR_RESOLUTION_M}m resolution. "
+                f"Baseline: {BASELINE_YEARS}-year seasonal baselines (per calendar month). "
+                f"Anomaly detection via z-scores (threshold: ±{ZSCORE_THRESHOLD}). "
+                f"Change detection: >{CHANGE_THRESHOLD_DB} dB difference vs baseline. "
                 f"Flood mapping: VV < baseline_mean − {FLOOD_SIGMA}σ. "
                 f"Processed via CDSE openEO."
             ),
             limitations=[
-                f"Resampled to {RESOLUTION_M}m — fine-scale changes not captured.",
+                f"Resampled to {SAR_RESOLUTION_M}m — fine-scale changes not captured.",
                 "Ascending orbit filter may reduce temporal coverage in some areas.",
                 "Sentinel-1 coverage over East Africa can be inconsistent.",
                 "VV decrease may indicate flooding, moisture, or vegetation change — not uniquely flood.",
+                "Z-score anomalies assume baseline is representative of normal conditions.",
             ],
         )
 
+    # ------------------------------------------------------------------
+    # Statistics helpers
+    # ------------------------------------------------------------------
+
     @staticmethod
     def _compute_stats(tif_path: str) -> dict[str, Any]:
         """Extract monthly VV statistics from interleaved SAR GeoTIFF.
@@ -435,8 +610,180 @@ class SarIndicator(BaseIndicator):
             "overall_vv_mean": overall_vv_mean,
             "vv_std": vv_std,
             "valid_months": valid_months,
+            "valid_months_total": n_bands // 2,
         }
 
+    @staticmethod
+    def _build_seasonal_stats_from_vv(
+        monthly_vv_means: list[float],
+        n_years: int,
+    ) -> dict[int, dict[str, Any]]:
+        """Group baseline monthly VV means by calendar month and compute stats.
+
+        This avoids calling ``compute_seasonal_stats_aoi`` directly on the
+        interleaved SAR TIFF (which would mix VV and VH bands).
+        """
+        grouped: dict[int, list[float]] = {m: [] for m in range(1, 13)}
+        for i, val in enumerate(monthly_vv_means):
+            if val == 0.0:
+                continue
+            cal_month = (i % 12) + 1
+            grouped[cal_month].append(val)
+
+        stats: dict[int, dict[str, Any]] = {}
+        for month, values in grouped.items():
+            if values:
+                arr = np.array(values)
+                stats[month] = {
+                    "mean": float(np.mean(arr)),
+                    "median": float(np.median(arr)),
+                    "std": float(np.std(arr, ddof=1)) if len(arr) > 1 else 0.0,
+                    "min": float(np.min(arr)),
+                    "max": float(np.max(arr)),
+                    "n_years": len(values),
+                }
+            else:
+                stats[month] = {
+                    "mean": 0.0, "median": 0.0, "std": 0.0,
+                    "min": 0.0, "max": 0.0, "n_years": 0,
+                }
+        return stats
+
+    @staticmethod
+    def _get_vv_band_indices_for_month(
+        n_total_months: int,
+        n_years: int,
+        target_month: int,
+    ) -> list[int]:
+        """Return 1-based VV band indices for a given calendar month.
+
+        Bands are interleaved VV/VH, so VV for month *i* (0-based) is at
+        band ``i * 2 + 1`` (1-based).
+        """
+        vv_bands: list[int] = []
+        for i in range(n_total_months):
+            cal_month = (i % 12) + 1
+            if cal_month == target_month:
+                vv_bands.append(i * 2 + 1)  # 1-based
+        return vv_bands
+
+    @staticmethod
+    def _compute_vv_pixel_stats(
+        tif_path: str,
+        vv_band_indices: list[int],
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """Compute per-pixel mean and std from specific VV bands."""
+        with rasterio.open(tif_path) as src:
+            nodata = src.nodata
+            stack = []
+            for band in vv_band_indices:
+                data = src.read(band).astype(np.float32)
+                if nodata is not None:
+                    data[data == nodata] = np.nan
+                stack.append(data)
+
+        arr = np.stack(stack, axis=0)
+        with np.errstate(all="ignore"):
+            mean = np.nanmean(arr, axis=0)
+            std = np.nanstd(arr, axis=0, ddof=1) if arr.shape[0] > 1 else np.zeros_like(mean)
+        return mean, std
+
+    @staticmethod
+    def _compute_spatial_completeness(tif_path: str) -> float:
+        """Compute fraction of AOI with valid (non-nodata) pixels."""
+        with rasterio.open(tif_path) as src:
+            data = src.read(1).astype(np.float32)
+            nodata = src.nodata
+            if nodata is not None:
+                valid = np.sum(data != nodata)
+            else:
+                valid = np.sum(~np.isnan(data))
+            total = data.size
+        return float(valid / total) if total > 0 else 0.0
+
+    # ------------------------------------------------------------------
+    # Classification helpers (z-score based)
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _classify_zscore(z_score: float, hotspot_pct: float) -> StatusLevel:
+        """Classify status using z-score and hotspot percentage."""
+        if abs(z_score) > ZSCORE_THRESHOLD or hotspot_pct > 25:
+            return StatusLevel.RED
+        if abs(z_score) > 1.0 or hotspot_pct > 10:
+            return StatusLevel.AMBER
+        return StatusLevel.GREEN
+
+    @staticmethod
+    def _compute_trend_zscore(monthly_zscores: list[float]) -> TrendDirection:
+        """Compute trend from direction of monthly z-scores."""
+        valid = [z for z in monthly_zscores if z != 0.0]
+        if len(valid) < 2:
+            return TrendDirection.STABLE
+        within_normal = sum(1 for z in valid if abs(z) <= 1.0)
+        if within_normal > len(valid) / 2:
+            return TrendDirection.STABLE
+        negative = sum(1 for z in valid if z < -1.0)
+        positive = sum(1 for z in valid if z > 1.0)
+        if negative > positive:
+            return TrendDirection.DETERIORATING
+        if positive > negative:
+            return TrendDirection.IMPROVING
+        return TrendDirection.STABLE
+
+    @staticmethod
+    def _build_seasonal_chart_data(
+        current_monthly: list[float],
+        seasonal_stats: dict[int, dict],
+        time_range: TimeRange,
+        monthly_zscores: list[float],
+    ) -> dict[str, Any]:
+        """Build chart data with seasonal baseline envelope."""
+        start_month = time_range.start.month
+        n = len(current_monthly)
+        year = time_range.end.year
+
+        dates: list[str] = []
+        values: list[float] = []
+        b_mean: list[float] = []
+        b_min: list[float] = []
+        b_max: list[float] = []
+        anomaly_flags: list[bool] = []
+
+        for i in range(n):
+            cal_month = ((start_month + i - 1) % 12) + 1
+            dates.append(f"{year}-{cal_month:02d}")
+            values.append(round(current_monthly[i], 2))
+
+            if cal_month in seasonal_stats and seasonal_stats[cal_month]["n_years"] > 0:
+                s = seasonal_stats[cal_month]
+                b_mean.append(round(s["mean"], 2))
+                b_min.append(round(s["min"], 2))
+                b_max.append(round(s["max"], 2))
+            else:
+                b_mean.append(0.0)
+                b_min.append(0.0)
+                b_max.append(0.0)
+
+            if i < len(monthly_zscores):
+                anomaly_flags.append(abs(monthly_zscores[i]) > ZSCORE_THRESHOLD)
+            else:
+                anomaly_flags.append(False)
+
+        return {
+            "dates": dates,
+            "values": values,
+            "baseline_mean": b_mean,
+            "baseline_min": b_min,
+            "baseline_max": b_max,
+            "anomaly_flags": anomaly_flags,
+            "label": "VV Backscatter (dB)",
+        }
+
+    # ------------------------------------------------------------------
+    # SAR-specific helpers (kept as-is)
+    # ------------------------------------------------------------------
+
     @staticmethod
     def _compute_change_area_pct(
         current_path: str, baseline_path: str,
@@ -470,52 +817,6 @@ class SarIndicator(BaseIndicator):
         threshold = baseline_mean - FLOOD_SIGMA * baseline_std
         return sum(1 for v in monthly_vv if v != 0.0 and v < threshold)
 
-    @staticmethod
-    def _classify(change_pct: float, flood_months: int) -> StatusLevel:
-        if change_pct >= 15 or flood_months >= 3:
-            return StatusLevel.RED
-        if change_pct >= 5 or flood_months >= 1:
-            return StatusLevel.AMBER
-        return StatusLevel.GREEN
-
-    @staticmethod
-    def _compute_trend(monthly_vv: list[float]) -> TrendDirection:
-        valid = [v for v in monthly_vv if v != 0.0]
-        if len(valid) < 4:
-            return TrendDirection.STABLE
-        mid = len(valid) // 2
-        first_half = np.mean(valid[:mid])
-        second_half = np.mean(valid[mid:])
-        diff = abs(second_half - first_half)
-        if diff < 1.0:
-            return TrendDirection.STABLE
-        if second_half > first_half:
-            return TrendDirection.IMPROVING
-        return TrendDirection.DETERIORATING
-
-    @staticmethod
-    def _build_chart_data(
-        current_monthly: list[float],
-        baseline_monthly: list[float],
-        time_range: TimeRange,
-    ) -> dict[str, Any]:
-        year = time_range.end.year
-        n = min(len(current_monthly), len(baseline_monthly))
-        dates = [f"{year}-{m + 1:02d}" for m in range(n)]
-        values = [round(v, 2) for v in current_monthly[:n]]
-        b_mean = [round(v, 2) for v in baseline_monthly[:n]] if baseline_monthly else []
-        b_min = [round(v - 2.0, 2) for v in b_mean]
-        b_max = [round(v + 2.0, 2) for v in b_mean]
-
-        return {
-            "dates": dates,
-            "values": values,
-            "baseline_mean": b_mean,
-            "baseline_min": b_min,
-            "baseline_max": b_max,
-            "label": "VV Backscatter (dB)",
-        }
-
     @staticmethod
     def _write_change_raster(current_path: str, baseline_path: str, output_path: str) -> None:
         """Write a single-band GeoTIFF of VV change (current_mean - baseline_mean)."""
@@ -542,4 +843,3 @@ class SarIndicator(BaseIndicator):
             "area and time period. SAR coverage over parts of East Africa "
             "is inconsistent."
         )
-

app/indicators/water.py

@@ -1,7 +1,8 @@
 """Water Bodies Indicator — pixel-level MNDWI via CDSE openEO.
 
 Computes monthly MNDWI composites from Sentinel-2 L2A, classifies water
-pixels (MNDWI > 0), and tracks water extent change against a 5-year baseline.
+pixels (MNDWI > 0), and tracks water extent change against a 5-year
+seasonal baseline using z-score anomaly detection.
 """
 from __future__ import annotations
 
@@ -14,7 +15,13 @@ from typing import Any
 import numpy as np
 import rasterio
 
-from app.config import RESOLUTION_M
+from app.config import (
+    WATER_RESOLUTION_M,
+    TRUECOLOR_RESOLUTION_M,
+    MIN_STD_WATER,
+    ZSCORE_THRESHOLD,
+    MIN_CLUSTER_PIXELS,
+)
 from app.indicators.base import BaseIndicator, SpatialData
 from app.models import (
     AOI,
@@ -25,6 +32,14 @@ from app.models import (
     ConfidenceLevel,
 )
 from app.openeo_client import get_connection, build_mndwi_graph, build_true_color_graph, _bbox_dict, submit_as_batch
+from app.analysis.seasonal import (
+    group_bands_by_calendar_month,
+    compute_seasonal_stats_aoi,
+    compute_seasonal_stats_pixel,
+    compute_zscore,
+)
+from app.analysis.change import compute_zscore_raster, detect_hotspots, cluster_hotspots
+from app.analysis.confidence import compute_confidence
 
 logger = logging.getLogger(__name__)
 
@@ -56,22 +71,26 @@ class WaterIndicator(BaseIndicator):
             time_range.start.month,
             time_range.start.day,
         ).isoformat()
-        baseline_end = time_range.start.isoformat()
+        baseline_end = date(
+            time_range.start.year,
+            time_range.start.month,
+            time_range.start.day,
+        ).isoformat()
 
         current_cube = build_mndwi_graph(
             conn=conn, bbox=bbox,
             temporal_extent=[current_start, current_end],
-            resolution_m=RESOLUTION_M,
+            resolution_m=WATER_RESOLUTION_M,
         )
         baseline_cube = build_mndwi_graph(
             conn=conn, bbox=bbox,
             temporal_extent=[baseline_start, baseline_end],
-            resolution_m=RESOLUTION_M,
+            resolution_m=WATER_RESOLUTION_M,
         )
         true_color_cube = build_true_color_graph(
             conn=conn, bbox=bbox,
             temporal_extent=[current_start, current_end],
-            resolution_m=RESOLUTION_M,
+            resolution_m=TRUECOLOR_RESOLUTION_M,
         )
 
         return [
@@ -118,44 +137,105 @@ class WaterIndicator(BaseIndicator):
         except Exception as exc:
             logger.warning("Water true-color batch download failed: %s", exc)
 
-        # Compute statistics
+        # --- Seasonal baseline analysis ---
         current_stats = self._compute_stats(current_path)
+        current_mean = current_stats["overall_mean"]
         current_frac = current_stats["overall_water_fraction"]
+        n_current_bands = current_stats["valid_months"]
+
+        spatial_completeness = self._compute_spatial_completeness(current_path)
 
         if baseline_path:
+            seasonal_stats = compute_seasonal_stats_aoi(baseline_path, n_years=BASELINE_YEARS)
             baseline_stats = self._compute_stats(baseline_path)
-            baseline_frac = baseline_stats["overall_water_fraction"]
-            change_pp = (current_frac - baseline_frac) * 100
-            confidence = (
-                ConfidenceLevel.HIGH if current_stats["valid_months"] >= 6
-                else ConfidenceLevel.MODERATE if current_stats["valid_months"] >= 3
-                else ConfidenceLevel.LOW
+
+            start_month = time_range.start.month
+            most_recent_month = ((start_month + n_current_bands - 2) % 12) + 1
+
+            if most_recent_month in seasonal_stats and seasonal_stats[most_recent_month]["n_years"] > 0:
+                s = seasonal_stats[most_recent_month]
+                z_current = compute_zscore(current_mean, s["mean"], s["std"], MIN_STD_WATER)
+            else:
+                z_current = 0.0
+
+            anomaly_months = 0
+            monthly_zscores = []
+            for i, val in enumerate(current_stats["monthly_means"]):
+                if val <= -1.0:
+                    monthly_zscores.append(0.0)
+                    continue
+                cal_month = ((start_month + i - 1) % 12) + 1
+                if cal_month in seasonal_stats and seasonal_stats[cal_month]["n_years"] > 0:
+                    z = compute_zscore(val, seasonal_stats[cal_month]["mean"],
+                                       seasonal_stats[cal_month]["std"], MIN_STD_WATER)
+                    monthly_zscores.append(z)
+                    if abs(z) > ZSCORE_THRESHOLD:
+                        anomaly_months += 1
+                else:
+                    monthly_zscores.append(0.0)
+
+            month_map = group_bands_by_calendar_month(baseline_stats["valid_months_total"], BASELINE_YEARS)
+            hotspot_pct = 0.0
+            self._zscore_raster = None
+            self._hotspot_mask = None
+            if most_recent_month in month_map and len(month_map[most_recent_month]) > 0:
+                pixel_stats = compute_seasonal_stats_pixel(baseline_path, month_map[most_recent_month])
+                with rasterio.open(current_path) as src:
+                    current_band_idx = min(n_current_bands, src.count)
+                    current_data = src.read(current_band_idx).astype(np.float32)
+                    if src.nodata is not None:
+                        current_data[current_data == src.nodata] = np.nan
+
+                z_raster = compute_zscore_raster(current_data, pixel_stats["mean"],
+                                                  pixel_stats["std"], MIN_STD_WATER)
+                hotspot_mask, hotspot_pct = detect_hotspots(z_raster, ZSCORE_THRESHOLD)
+                self._zscore_raster = z_raster
+                self._hotspot_mask = hotspot_mask
+
+            baseline_depth = sum(1 for m in range(1, 13)
+                                 if m in seasonal_stats and seasonal_stats[m]["n_years"] > 0)
+            mean_baseline_years = (sum(seasonal_stats[m]["n_years"] for m in range(1, 13)
+                                       if m in seasonal_stats) / max(baseline_depth, 1))
+            conf = compute_confidence(
+                valid_months=n_current_bands,
+                mean_obs_per_composite=5.0,
+                baseline_years_with_data=int(mean_baseline_years),
+                spatial_completeness=spatial_completeness,
             )
-            chart_data = self._build_chart_data(
-                current_stats["monthly_water_fractions"],
-                baseline_stats["monthly_water_fractions"],
-                time_range,
+            confidence = conf["level"]
+            confidence_factors = conf["factors"]
+
+            status = self._classify_zscore(z_current, hotspot_pct)
+            trend = self._compute_trend_zscore(monthly_zscores)
+
+            chart_data = self._build_seasonal_chart_data(
+                current_stats["monthly_water_fractions"], seasonal_stats, time_range, monthly_zscores,
             )
+
+            change = current_mean - baseline_stats["overall_mean"]
         else:
-            baseline_frac = current_frac
-            change_pp = 0.0
+            z_current = 0.0
+            anomaly_months = 0
+            hotspot_pct = 0.0
             confidence = ConfidenceLevel.LOW
+            confidence_factors = {}
+            status = StatusLevel.GREEN
+            trend = TrendDirection.STABLE
+            change = 0.0
+            self._zscore_raster = None
+            self._hotspot_mask = None
             chart_data = {
                 "dates": [f"{time_range.end.year}-{m+1:02d}" for m in range(len(current_stats["monthly_water_fractions"]))],
                 "values": [round(v * 100, 1) for v in current_stats["monthly_water_fractions"]],
                 "label": "Water extent (%)",
             }
 
-        status = self._classify(abs(change_pp))
-        trend = self._compute_trend(change_pp) if baseline_path else TrendDirection.STABLE
-
-        if not baseline_path:
-            headline = f"Water extent: {current_frac*100:.1f}% — baseline unavailable"
-        elif abs(change_pp) <= 5:
-            headline = f"Water extent stable ({current_frac*100:.1f}%, \u0394{change_pp:+.1f}pp)"
+        if abs(z_current) <= 1.0:
+            headline = f"Water extent within seasonal range ({current_frac*100:.1f}%, z={z_current:+.1f})"
+        elif z_current > 0:
+            headline = f"Water extent above seasonal average ({current_frac*100:.1f}%, z={z_current:+.1f})"
         else:
-            direction = "increase" if change_pp > 0 else "decrease"
-            headline = f"Water extent {direction} ({change_pp:+.1f}pp vs baseline)"
+            headline = f"Water extent anomaly detected ({current_frac*100:.1f}%, z={z_current:+.1f})"
 
         self._spatial_data = SpatialData(
             map_type="raster",
@@ -177,27 +257,30 @@ class WaterIndicator(BaseIndicator):
             map_layer_path=current_path,
             chart_data=chart_data,
             data_source="satellite",
+            anomaly_months=anomaly_months,
+            z_score_current=round(z_current, 2),
+            hotspot_pct=round(hotspot_pct, 1),
+            confidence_factors=confidence_factors,
             summary=(
-                f"Water covers {current_frac*100:.1f}% of the AOI compared to "
-                f"{baseline_frac*100:.1f}% baseline ({change_pp:+.1f}pp). "
-                f"Pixel-level MNDWI analysis at {RESOLUTION_M}m resolution."
-            ) if baseline_path else (
-                f"Water covers {current_frac*100:.1f}% of the AOI. "
-                f"Baseline unavailable. "
-                f"Pixel-level MNDWI analysis at {RESOLUTION_M}m resolution."
+                f"Water covers {current_frac*100:.1f}% of the AOI (mean MNDWI {current_mean:.3f}, "
+                f"z-score {z_current:+.1f} vs seasonal baseline). "
+                f"{anomaly_months} of {n_current_bands} months show significant anomalies. "
+                f"{hotspot_pct:.0f}% of AOI has statistically significant change. "
+                f"Pixel-level MNDWI analysis at {WATER_RESOLUTION_M}m resolution."
             ),
             methodology=(
                 f"Sentinel-2 L2A pixel-level MNDWI = (B03 \u2212 B11) / (B03 + B11). "
                 f"Cloud-masked using SCL band. Water classified as MNDWI > {WATER_THRESHOLD}. "
-                f"Monthly median composites at {RESOLUTION_M}m. "
-                f"Baseline: {BASELINE_YEARS}-year water extent frequency. "
-                f"Processed via CDSE openEO batch jobs."
+                f"Monthly median composites at {WATER_RESOLUTION_M}m native resolution. "
+                f"Baseline: {BASELINE_YEARS}-year seasonal baselines (per calendar month). "
+                f"Anomaly detection via z-scores (threshold: \u00b1{ZSCORE_THRESHOLD}). "
+                f"Processed server-side via CDSE openEO batch jobs."
             ),
             limitations=[
-                f"Resampled to {RESOLUTION_M}m \u2014 small water bodies may be missed.",
                 "Cloud/shadow contamination can cause false water detections.",
                 "Seasonal flooding may appear as change if analysis windows differ.",
                 "MNDWI threshold is fixed; turbid water may be misclassified.",
+                "Z-score anomalies assume baseline is representative of normal conditions.",
             ] + (["Baseline unavailable \u2014 change and trend not computed."] if not baseline_path else []),
         )
 
@@ -221,24 +304,28 @@ class WaterIndicator(BaseIndicator):
             time_range.start.month,
             time_range.start.day,
         ).isoformat()
-        baseline_end = time_range.start.isoformat()
+        baseline_end = date(
+            time_range.start.year,
+            time_range.start.month,
+            time_range.start.day,
+        ).isoformat()
 
         results_dir = tempfile.mkdtemp(prefix="aperture_water_")
 
         current_cube = build_mndwi_graph(
             conn=conn, bbox=bbox,
             temporal_extent=[current_start, current_end],
-            resolution_m=RESOLUTION_M,
+            resolution_m=WATER_RESOLUTION_M,
         )
         baseline_cube = build_mndwi_graph(
             conn=conn, bbox=bbox,
             temporal_extent=[baseline_start, baseline_end],
-            resolution_m=RESOLUTION_M,
+            resolution_m=WATER_RESOLUTION_M,
         )
         true_color_cube = build_true_color_graph(
             conn=conn, bbox=bbox,
             temporal_extent=[current_start, current_end],
-            resolution_m=RESOLUTION_M,
+            resolution_m=TRUECOLOR_RESOLUTION_M,
         )
 
         loop = asyncio.get_event_loop()
@@ -252,32 +339,83 @@ class WaterIndicator(BaseIndicator):
 
         self._true_color_path = true_color_path
 
+        # --- Seasonal baseline analysis ---
         current_stats = self._compute_stats(current_path)
         baseline_stats = self._compute_stats(baseline_path)
-
+        current_mean = current_stats["overall_mean"]
         current_frac = current_stats["overall_water_fraction"]
-        baseline_frac = baseline_stats["overall_water_fraction"]
-        change_pp = (current_frac - baseline_frac) * 100  # percentage points
-
-        status = self._classify(abs(change_pp))
-        trend = self._compute_trend(change_pp)
-        confidence = (
-            ConfidenceLevel.HIGH if current_stats["valid_months"] >= 6
-            else ConfidenceLevel.MODERATE if current_stats["valid_months"] >= 3
-            else ConfidenceLevel.LOW
+        n_current_bands = current_stats["valid_months"]
+        spatial_completeness = self._compute_spatial_completeness(current_path)
+
+        seasonal_stats = compute_seasonal_stats_aoi(baseline_path, n_years=BASELINE_YEARS)
+        start_month = time_range.start.month
+        most_recent_month = ((start_month + n_current_bands - 2) % 12) + 1
+
+        if most_recent_month in seasonal_stats and seasonal_stats[most_recent_month]["n_years"] > 0:
+            s = seasonal_stats[most_recent_month]
+            z_current = compute_zscore(current_mean, s["mean"], s["std"], MIN_STD_WATER)
+        else:
+            z_current = 0.0
+
+        anomaly_months = 0
+        monthly_zscores = []
+        for i, val in enumerate(current_stats["monthly_means"]):
+            if val <= -1.0:
+                monthly_zscores.append(0.0)
+                continue
+            cal_month = ((start_month + i - 1) % 12) + 1
+            if cal_month in seasonal_stats and seasonal_stats[cal_month]["n_years"] > 0:
+                z = compute_zscore(val, seasonal_stats[cal_month]["mean"],
+                                   seasonal_stats[cal_month]["std"], MIN_STD_WATER)
+                monthly_zscores.append(z)
+                if abs(z) > ZSCORE_THRESHOLD:
+                    anomaly_months += 1
+            else:
+                monthly_zscores.append(0.0)
+
+        month_map = group_bands_by_calendar_month(baseline_stats["valid_months_total"], BASELINE_YEARS)
+        hotspot_pct = 0.0
+        self._zscore_raster = None
+        self._hotspot_mask = None
+        if most_recent_month in month_map and len(month_map[most_recent_month]) > 0:
+            pixel_stats = compute_seasonal_stats_pixel(baseline_path, month_map[most_recent_month])
+            with rasterio.open(current_path) as src:
+                current_band_idx = min(n_current_bands, src.count)
+                current_data = src.read(current_band_idx).astype(np.float32)
+                if src.nodata is not None:
+                    current_data[current_data == src.nodata] = np.nan
+            z_raster = compute_zscore_raster(current_data, pixel_stats["mean"],
+                                              pixel_stats["std"], MIN_STD_WATER)
+            hotspot_mask, hotspot_pct = detect_hotspots(z_raster, ZSCORE_THRESHOLD)
+            self._zscore_raster = z_raster
+            self._hotspot_mask = hotspot_mask
+
+        baseline_depth = sum(1 for m in range(1, 13)
+                             if m in seasonal_stats and seasonal_stats[m]["n_years"] > 0)
+        mean_baseline_years = (sum(seasonal_stats[m]["n_years"] for m in range(1, 13)
+                                   if m in seasonal_stats) / max(baseline_depth, 1))
+        conf = compute_confidence(
+            valid_months=n_current_bands,
+            mean_obs_per_composite=5.0,
+            baseline_years_with_data=int(mean_baseline_years),
+            spatial_completeness=spatial_completeness,
         )
+        confidence = conf["level"]
+        confidence_factors = conf["factors"]
 
-        chart_data = self._build_chart_data(
-            current_stats["monthly_water_fractions"],
-            baseline_stats["monthly_water_fractions"],
-            time_range,
+        status = self._classify_zscore(z_current, hotspot_pct)
+        trend = self._compute_trend_zscore(monthly_zscores)
+        chart_data = self._build_seasonal_chart_data(
+            current_stats["monthly_water_fractions"], seasonal_stats, time_range, monthly_zscores,
         )
+        change = current_mean - baseline_stats["overall_mean"]
 
-        direction = "increase" if change_pp > 0 else "decrease"
-        if abs(change_pp) <= 5:
-            headline = f"Water extent stable ({current_frac*100:.1f}%, \u0394{change_pp:+.1f}pp)"
+        if abs(z_current) <= 1.0:
+            headline = f"Water extent within seasonal range ({current_frac*100:.1f}%, z={z_current:+.1f})"
+        elif z_current > 0:
+            headline = f"Water extent above seasonal average ({current_frac*100:.1f}%, z={z_current:+.1f})"
         else:
-            headline = f"Water extent {direction} ({change_pp:+.1f}pp vs baseline)"
+            headline = f"Water extent anomaly detected ({current_frac*100:.1f}%, z={z_current:+.1f})"
 
         self._spatial_data = SpatialData(
             map_type="raster",
@@ -299,32 +437,40 @@ class WaterIndicator(BaseIndicator):
             map_layer_path=current_path,
             chart_data=chart_data,
             data_source="satellite",
+            anomaly_months=anomaly_months,
+            z_score_current=round(z_current, 2),
+            hotspot_pct=round(hotspot_pct, 1),
+            confidence_factors=confidence_factors,
             summary=(
-                f"Water covers {current_frac*100:.1f}% of the AOI compared to "
-                f"{baseline_frac*100:.1f}% baseline ({change_pp:+.1f}pp). "
-                f"Pixel-level MNDWI analysis at {RESOLUTION_M}m resolution."
+                f"Water covers {current_frac*100:.1f}% of the AOI (mean MNDWI {current_mean:.3f}, "
+                f"z-score {z_current:+.1f} vs seasonal baseline). "
+                f"{anomaly_months} of {n_current_bands} months show significant anomalies. "
+                f"{hotspot_pct:.0f}% of AOI has statistically significant change. "
+                f"Pixel-level MNDWI analysis at {WATER_RESOLUTION_M}m resolution."
             ),
             methodology=(
                 f"Sentinel-2 L2A pixel-level MNDWI = (B03 \u2212 B11) / (B03 + B11). "
                 f"Cloud-masked using SCL band. Water classified as MNDWI > {WATER_THRESHOLD}. "
-                f"Monthly median composites at {RESOLUTION_M}m. "
-                f"Baseline: {BASELINE_YEARS}-year water extent frequency. "
-                f"Processed via CDSE openEO."
+                f"Monthly median composites at {WATER_RESOLUTION_M}m native resolution. "
+                f"Baseline: {BASELINE_YEARS}-year seasonal baselines (per calendar month). "
+                f"Anomaly detection via z-scores (threshold: \u00b1{ZSCORE_THRESHOLD}). "
+                f"Processed server-side via CDSE openEO."
             ),
             limitations=[
-                f"Resampled to {RESOLUTION_M}m \u2014 small water bodies may be missed.",
                 "Cloud/shadow contamination can cause false water detections.",
                 "Seasonal flooding may appear as change if analysis windows differ.",
                 "MNDWI threshold is fixed; turbid water may be misclassified.",
+                "Z-score anomalies assume baseline is representative of normal conditions.",
             ],
         )
 
     @staticmethod
     def _compute_stats(tif_path: str) -> dict[str, Any]:
-        """Extract monthly water fraction statistics from MNDWI GeoTIFF."""
+        """Extract monthly water fraction and MNDWI statistics from a multi-band GeoTIFF."""
         with rasterio.open(tif_path) as src:
             n_bands = src.count
             monthly_fractions = []
+            monthly_means = []
             peak_frac = -1.0
             peak_band = 1
             for band in range(1, n_bands + 1):
@@ -338,50 +484,108 @@ class WaterIndicator(BaseIndicator):
                     water_pixels = np.sum(valid > WATER_THRESHOLD)
                     frac = float(water_pixels / len(valid))
                     monthly_fractions.append(frac)
+                    mean_val = float(np.nanmean(valid))
+                    monthly_means.append(mean_val)
                     if frac > peak_frac:
                         peak_frac = frac
                         peak_band = band
                 else:
                     monthly_fractions.append(0.0)
+                    monthly_means.append(0.0)
 
-        overall = float(np.mean(monthly_fractions)) if monthly_fractions else 0.0
+        overall_frac = float(np.mean(monthly_fractions)) if monthly_fractions else 0.0
+        valid_months = sum(1 for m in monthly_means if m > -1.0)
+        overall_mean = float(np.mean([m for m in monthly_means if m > -1.0])) if valid_months > 0 else 0.0
 
         return {
             "monthly_water_fractions": monthly_fractions,
-            "overall_water_fraction": overall,
-            "valid_months": len(monthly_fractions),
+            "monthly_means": monthly_means,
+            "overall_water_fraction": overall_frac,
+            "overall_mean": overall_mean,
+            "valid_months": valid_months,
+            "valid_months_total": n_bands,
             "peak_water_band": peak_band,
         }
 
     @staticmethod
-    def _classify(change_pp: float) -> StatusLevel:
-        if change_pp <= 10:
-            return StatusLevel.GREEN
-        if change_pp <= 25:
+    def _compute_spatial_completeness(tif_path: str) -> float:
+        """Compute fraction of AOI with valid (non-nodata) pixels."""
+        with rasterio.open(tif_path) as src:
+            data = src.read(1).astype(np.float32)
+            nodata = src.nodata
+            if nodata is not None:
+                valid = np.sum(data != nodata)
+            else:
+                valid = np.sum(~np.isnan(data))
+            total = data.size
+        return float(valid / total) if total > 0 else 0.0
+
+    @staticmethod
+    def _classify_zscore(z_score: float, hotspot_pct: float) -> StatusLevel:
+        """Classify status using z-score and hotspot percentage."""
+        if abs(z_score) > ZSCORE_THRESHOLD or hotspot_pct > 25:
+            return StatusLevel.RED
+        if abs(z_score) > 1.0 or hotspot_pct > 10:
             return StatusLevel.AMBER
-        return StatusLevel.RED
+        return StatusLevel.GREEN
 
     @staticmethod
-    def _compute_trend(change_pp: float) -> TrendDirection:
-        if abs(change_pp) <= 5:
+    def _compute_trend_zscore(monthly_zscores: list[float]) -> TrendDirection:
+        """Compute trend from direction of monthly z-scores."""
+        valid = [z for z in monthly_zscores if z != 0.0]
+        if len(valid) < 2:
             return TrendDirection.STABLE
-        if change_pp > 0:
-            return TrendDirection.DETERIORATING  # flooding
-        return TrendDirection.DETERIORATING  # drought
+        within_normal = sum(1 for z in valid if abs(z) <= 1.0)
+        if within_normal > len(valid) / 2:
+            return TrendDirection.STABLE
+        negative = sum(1 for z in valid if z < -1.0)
+        positive = sum(1 for z in valid if z > 1.0)
+        if negative > positive:
+            return TrendDirection.DETERIORATING
+        if positive > negative:
+            return TrendDirection.IMPROVING
+        return TrendDirection.STABLE
 
     @staticmethod
-    def _build_chart_data(
-        current_monthly: list[float],
-        baseline_monthly: list[float],
+    def _build_seasonal_chart_data(
+        current_monthly_fractions: list[float],
+        seasonal_stats: dict[int, dict],
         time_range: TimeRange,
+        monthly_zscores: list[float],
     ) -> dict[str, Any]:
+        """Build chart data with seasonal baseline envelope (water extent %)."""
+        start_month = time_range.start.month
+        n = len(current_monthly_fractions)
         year = time_range.end.year
-        n = min(len(current_monthly), len(baseline_monthly))
-        dates = [f"{year}-{m + 1:02d}" for m in range(n)]
-        values = [round(v * 100, 1) for v in current_monthly[:n]]
-        b_mean = [round(v * 100, 1) for v in baseline_monthly[:n]]
-        b_min = [round(max(v * 100 - 5, 0), 1) for v in baseline_monthly[:n]]
-        b_max = [round(min(v * 100 + 5, 100), 1) for v in baseline_monthly[:n]]
+
+        dates = []
+        values = []
+        b_mean = []
+        b_min = []
+        b_max = []
+        anomaly_flags = []
+
+        for i in range(n):
+            cal_month = ((start_month + i - 1) % 12) + 1
+            dates.append(f"{year}-{cal_month:02d}")
+            values.append(round(current_monthly_fractions[i] * 100, 1))
+
+            if cal_month in seasonal_stats and seasonal_stats[cal_month]["n_years"] > 0:
+                s = seasonal_stats[cal_month]
+                # Convert MNDWI-based stats to approximate water fraction percentages
+                # using baseline mean/min/max as proxies for extent envelope
+                b_mean.append(round(s["mean"] * 100, 1) if s["mean"] > 0 else 0.0)
+                b_min.append(round(s["min"] * 100, 1) if s["min"] > 0 else 0.0)
+                b_max.append(round(s["max"] * 100, 1) if s["max"] > 0 else 0.0)
+            else:
+                b_mean.append(0.0)
+                b_min.append(0.0)
+                b_max.append(0.0)
+
+            if i < len(monthly_zscores):
+                anomaly_flags.append(abs(monthly_zscores[i]) > ZSCORE_THRESHOLD)
+            else:
+                anomaly_flags.append(False)
 
         return {
             "dates": dates,
@@ -389,6 +593,6 @@ class WaterIndicator(BaseIndicator):
             "baseline_mean": b_mean,
             "baseline_min": b_min,
             "baseline_max": b_max,
+            "anomaly_flags": anomaly_flags,
             "label": "Water extent (%)",
         }
-