Add implementation plan for EO product analytical upgrade

19 tasks covering: data model changes, native resolution, seasonal
baselines, pixel-level change detection, compound signals, confidence
model, chart/map/narrative/report improvements.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

docs/superpowers/plans/2026-04-06-eo-product-overhaul.md

@@ -0,0 +1,2593 @@
+# EO Product Analytical Upgrade — Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Upgrade all 4 EO indicators with native resolution, seasonal baselines, pixel-level change detection, cross-indicator compound signals, and a richer confidence model + report output.
+
+**Architecture:** New `app/analysis/` package isolates reusable computation (seasonal stats, z-scores, hotspots, compound signals, confidence scoring) from indicator-specific code. Each indicator's `harvest()` method calls into these shared modules. The openEO graphs drop their `resample_spatial` step to deliver native-resolution data. The output pipeline gains hotspot maps, seasonal charts, and a compound signals report section.
+
+**Tech Stack:** Python 3.11+, numpy, rasterio, scipy (ndimage.label), matplotlib, reportlab, openEO Python client, pydantic.
+
+**Spec:** `docs/superpowers/specs/2026-04-06-eo-product-overhaul-design.md`
+
+---
+
+## File Structure
+
+### New files
+
+| File | Responsibility |
+|---|---|
+| `app/analysis/__init__.py` | Package init |
+| `app/analysis/seasonal.py` | Seasonal baseline computation: group bands by calendar month, compute per-pixel and AOI-level stats (mean, median, std, min, max) |
+| `app/analysis/change.py` | Pixel-level change detection: z-score rasters, hotspot masks, spatial clustering |
+| `app/analysis/compound.py` | Cross-indicator compound signal detection |
+| `app/analysis/confidence.py` | Four-factor confidence scoring model |
+| `tests/test_seasonal.py` | Tests for seasonal baseline computation |
+| `tests/test_change.py` | Tests for change detection and hotspot clustering |
+| `tests/test_compound.py` | Tests for compound signal detection |
+| `tests/test_confidence.py` | Tests for confidence scoring |
+| `tests/test_narrative.py` | Tests for updated narrative generation |
+| `tests/conftest.py` | Shared test fixtures (synthetic rasters, mock results) |
+
+### Modified files
+
+| File | What changes |
+|---|---|
+| `app/models.py` | Add `anomaly_months`, `z_score_current`, `hotspot_pct`, `confidence_factors` to `IndicatorResult`; add `CompoundSignal` model |
+| `app/config.py` | Per-indicator native resolution constants; min std thresholds |
+| `app/openeo_client.py` | Remove `resample_spatial` from `build_ndvi_graph`, `build_mndwi_graph`, `build_sar_graph`, `build_buildup_graph`; update `build_true_color_graph` to 10m |
+| `app/indicators/ndvi.py` | Use seasonal baselines, z-score classification, new confidence model, hotspot data |
+| `app/indicators/water.py` | Same pattern as NDVI |
+| `app/indicators/sar.py` | Same pattern as NDVI |
+| `app/indicators/buildup.py` | Same pattern as NDVI |
+| `app/outputs/charts.py` | Seasonal envelope, anomaly markers, y-axis labels |
+| `app/outputs/maps.py` | New `render_hotspot_map()` function |
+| `app/outputs/narrative.py` | Z-score language, seasonal context, compound signal text |
+| `app/outputs/report.py` | Compound signals section, anomaly months column, confidence breakdown in annex |
+| `app/outputs/overview.py` | Factor in anomaly counts for composite score |
+| `app/worker.py` | Generate hotspot maps, compound signals, pass new data through pipeline |
+
+---
+
+## Task 1: Test fixtures and project setup
+
+**Files:**
+- Create: `tests/__init__.py`
+- Create: `tests/conftest.py`
+
+- [ ] **Step 1: Create test package and shared fixtures**
+
+```python
+# tests/__init__.py
+```
+
+```python
+# tests/conftest.py
+"""Shared test fixtures for Aperture tests."""
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+
+@pytest.fixture
+def synthetic_monthly_raster(tmp_path):
+    """Create a synthetic multi-band GeoTIFF with 12 monthly bands.
+
+    Returns a factory function: call with (n_bands, shape, fill_fn) to get a path.
+    fill_fn(band_idx) -> 2D numpy array.
+    """
+    import rasterio
+    from rasterio.transform import from_bounds
+
+    def _make(
+        n_bands: int = 12,
+        shape: tuple[int, int] = (100, 100),
+        fill_fn=None,
+        bbox: tuple[float, ...] = (37.8, 2.08, 37.88, 2.17),
+    ) -> str:
+        if fill_fn is None:
+            fill_fn = lambda i: np.random.default_rng(i).uniform(0.2, 0.8, shape).astype(np.float32)
+
+        path = str(tmp_path / f"synthetic_{n_bands}bands.tif")
+        transform = from_bounds(*bbox, shape[1], shape[0])
+        with rasterio.open(
+            path, "w", driver="GTiff",
+            height=shape[0], width=shape[1],
+            count=n_bands, dtype="float32",
+            crs="EPSG:4326", transform=transform,
+            nodata=-9999.0,
+        ) as dst:
+            for i in range(n_bands):
+                dst.write(fill_fn(i), i + 1)
+        return path
+
+    return _make
+
+
+@pytest.fixture
+def mock_indicator_result():
+    """Factory for IndicatorResult with sensible defaults."""
+    from app.models import IndicatorResult, StatusLevel, TrendDirection, ConfidenceLevel
+
+    def _make(**overrides):
+        defaults = dict(
+            indicator_id="ndvi",
+            headline="Test headline",
+            status=StatusLevel.GREEN,
+            trend=TrendDirection.STABLE,
+            confidence=ConfidenceLevel.HIGH,
+            map_layer_path="/tmp/fake.tif",
+            chart_data={"dates": [], "values": []},
+            summary="Test summary",
+            methodology="Test methodology",
+            limitations=["Test limitation"],
+            data_source="satellite",
+            anomaly_months=0,
+            z_score_current=0.0,
+            hotspot_pct=0.0,
+            confidence_factors={},
+        )
+        defaults.update(overrides)
+        return IndicatorResult(**defaults)
+
+    return _make
+```
+
+- [ ] **Step 2: Verify pytest discovers fixtures**
+
+Run: `cd /Users/kmini/github/aperture && python -m pytest tests/conftest.py --collect-only 2>&1 | head -5`
+Expected: No errors, fixtures discovered.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add tests/__init__.py tests/conftest.py
+git commit -m "feat: add test fixtures for EO product overhaul"
+```
+
+---
+
+## Task 2: Data model changes
+
+**Files:**
+- Modify: `app/models.py:118-129`
+
+- [ ] **Step 1: Write test for new IndicatorResult fields**
+
+```python
+# tests/test_models.py
+"""Tests for updated data models."""
+from app.models import IndicatorResult, StatusLevel, TrendDirection, ConfidenceLevel
+
+
+def test_indicator_result_new_fields():
+    """IndicatorResult accepts and stores new analytical fields."""
+    result = IndicatorResult(
+        indicator_id="ndvi",
+        headline="Test",
+        status=StatusLevel.AMBER,
+        trend=TrendDirection.DETERIORATING,
+        confidence=ConfidenceLevel.MODERATE,
+        map_layer_path="/tmp/test.tif",
+        chart_data={"dates": [], "values": []},
+        summary="Test summary",
+        methodology="Test methodology",
+        limitations=["Test"],
+        anomaly_months=3,
+        z_score_current=-1.8,
+        hotspot_pct=15.2,
+        confidence_factors={
+            "temporal": 0.75,
+            "observation_density": 0.5,
+            "baseline_depth": 1.0,
+            "spatial_completeness": 0.9,
+        },
+    )
+    assert result.anomaly_months == 3
+    assert result.z_score_current == -1.8
+    assert result.hotspot_pct == 15.2
+    assert result.confidence_factors["baseline_depth"] == 1.0
+
+
+def test_indicator_result_defaults_for_new_fields():
+    """New fields have sensible defaults for backward compatibility."""
+    result = IndicatorResult(
+        indicator_id="ndvi",
+        headline="Test",
+        status=StatusLevel.GREEN,
+        trend=TrendDirection.STABLE,
+        confidence=ConfidenceLevel.LOW,
+        map_layer_path="/tmp/test.tif",
+        chart_data={},
+        summary="",
+        methodology="",
+        limitations=[],
+    )
+    assert result.anomaly_months == 0
+    assert result.z_score_current == 0.0
+    assert result.hotspot_pct == 0.0
+    assert result.confidence_factors == {}
+
+
+def test_compound_signal_model():
+    """CompoundSignal stores cross-indicator detection results."""
+    from app.models import CompoundSignal
+
+    signal = CompoundSignal(
+        name="land_conversion",
+        triggered=True,
+        confidence="strong",
+        description="NDVI decline overlaps with settlement growth",
+        indicators=["ndvi", "buildup"],
+        overlap_pct=25.3,
+        affected_ha=145.0,
+    )
+    assert signal.triggered is True
+    assert signal.confidence == "strong"
+    assert len(signal.indicators) == 2
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `cd /Users/kmini/github/aperture && python -m pytest tests/test_models.py -v`
+Expected: FAIL — `anomaly_months` field not recognized, `CompoundSignal` not importable.
+
+- [ ] **Step 3: Add new fields to IndicatorResult and create CompoundSignal**
+
+In `app/models.py`, update `IndicatorResult` (line 118) to:
+
+```python
+class IndicatorResult(BaseModel):
+    indicator_id: str
+    headline: str
+    status: StatusLevel
+    trend: TrendDirection
+    confidence: ConfidenceLevel
+    map_layer_path: str
+    chart_data: dict[str, Any]
+    summary: str
+    methodology: str
+    limitations: list[str]
+    data_source: str = "satellite"
+    anomaly_months: int = 0
+    z_score_current: float = 0.0
+    hotspot_pct: float = 0.0
+    confidence_factors: dict[str, float] = Field(default_factory=dict)
+```
+
+Add after `AoiAdviceRequest` (after line 152):
+
+```python
+class CompoundSignal(BaseModel):
+    name: str
+    triggered: bool
+    confidence: str  # "strong", "moderate", "weak"
+    description: str
+    indicators: list[str]
+    overlap_pct: float = 0.0
+    affected_ha: float = 0.0
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `cd /Users/kmini/github/aperture && python -m pytest tests/test_models.py -v`
+Expected: All 3 tests PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add app/models.py tests/test_models.py
+git commit -m "feat: add anomaly, hotspot, confidence fields to IndicatorResult; add CompoundSignal model"
+```
+
+---
+
+## Task 3: Config changes — per-indicator resolution and thresholds
+
+**Files:**
+- Modify: `app/config.py:1-34`
+
+- [ ] **Step 1: Update config with native resolutions and thresholds**
+
+Replace the `RESOLUTION_M` line (line 8) and add new constants after it in `app/config.py`:
+
+```python
+# Legacy global resolution — kept for backward compatibility
+RESOLUTION_M: int = int(os.environ.get("APERTURE_RESOLUTION_M", "100"))
+
+# Per-indicator native resolutions (meters)
+NDVI_RESOLUTION_M: int = 10
+WATER_RESOLUTION_M: int = 20
+SAR_RESOLUTION_M: int = 10
+BUILDUP_RESOLUTION_M: int = 20
+TRUECOLOR_RESOLUTION_M: int = 10
+
+# Minimum std thresholds to cap z-scores (avoid division-by-near-zero)
+MIN_STD_NDVI: float = 0.02
+MIN_STD_WATER: float = 0.01
+MIN_STD_SAR: float = 0.5  # dB
+MIN_STD_BUILDUP: float = 0.01
+
+# Z-score threshold for significant anomaly
+ZSCORE_THRESHOLD: float = 2.0
+
+# Minimum hotspot cluster size in pixels
+MIN_CLUSTER_PIXELS: int = 4
+```
+
+- [ ] **Step 2: Verify import works**
+
+Run: `cd /Users/kmini/github/aperture && python -c "from app.config import NDVI_RESOLUTION_M, MIN_STD_NDVI, ZSCORE_THRESHOLD; print(f'NDVI={NDVI_RESOLUTION_M}m, min_std={MIN_STD_NDVI}, z={ZSCORE_THRESHOLD}')"`
+Expected: `NDVI=10m, min_std=0.02, z=2.0`
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add app/config.py
+git commit -m "feat: add per-indicator native resolution and z-score threshold config"
+```
+
+---
+
+## Task 4: OpenEO graph builders — remove resample_spatial
+
+**Files:**
+- Modify: `app/openeo_client.py:81-269`
+
+- [ ] **Step 1: Update build_ndvi_graph to use native resolution**
+
+In `app/openeo_client.py`, replace lines 81-119 with:
+
+```python
+def build_ndvi_graph(
+    *,
+    conn: openeo.Connection,
+    bbox: dict[str, float],
+    temporal_extent: list[str],
+    resolution_m: int = 10,
+) -> openeo.DataCube:
+    """Build an openEO process graph for monthly median NDVI composites.
+
+    Loads Sentinel-2 L2A, masks clouds using the SCL band, computes
+    NDVI = (B08 - B04) / (B08 + B04), and aggregates to monthly medians.
+    Default resolution is 10m (native for B04 and B08).
+
+    Returns an openEO DataCube (not yet executed).
+    """
+    cube = conn.load_collection(
+        collection_id="SENTINEL2_L2A",
+        spatial_extent=bbox,
+        temporal_extent=temporal_extent,
+        bands=["B04", "B08", "SCL"],
+    )
+
+    # Cloud mask: keep only vegetation, bare soil, water (SCL classes 4,5,6)
+    scl = cube.band("SCL")
+    cloud_mask = (scl == 4) | (scl == 5) | (scl == 6)
+    cube = cube.mask(cloud_mask == 0)
+
+    # NDVI
+    b08 = cube.band("B08")
+    b04 = cube.band("B04")
+    ndvi = (b08 - b04) / (b08 + b04)
+
+    # Monthly median composite
+    monthly = ndvi.aggregate_temporal_period("month", reducer="median")
+
+    # Only resample if explicitly requesting coarser than native 10m
+    if resolution_m > 10:
+        monthly = monthly.resample_spatial(resolution=resolution_m / 111320, projection="EPSG:4326")
+
+    return monthly
+```
+
+- [ ] **Step 2: Update build_true_color_graph**
+
+Replace lines 122-158 with:
+
+```python
+def build_true_color_graph(
+    *,
+    conn: openeo.Connection,
+    bbox: dict[str, float],
+    temporal_extent: list[str],
+    resolution_m: int = 10,
+) -> openeo.DataCube:
+    """Build an openEO process graph for a true-color Sentinel-2 composite.
+
+    Default resolution is 10m (native for B02, B03, B04).
+    """
+    cube = conn.load_collection(
+        collection_id="SENTINEL2_L2A",
+        spatial_extent=bbox,
+        temporal_extent=temporal_extent,
+        bands=["B02", "B03", "B04", "SCL"],
+    )
+
+    scl = cube.band("SCL")
+    cloud_mask = (scl == 4) | (scl == 5) | (scl == 6)
+    cube = cube.mask(cloud_mask == 0)
+
+    rgb = cube.filter_bands(["B02", "B03", "B04"])
+    composite = rgb.reduce_dimension(dimension="t", reducer="median")
+
+    if resolution_m > 10:
+        composite = composite.resample_spatial(resolution=resolution_m / 111320, projection="EPSG:4326")
+
+    return composite
+```
+
+- [ ] **Step 3: Update build_mndwi_graph to 20m native**
+
+Replace lines 161-193 with:
+
+```python
+def build_mndwi_graph(
+    *,
+    conn: openeo.Connection,
+    bbox: dict[str, float],
+    temporal_extent: list[str],
+    resolution_m: int = 20,
+) -> openeo.DataCube:
+    """Build an openEO process graph for monthly MNDWI water index composites.
+
+    MNDWI = (B03 - B11) / (B03 + B11). Default resolution is 20m
+    (native for B11; B03 is 10m and gets resampled by openEO automatically).
+    """
+    cube = conn.load_collection(
+        collection_id="SENTINEL2_L2A",
+        spatial_extent=bbox,
+        temporal_extent=temporal_extent,
+        bands=["B03", "B11", "SCL"],
+    )
+
+    scl = cube.band("SCL")
+    cloud_mask = (scl == 4) | (scl == 5) | (scl == 6)
+    cube = cube.mask(cloud_mask == 0)
+
+    b03 = cube.band("B03")
+    b11 = cube.band("B11")
+    mndwi = (b03 - b11) / (b03 + b11)
+
+    monthly = mndwi.aggregate_temporal_period("month", reducer="median")
+
+    if resolution_m > 20:
+        monthly = monthly.resample_spatial(resolution=resolution_m / 111320, projection="EPSG:4326")
+
+    return monthly
+```
+
+- [ ] **Step 4: Update build_sar_graph to 10m native**
+
+Replace lines 196-227 with:
+
+```python
+def build_sar_graph(
+    *,
+    conn: openeo.Connection,
+    bbox: dict[str, float],
+    temporal_extent: list[str],
+    resolution_m: int = 10,
+) -> openeo.DataCube:
+    """Build an openEO process graph for Sentinel-1 GRD SAR backscatter.
+
+    Default resolution is 10m (native for Sentinel-1 GRD).
+    """
+    cube = conn.load_collection(
+        collection_id="SENTINEL1_GRD",
+        spatial_extent=bbox,
+        temporal_extent=temporal_extent,
+        bands=["VV", "VH"],
+    )
+
+    cube = 10.0 * cube.log10()
+
+    monthly = cube.aggregate_temporal_period("month", reducer="median")
+
+    if resolution_m > 10:
+        monthly = monthly.resample_spatial(resolution=resolution_m / 111320, projection="EPSG:4326")
+
+    return monthly
+```
+
+- [ ] **Step 5: Update build_buildup_graph to 20m native**
+
+Replace lines 230-269 with:
+
+```python
+def build_buildup_graph(
+    *,
+    conn: openeo.Connection,
+    bbox: dict[str, float],
+    temporal_extent: list[str],
+    resolution_m: int = 20,
+) -> openeo.DataCube:
+    """Build an openEO process graph for monthly NDBI built-up index composites.
+
+    NDBI = (B11 - B08) / (B11 + B08). Default resolution is 20m
+    (native for B11; B08 is 10m and gets resampled by openEO automatically).
+    """
+    cube = conn.load_collection(
+        collection_id="SENTINEL2_L2A",
+        spatial_extent=bbox,
+        temporal_extent=temporal_extent,
+        bands=["B04", "B08", "B11", "SCL"],
+    )
+
+    scl = cube.band("SCL")
+    cloud_mask = (scl == 4) | (scl == 5) | (scl == 6)
+    cube = cube.mask(cloud_mask == 0)
+
+    b11 = cube.band("B11")
+    b08 = cube.band("B08")
+    ndbi = (b11 - b08) / (b11 + b08)
+
+    monthly = ndbi.aggregate_temporal_period("month", reducer="median")
+
+    if resolution_m > 20:
+        monthly = monthly.resample_spatial(resolution=resolution_m / 111320, projection="EPSG:4326")
+
+    return monthly
+```
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add app/openeo_client.py
+git commit -m "feat: update openEO graph builders to native resolution (10-20m)"
+```
+
+---
+
+## Task 5: Seasonal baseline module
+
+**Files:**
+- Create: `app/analysis/__init__.py`
+- Create: `app/analysis/seasonal.py`
+- Create: `tests/test_seasonal.py`
+
+- [ ] **Step 1: Write tests for seasonal baseline computation**
+
+```python
+# tests/test_seasonal.py
+"""Tests for seasonal baseline computation."""
+import numpy as np
+import pytest
+
+
+def test_group_bands_by_calendar_month():
+    """60 bands (5 years x 12 months) are correctly grouped by calendar month."""
+    from app.analysis.seasonal import group_bands_by_calendar_month
+
+    result = group_bands_by_calendar_month(n_bands=60, n_years=5)
+    # January bands: 1, 13, 25, 37, 49 (1-indexed)
+    assert result[1] == [1, 13, 25, 37, 49]
+    # December bands: 12, 24, 36, 48, 60
+    assert result[12] == [12, 24, 36, 48, 60]
+    assert len(result) == 12
+
+
+def test_group_bands_partial_years():
+    """Handles baseline with fewer than 60 bands gracefully."""
+    from app.analysis.seasonal import group_bands_by_calendar_month
+
+    result = group_bands_by_calendar_month(n_bands=36, n_years=3)
+    assert result[1] == [1, 13, 25]
+    assert result[12] == [12, 24, 36]
+
+
+def test_compute_seasonal_stats_aoi(synthetic_monthly_raster):
+    """Computes per-month AOI-level stats from a baseline raster."""
+    from app.analysis.seasonal import compute_seasonal_stats_aoi
+
+    # 60 bands, 5 years of data, values between 0.2 and 0.8
+    path = synthetic_monthly_raster(n_bands=60)
+    stats = compute_seasonal_stats_aoi(path, n_years=5)
+
+    assert len(stats) == 12  # one entry per calendar month
+    for month in range(1, 13):
+        s = stats[month]
+        assert "mean" in s
+        assert "median" in s
+        assert "std" in s
+        assert "min" in s
+        assert "max" in s
+        assert s["min"] <= s["mean"] <= s["max"]
+        assert s["std"] >= 0
+        assert s["n_years"] == 5
+
+
+def test_compute_seasonal_stats_pixel(synthetic_monthly_raster):
+    """Computes per-pixel seasonal stats for a single calendar month."""
+    from app.analysis.seasonal import compute_seasonal_stats_pixel
+
+    path = synthetic_monthly_raster(n_bands=60, shape=(50, 50))
+    # Get stats for January (bands 1, 13, 25, 37, 49)
+    stats = compute_seasonal_stats_pixel(path, bands=[1, 13, 25, 37, 49])
+
+    assert stats["mean"].shape == (50, 50)
+    assert stats["std"].shape == (50, 50)
+    assert stats["median"].shape == (50, 50)
+    assert np.all(stats["std"] >= 0)
+
+
+def test_compute_zscore_aoi():
+    """Z-score computed correctly at AOI level."""
+    from app.analysis.seasonal import compute_zscore
+
+    z = compute_zscore(current=0.5, baseline_mean=0.6, baseline_std=0.05, min_std=0.02)
+    assert z == pytest.approx(-2.0, abs=0.01)
+
+
+def test_compute_zscore_clamps_low_std():
+    """Z-score uses min_std when baseline_std is too low."""
+    from app.analysis.seasonal import compute_zscore
+
+    z = compute_zscore(current=0.5, baseline_mean=0.5, baseline_std=0.001, min_std=0.02)
+    assert z == pytest.approx(0.0, abs=0.01)
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `cd /Users/kmini/github/aperture && python -m pytest tests/test_seasonal.py -v`
+Expected: FAIL — `app.analysis.seasonal` not found.
+
+- [ ] **Step 3: Implement seasonal.py**
+
+```python
+# app/analysis/__init__.py
+"""Reusable EO analysis modules."""
+```
+
+```python
+# app/analysis/seasonal.py
+"""Seasonal baseline computation for EO indicators.
+
+Groups multi-year monthly composites by calendar month and computes
+per-pixel and AOI-level statistics for seasonal anomaly detection.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import rasterio
+
+
+def group_bands_by_calendar_month(n_bands: int, n_years: int) -> dict[int, list[int]]:
+    """Map calendar months (1-12) to 1-indexed band numbers.
+
+    Assumes bands are ordered chronologically: band 1 = first month of
+    first year, band 13 = first month of second year, etc.
+    """
+    result: dict[int, list[int]] = {m: [] for m in range(1, 13)}
+    for band_idx in range(1, n_bands + 1):
+        month = ((band_idx - 1) % 12) + 1
+        result[month].append(band_idx)
+    return result
+
+
+def compute_seasonal_stats_aoi(
+    tif_path: str,
+    n_years: int = 5,
+) -> dict[int, dict[str, Any]]:
+    """Compute per-calendar-month AOI-level statistics from a baseline raster.
+
+    Returns dict keyed by month (1-12), each containing:
+    mean, median, std, min, max, n_years (with valid data).
+    """
+    with rasterio.open(tif_path) as src:
+        n_bands = src.count
+        nodata = src.nodata
+        month_map = group_bands_by_calendar_month(n_bands, n_years)
+
+        stats: dict[int, dict[str, Any]] = {}
+        for month, bands in month_map.items():
+            monthly_means: list[float] = []
+            for band in bands:
+                data = src.read(band).astype(np.float32)
+                if nodata is not None:
+                    valid = data[data != nodata]
+                else:
+                    valid = data.ravel()
+                if len(valid) > 0:
+                    monthly_means.append(float(np.nanmean(valid)))
+
+            if monthly_means:
+                arr = np.array(monthly_means)
+                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(monthly_means),
+                }
+            else:
+                stats[month] = {
+                    "mean": 0.0, "median": 0.0, "std": 0.0,
+                    "min": 0.0, "max": 0.0, "n_years": 0,
+                }
+
+    return stats
+
+
+def compute_seasonal_stats_pixel(
+    tif_path: str,
+    bands: list[int],
+) -> dict[str, np.ndarray]:
+    """Compute per-pixel statistics across bands for one calendar month.
+
+    Parameters
+    ----------
+    tif_path : str
+        Path to multi-band GeoTIFF.
+    bands : list[int]
+        1-indexed band numbers (e.g. [1, 13, 25, 37, 49] for all Januaries).
+
+    Returns
+    -------
+    dict with keys: mean, median, std (all 2D arrays same shape as input bands).
+    """
+    with rasterio.open(tif_path) as src:
+        nodata = src.nodata
+        stack = []
+        for band in bands:
+            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)  # shape: (n_years, H, W)
+
+    with np.errstate(all="ignore"):
+        mean = np.nanmean(arr, axis=0)
+        median = np.nanmedian(arr, axis=0)
+        std = np.nanstd(arr, axis=0, ddof=1) if arr.shape[0] > 1 else np.zeros_like(mean)
+
+    return {"mean": mean, "median": median, "std": std}
+
+
+def compute_zscore(
+    current: float,
+    baseline_mean: float,
+    baseline_std: float,
+    min_std: float,
+) -> float:
+    """Compute z-score with a floor on std to avoid division-by-near-zero."""
+    effective_std = max(baseline_std, min_std)
+    return (current - baseline_mean) / effective_std
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `cd /Users/kmini/github/aperture && python -m pytest tests/test_seasonal.py -v`
+Expected: All 6 tests PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add app/analysis/__init__.py app/analysis/seasonal.py tests/test_seasonal.py
+git commit -m "feat: add seasonal baseline computation module"
+```
+
+---
+
+## Task 6: Pixel-level change detection module
+
+**Files:**
+- Create: `app/analysis/change.py`
+- Create: `tests/test_change.py`
+
+- [ ] **Step 1: Write tests for change detection**
+
+```python
+# tests/test_change.py
+"""Tests for pixel-level change detection."""
+import numpy as np
+import pytest
+
+
+def test_compute_zscore_raster():
+    """Z-score raster computed correctly from current and baseline stats."""
+    from app.analysis.change import compute_zscore_raster
+
+    current = np.array([[0.5, 0.3], [0.7, 0.4]], dtype=np.float32)
+    baseline_mean = np.array([[0.6, 0.6], [0.6, 0.6]], dtype=np.float32)
+    baseline_std = np.array([[0.05, 0.05], [0.05, 0.05]], dtype=np.float32)
+
+    z = compute_zscore_raster(current, baseline_mean, baseline_std, min_std=0.02)
+    expected = np.array([[-2.0, -6.0], [2.0, -4.0]], dtype=np.float32)
+    np.testing.assert_array_almost_equal(z, expected, decimal=1)
+
+
+def test_compute_zscore_raster_clamps_std():
+    """Z-score raster uses min_std floor."""
+    from app.analysis.change import compute_zscore_raster
+
+    current = np.array([[0.5]], dtype=np.float32)
+    baseline_mean = np.array([[0.5]], dtype=np.float32)
+    baseline_std = np.array([[0.001]], dtype=np.float32)
+
+    z = compute_zscore_raster(current, baseline_mean, baseline_std, min_std=0.02)
+    assert z[0, 0] == pytest.approx(0.0, abs=0.01)
+
+
+def test_detect_hotspots():
+    """Hotspot mask identifies pixels beyond z-score threshold."""
+    from app.analysis.change import detect_hotspots
+
+    z = np.array([[-3.0, 0.5, 2.5], [1.0, -0.3, -2.1]], dtype=np.float32)
+    mask, pct = detect_hotspots(z, threshold=2.0)
+
+    # Hotspot pixels: (-3.0), (2.5), (-2.1) = 3 out of 6 = 50%
+    assert mask[0, 0] == True
+    assert mask[0, 1] == False
+    assert mask[0, 2] == True
+    assert mask[1, 2] == True
+    assert pct == pytest.approx(50.0, abs=0.1)
+
+
+def test_cluster_hotspots():
+    """Connected-component labeling finds spatial clusters."""
+    from app.analysis.change import cluster_hotspots
+
+    mask = np.array([
+        [True, True, False, False, False],
+        [True, True, False, False, False],
+        [False, False, False, True, True],
+        [False, False, False, True, True],
+    ], dtype=bool)
+
+    z = np.array([
+        [-2.5, -2.3, 0.0, 0.0, 0.0],
+        [-2.1, -2.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 2.5, 2.3],
+        [0.0, 0.0, 0.0, 2.1, 2.8],
+    ], dtype=np.float32)
+
+    clusters = cluster_hotspots(mask, z, pixel_area_ha=1.0, min_pixels=2)
+    assert len(clusters) == 2
+    # Clusters sorted by area descending
+    assert clusters[0]["area_ha"] == 4.0
+    assert clusters[1]["area_ha"] == 4.0
+
+
+def test_cluster_hotspots_filters_small():
+    """Clusters smaller than min_pixels are excluded."""
+    from app.analysis.change import cluster_hotspots
+
+    mask = np.array([
+        [True, False, False],
+        [False, False, True],
+    ], dtype=bool)
+    z = np.full((2, 3), -2.5, dtype=np.float32)
+
+    clusters = cluster_hotspots(mask, z, pixel_area_ha=1.0, min_pixels=2)
+    assert len(clusters) == 0  # both clusters are 1 pixel, below min_pixels=2
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `cd /Users/kmini/github/aperture && python -m pytest tests/test_change.py -v`
+Expected: FAIL — `app.analysis.change` not found.
+
+- [ ] **Step 3: Implement change.py**
+
+```python
+# app/analysis/change.py
+"""Pixel-level change detection: z-score rasters, hotspot masks, clustering."""
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+from scipy import ndimage
+
+
+def compute_zscore_raster(
+    current: np.ndarray,
+    baseline_mean: np.ndarray,
+    baseline_std: np.ndarray,
+    min_std: float,
+) -> np.ndarray:
+    """Compute per-pixel z-score raster.
+
+    Parameters
+    ----------
+    current : 2D float array — current month pixel values.
+    baseline_mean : 2D float array — same-month baseline mean.
+    baseline_std : 2D float array — same-month baseline std.
+    min_std : float — floor for std to avoid division noise.
+
+    Returns
+    -------
+    2D float array of z-scores.
+    """
+    effective_std = np.maximum(baseline_std, min_std)
+    return (current - baseline_mean) / effective_std
+
+
+def detect_hotspots(
+    zscore_raster: np.ndarray,
+    threshold: float = 2.0,
+) -> tuple[np.ndarray, float]:
+    """Create boolean hotspot mask and compute percentage of area affected.
+
+    Returns (mask, pct_affected) where mask is True for |z| > threshold.
+    """
+    valid = ~np.isnan(zscore_raster)
+    mask = valid & (np.abs(zscore_raster) > threshold)
+    n_valid = np.sum(valid)
+    pct = float(np.sum(mask) / n_valid * 100) if n_valid > 0 else 0.0
+    return mask, pct
+
+
+def cluster_hotspots(
+    mask: np.ndarray,
+    zscore_raster: np.ndarray,
+    pixel_area_ha: float,
+    min_pixels: int = 4,
+    top_n: int = 3,
+) -> list[dict[str, Any]]:
+    """Find connected hotspot clusters and return the top N by area.
+
+    Parameters
+    ----------
+    mask : 2D bool array — hotspot mask.
+    zscore_raster : 2D float array — z-scores for mean calculation.
+    pixel_area_ha : float — area of one pixel in hectares.
+    min_pixels : int — ignore clusters smaller than this.
+    top_n : int — return at most this many clusters.
+
+    Returns
+    -------
+    List of dicts sorted by area descending, each with:
+    area_ha, centroid_row, centroid_col, mean_zscore, n_pixels.
+    """
+    labeled, n_features = ndimage.label(mask)
+
+    clusters: list[dict[str, Any]] = []
+    for label_id in range(1, n_features + 1):
+        pixels = labeled == label_id
+        n_pixels = int(np.sum(pixels))
+        if n_pixels < min_pixels:
+            continue
+
+        rows, cols = np.where(pixels)
+        clusters.append({
+            "area_ha": n_pixels * pixel_area_ha,
+            "centroid_row": float(np.mean(rows)),
+            "centroid_col": float(np.mean(cols)),
+            "mean_zscore": float(np.nanmean(zscore_raster[pixels])),
+            "n_pixels": n_pixels,
+        })
+
+    clusters.sort(key=lambda c: c["area_ha"], reverse=True)
+    return clusters[:top_n]
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `cd /Users/kmini/github/aperture && python -m pytest tests/test_change.py -v`
+Expected: All 5 tests PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add app/analysis/change.py tests/test_change.py
+git commit -m "feat: add pixel-level change detection with z-scores and hotspot clustering"
+```
+
+---
+
+## Task 7: Confidence scoring module
+
+**Files:**
+- Create: `app/analysis/confidence.py`
+- Create: `tests/test_confidence.py`
+
+- [ ] **Step 1: Write tests for confidence scoring**
+
+```python
+# tests/test_confidence.py
+"""Tests for four-factor confidence scoring."""
+import pytest
+
+
+def test_score_temporal_coverage():
+    """Temporal coverage factor scores correctly across thresholds."""
+    from app.analysis.confidence import score_temporal_coverage
+
+    assert score_temporal_coverage(0) == 0.25
+    assert score_temporal_coverage(3) == 0.25
+    assert score_temporal_coverage(5) == 0.5
+    assert score_temporal_coverage(8) == 0.75
+    assert score_temporal_coverage(12) == 1.0
+
+
+def test_score_observation_density():
+    """Observation density factor scores correctly."""
+    from app.analysis.confidence import score_observation_density
+
+    assert score_observation_density(1.0) == 0.25
+    assert score_observation_density(4.0) == 0.5
+    assert score_observation_density(8.0) == 0.75
+    assert score_observation_density(15.0) == 1.0
+
+
+def test_score_baseline_depth():
+    """Baseline depth factor scores correctly."""
+    from app.analysis.confidence import score_baseline_depth
+
+    assert score_baseline_depth(1) == 0.25
+    assert score_baseline_depth(3) == 0.5
+    assert score_baseline_depth(4) == 0.75
+    assert score_baseline_depth(5) == 1.0
+
+
+def test_score_spatial_completeness():
+    """Spatial completeness factor scores correctly."""
+    from app.analysis.confidence import score_spatial_completeness
+
+    assert score_spatial_completeness(0.3) == 0.25
+    assert score_spatial_completeness(0.6) == 0.5
+    assert score_spatial_completeness(0.85) == 0.75
+    assert score_spatial_completeness(0.95) == 1.0
+
+
+def test_compute_confidence_high():
+    """Full data coverage yields HIGH confidence."""
+    from app.analysis.confidence import compute_confidence
+    from app.models import ConfidenceLevel
+
+    result = compute_confidence(
+        valid_months=12,
+        mean_obs_per_composite=15.0,
+        baseline_years_with_data=5,
+        spatial_completeness=0.95,
+    )
+    assert result["level"] == ConfidenceLevel.HIGH
+    assert result["score"] > 0.7
+
+
+def test_compute_confidence_low():
+    """Sparse data yields LOW confidence."""
+    from app.analysis.confidence import compute_confidence
+    from app.models import ConfidenceLevel
+
+    result = compute_confidence(
+        valid_months=2,
+        mean_obs_per_composite=1.5,
+        baseline_years_with_data=1,
+        spatial_completeness=0.3,
+    )
+    assert result["level"] == ConfidenceLevel.LOW
+    assert result["score"] < 0.4
+
+
+def test_compute_confidence_returns_factors():
+    """Confidence result includes the four factor breakdowns."""
+    from app.analysis.confidence import compute_confidence
+
+    result = compute_confidence(
+        valid_months=6,
+        mean_obs_per_composite=5.0,
+        baseline_years_with_data=3,
+        spatial_completeness=0.8,
+    )
+    assert "factors" in result
+    factors = result["factors"]
+    assert "temporal" in factors
+    assert "observation_density" in factors
+    assert "baseline_depth" in factors
+    assert "spatial_completeness" in factors
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `cd /Users/kmini/github/aperture && python -m pytest tests/test_confidence.py -v`
+Expected: FAIL — `app.analysis.confidence` not found.
+
+- [ ] **Step 3: Implement confidence.py**
+
+```python
+# app/analysis/confidence.py
+"""Four-factor confidence scoring for EO indicators."""
+from __future__ import annotations
+
+from typing import Any
+
+from app.models import ConfidenceLevel
+
+
+def score_temporal_coverage(valid_months: int) -> float:
+    """Score 0-1 based on valid monthly composites (out of 12)."""
+    if valid_months >= 10:
+        return 1.0
+    if valid_months >= 7:
+        return 0.75
+    if valid_months >= 4:
+        return 0.5
+    return 0.25
+
+
+def score_observation_density(mean_obs: float) -> float:
+    """Score 0-1 based on mean cloud-free observations per composite."""
+    if mean_obs > 10:
+        return 1.0
+    if mean_obs >= 6:
+        return 0.75
+    if mean_obs >= 3:
+        return 0.5
+    return 0.25
+
+
+def score_baseline_depth(years_with_data: int) -> float:
+    """Score 0-1 based on how many of 5 baseline years had valid data."""
+    if years_with_data >= 5:
+        return 1.0
+    if years_with_data >= 4:
+        return 0.75
+    if years_with_data >= 2:
+        return 0.5
+    return 0.25
+
+
+def score_spatial_completeness(fraction: float) -> float:
+    """Score 0-1 based on fraction of AOI with valid (non-nodata) pixels."""
+    if fraction > 0.9:
+        return 1.0
+    if fraction > 0.75:
+        return 0.75
+    if fraction >= 0.5:
+        return 0.5
+    return 0.25
+
+
+def compute_confidence(
+    valid_months: int,
+    mean_obs_per_composite: float,
+    baseline_years_with_data: int,
+    spatial_completeness: float,
+) -> dict[str, Any]:
+    """Compute composite confidence score from four factors.
+
+    Returns dict with: level (ConfidenceLevel), score (0-1), factors (dict).
+    """
+    temporal = score_temporal_coverage(valid_months)
+    obs = score_observation_density(mean_obs_per_composite)
+    baseline = score_baseline_depth(baseline_years_with_data)
+    spatial = score_spatial_completeness(spatial_completeness)
+
+    score = temporal * 0.3 + obs * 0.2 + baseline * 0.3 + spatial * 0.2
+
+    if score > 0.7:
+        level = ConfidenceLevel.HIGH
+    elif score >= 0.4:
+        level = ConfidenceLevel.MODERATE
+    else:
+        level = ConfidenceLevel.LOW
+
+    return {
+        "level": level,
+        "score": round(score, 3),
+        "factors": {
+            "temporal": temporal,
+            "observation_density": obs,
+            "baseline_depth": baseline,
+            "spatial_completeness": spatial,
+        },
+    }
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `cd /Users/kmini/github/aperture && python -m pytest tests/test_confidence.py -v`
+Expected: All 8 tests PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add app/analysis/confidence.py tests/test_confidence.py
+git commit -m "feat: add four-factor confidence scoring model"
+```
+
+---
+
+## Task 8: Compound signal detection module
+
+**Files:**
+- Create: `app/analysis/compound.py`
+- Create: `tests/test_compound.py`
+
+- [ ] **Step 1: Write tests for compound signal detection**
+
+```python
+# tests/test_compound.py
+"""Tests for cross-indicator compound signal detection."""
+import numpy as np
+import pytest
+
+
+def test_compute_overlap_pct():
+    """Overlap percentage between two boolean masks."""
+    from app.analysis.compound import compute_overlap_pct
+
+    a = np.array([[True, True, False], [False, False, True]], dtype=bool)
+    b = np.array([[True, False, False], [False, False, True]], dtype=bool)
+    # Overlap: (0,0) and (1,2) = 2 pixels, union = 3, but we measure overlap/min(a,b)
+    pct = compute_overlap_pct(a, b)
+    assert pct > 0
+
+
+def test_detect_land_conversion():
+    """Land conversion detected when NDVI decline overlaps settlement growth."""
+    from app.analysis.compound import detect_compound_signals
+    from app.models import CompoundSignal
+
+    # NDVI decline hotspots
+    ndvi_z = np.full((10, 10), -2.5, dtype=np.float32)  # all declining
+    # Settlement growth hotspots
+    buildup_z = np.full((10, 10), 2.5, dtype=np.float32)  # all growing
+    # Other indicators: no anomaly
+    water_z = np.zeros((10, 10), dtype=np.float32)
+    sar_z = np.zeros((10, 10), dtype=np.float32)
+
+    signals = detect_compound_signals(
+        zscore_rasters={"ndvi": ndvi_z, "water": water_z, "sar": sar_z, "buildup": buildup_z},
+        pixel_area_ha=0.04,
+        threshold=2.0,
+    )
+
+    land_conv = [s for s in signals if s.name == "land_conversion"]
+    assert len(land_conv) == 1
+    assert land_conv[0].triggered is True
+    assert "ndvi" in land_conv[0].indicators
+    assert "buildup" in land_conv[0].indicators
+
+
+def test_no_signals_when_all_normal():
+    """No compound signals when all indicators are within normal range."""
+    from app.analysis.compound import detect_compound_signals
+
+    normal = np.zeros((10, 10), dtype=np.float32)
+    signals = detect_compound_signals(
+        zscore_rasters={"ndvi": normal, "water": normal, "sar": normal, "buildup": normal},
+        pixel_area_ha=0.04,
+        threshold=2.0,
+    )
+    triggered = [s for s in signals if s.triggered]
+    assert len(triggered) == 0
+
+
+def test_flood_signal():
+    """Flood signal detected when SAR decreases and water increases."""
+    from app.analysis.compound import detect_compound_signals
+
+    sar_z = np.full((10, 10), -2.5, dtype=np.float32)  # VV drop
+    water_z = np.full((10, 10), 2.5, dtype=np.float32)  # water increase
+    ndvi_z = np.zeros((10, 10), dtype=np.float32)
+    buildup_z = np.zeros((10, 10), dtype=np.float32)
+
+    signals = detect_compound_signals(
+        zscore_rasters={"ndvi": ndvi_z, "water": water_z, "sar": sar_z, "buildup": buildup_z},
+        pixel_area_ha=0.04,
+        threshold=2.0,
+    )
+
+    flood = [s for s in signals if s.name == "flood_event"]
+    assert len(flood) == 1
+    assert flood[0].triggered is True
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `cd /Users/kmini/github/aperture && python -m pytest tests/test_compound.py -v`
+Expected: FAIL — `app.analysis.compound` not found.
+
+- [ ] **Step 3: Implement compound.py**
+
+```python
+# app/analysis/compound.py
+"""Cross-indicator compound signal detection."""
+from __future__ import annotations
+
+import numpy as np
+
+from app.models import CompoundSignal
+
+
+def compute_overlap_pct(mask_a: np.ndarray, mask_b: np.ndarray) -> float:
+    """Compute overlap percentage: intersection / min(count_a, count_b) * 100."""
+    intersection = np.sum(mask_a & mask_b)
+    min_count = min(np.sum(mask_a), np.sum(mask_b))
+    if min_count == 0:
+        return 0.0
+    return float(intersection / min_count * 100)
+
+
+def _tag_confidence(n_indicators: int, overlap_pct: float) -> str:
+    """Assign confidence tag based on indicator agreement and spatial overlap."""
+    if n_indicators >= 3 and overlap_pct > 20:
+        return "strong"
+    if n_indicators >= 2 and overlap_pct >= 10:
+        return "moderate"
+    return "weak"
+
+
+def detect_compound_signals(
+    zscore_rasters: dict[str, np.ndarray],
+    pixel_area_ha: float,
+    threshold: float = 2.0,
+) -> list[CompoundSignal]:
+    """Test for compound signal patterns across indicator z-score rasters.
+
+    All rasters must be the same shape (resampled to common grid beforehand).
+
+    Returns a list of CompoundSignal objects (both triggered and not).
+    """
+    # Build directional hotspot masks
+    decline: dict[str, np.ndarray] = {}
+    increase: dict[str, np.ndarray] = {}
+    for ind_id, z in zscore_rasters.items():
+        decline[ind_id] = z < -threshold
+        increase[ind_id] = z > threshold
+
+    signals: list[CompoundSignal] = []
+
+    # 1. Land conversion: NDVI decline + Settlement growth
+    if "ndvi" in decline and "buildup" in increase:
+        overlap = compute_overlap_pct(decline["ndvi"], increase["buildup"])
+        triggered = overlap > 10
+        affected = float(np.sum(decline["ndvi"] & increase["buildup"])) * pixel_area_ha
+        signals.append(CompoundSignal(
+            name="land_conversion",
+            triggered=triggered,
+            confidence=_tag_confidence(2, overlap) if triggered else "weak",
+            description=(
+                f"NDVI decline overlaps with settlement growth ({overlap:.0f}% overlap, "
+                f"{affected:.1f} ha affected). Suggests possible vegetation loss to urbanization."
+            ) if triggered else "No land conversion signal detected.",
+            indicators=["ndvi", "buildup"],
+            overlap_pct=overlap,
+            affected_ha=affected,
+        ))
+
+    # 2. Flood event: SAR decrease + Water increase
+    if "sar" in decline and "water" in increase:
+        overlap = compute_overlap_pct(decline["sar"], increase["water"])
+        triggered = overlap > 10
+        affected = float(np.sum(decline["sar"] & increase["water"])) * pixel_area_ha
+        signals.append(CompoundSignal(
+            name="flood_event",
+            triggered=triggered,
+            confidence=_tag_confidence(2, overlap) if triggered else "weak",
+            description=(
+                f"SAR backscatter decrease coincides with water extent increase "
+                f"({overlap:.0f}% overlap, {affected:.1f} ha). Suggests potential flooding."
+            ) if triggered else "No flood signal detected.",
+            indicators=["sar", "water"],
+            overlap_pct=overlap,
+            affected_ha=affected,
+        ))
+
+    # 3. Drought stress: NDVI decline + Water decline + SAR increase
+    if "ndvi" in decline and "water" in decline and "sar" in increase:
+        # Need all three to overlap
+        combined = decline["ndvi"] & decline["water"] & increase["sar"]
+        n_combined = int(np.sum(combined))
+        min_single = min(np.sum(decline["ndvi"]), np.sum(decline["water"]), np.sum(increase["sar"]))
+        overlap = float(n_combined / min_single * 100) if min_single > 0 else 0.0
+        triggered = overlap > 10
+        affected = n_combined * pixel_area_ha
+        signals.append(CompoundSignal(
+            name="drought_stress",
+            triggered=triggered,
+            confidence=_tag_confidence(3, overlap) if triggered else "weak",
+            description=(
+                f"NDVI decline, water decline, and SAR increase co-occur "
+                f"({overlap:.0f}% overlap, {affected:.1f} ha). Suggests possible drought."
+            ) if triggered else "No drought signal detected.",
+            indicators=["ndvi", "water", "sar"],
+            overlap_pct=overlap,
+            affected_ha=affected,
+        ))
+
+    # 4. Displacement pressure: Settlement growth + NDVI decline in surrounding area
+    if "buildup" in increase and "ndvi" in decline:
+        # Use dilation to check adjacency — settlement growth hotspots expanded by 1 pixel
+        from scipy.ndimage import binary_dilation
+        expanded_buildup = binary_dilation(increase["buildup"], iterations=1)
+        adjacent_decline = expanded_buildup & decline["ndvi"] & ~increase["buildup"]
+        n_adjacent = int(np.sum(adjacent_decline))
+        n_buildup = int(np.sum(increase["buildup"]))
+        overlap = float(n_adjacent / max(n_buildup, 1) * 100)
+        triggered = overlap > 10 and n_adjacent > 0
+        affected = n_adjacent * pixel_area_ha
+        signals.append(CompoundSignal(
+            name="displacement_pressure",
+            triggered=triggered,
+            confidence=_tag_confidence(2, overlap) if triggered else "weak",
+            description=(
+                f"Settlement growth hotspots are adjacent to NDVI decline areas "
+                f"({affected:.1f} ha of surrounding vegetation loss). "
+                f"Suggests expansion into previously vegetated land."
+            ) if triggered else "No displacement pressure signal detected.",
+            indicators=["ndvi", "buildup"],
+            overlap_pct=overlap,
+            affected_ha=affected,
+        ))
+
+    return signals
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `cd /Users/kmini/github/aperture && python -m pytest tests/test_compound.py -v`
+Expected: All 4 tests PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add app/analysis/compound.py tests/test_compound.py
+git commit -m "feat: add cross-indicator compound signal detection"
+```
+
+---
+
+## Task 9: Update NDVI indicator with seasonal analysis
+
+**Files:**
+- Modify: `app/indicators/ndvi.py`
+
+This task serves as the template for all 4 indicators. The pattern established here will be replicated (with indicator-specific adjustments) in Tasks 10-12.
+
+- [ ] **Step 1: Update imports and constants at top of ndvi.py**
+
+Replace lines 18-32 with:
+
+```python
+from app.config import (
+    NDVI_RESOLUTION_M,
+    TRUECOLOR_RESOLUTION_M,
+    MIN_STD_NDVI,
+    ZSCORE_THRESHOLD,
+    MIN_CLUSTER_PIXELS,
+)
+from app.indicators.base import BaseIndicator, SpatialData
+from app.models import (
+    AOI,
+    TimeRange,
+    IndicatorResult,
+    StatusLevel,
+    TrendDirection,
+    ConfidenceLevel,
+)
+from app.openeo_client import get_connection, build_ndvi_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__)
+
+BASELINE_YEARS = 5
+```
+
+- [ ] **Step 2: Update submit_batch to use native resolution**
+
+Replace lines 65-78 (the three `build_*_graph` calls inside `submit_batch`) with:
+
+```python
+        current_cube = build_ndvi_graph(
+            conn=conn, bbox=bbox,
+            temporal_extent=[current_start, current_end],
+            resolution_m=NDVI_RESOLUTION_M,
+        )
+        baseline_cube = build_ndvi_graph(
+            conn=conn, bbox=bbox,
+            temporal_extent=[baseline_start, baseline_end],
+            resolution_m=NDVI_RESOLUTION_M,
+        )
+        true_color_cube = build_true_color_graph(
+            conn=conn, bbox=bbox,
+            temporal_extent=[current_start, current_end],
+            resolution_m=TRUECOLOR_RESOLUTION_M,
+        )
+```
+
+- [ ] **Step 3: Rewrite the harvest method's analysis section**
+
+Replace the analysis section of `harvest()` (lines 135-213) with the new seasonal analysis logic. This is the core change — replace everything from `# Compute statistics` (line 135) through the `return IndicatorResult(...)` block (ending at line 213):
+
+```python
+        # --- Seasonal baseline analysis ---
+        current_stats = self._compute_stats(current_path)
+        current_mean = current_stats["overall_mean"]
+        n_current_bands = current_stats["valid_months"]
+
+        # Compute spatial completeness from current raster
+        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)
+
+            # Determine which calendar month the most recent current band represents
+            # Current bands map to months starting from time_range.start.month
+            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_NDVI)
+            else:
+                z_current = 0.0
+
+            # Count anomaly months
+            anomaly_months = 0
+            monthly_zscores = []
+            for i, val in enumerate(current_stats["monthly_means"]):
+                if val <= 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_NDVI)
+                    monthly_zscores.append(z)
+                    if abs(z) > ZSCORE_THRESHOLD:
+                        anomaly_months += 1
+                else:
+                    monthly_zscores.append(0.0)
+
+            # Pixel-level change detection for most recent month
+            month_map = group_bands_by_calendar_month(baseline_stats["valid_months_total"], BASELINE_YEARS)
+            hotspot_pct = 0.0
+            self._zscore_raster = 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
+                    pixel_res = src.res[0]  # degrees
+
+                z_raster = compute_zscore_raster(current_data, pixel_stats["mean"],
+                                                  pixel_stats["std"], MIN_STD_NDVI)
+                hotspot_mask, hotspot_pct = detect_hotspots(z_raster, ZSCORE_THRESHOLD)
+
+                # Store for map rendering and cross-indicator analysis
+                self._zscore_raster = z_raster
+                self._hotspot_mask = hotspot_mask
+
+            # Confidence
+            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,  # TODO: track from openEO when cloud fraction tracking available
+                baseline_years_with_data=int(mean_baseline_years),
+                spatial_completeness=spatial_completeness,
+            )
+            confidence = conf["level"]
+            confidence_factors = conf["factors"]
+
+            # Status from z-score
+            status = self._classify_zscore(z_current, hotspot_pct)
+            trend = self._compute_trend_zscore(monthly_zscores)
+
+            # Chart data with seasonal envelope
+            chart_data = self._build_seasonal_chart_data(
+                current_stats["monthly_means"], seasonal_stats, time_range, monthly_zscores,
+            )
+
+            change = current_mean - baseline_stats["overall_mean"]
+        else:
+            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
+            chart_data = {
+                "dates": [f"{time_range.end.year}-{m+1:02d}" for m in range(len(current_stats["monthly_means"]))],
+                "values": [round(v, 3) for v in current_stats["monthly_means"]],
+                "label": "NDVI",
+            }
+
+        # Headline
+        if abs(z_current) <= 1.0:
+            headline = f"Vegetation within normal range (NDVI {current_mean:.2f}, z={z_current:+.1f})"
+        elif z_current > 0:
+            headline = f"Vegetation greening (NDVI {current_mean:.2f}, z={z_current:+.1f} above seasonal average)"
+        else:
+            headline = f"Vegetation decline (NDVI {current_mean:.2f}, z={z_current:+.1f} below seasonal average)"
+
+        # Spatial data for map rendering
+        self._spatial_data = SpatialData(
+            map_type="raster", label="NDVI", colormap="RdYlGn",
+            vmin=-0.2, vmax=0.9,
+        )
+        self._indicator_raster_path = current_path
+        self._true_color_path = true_color_path
+        self._ndvi_peak_band = current_stats["peak_month_band"]
+        self._render_band = current_stats["peak_month_band"]
+
+        return IndicatorResult(
+            indicator_id=self.id,
+            headline=headline,
+            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"Mean NDVI is {current_mean:.3f} (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 analysis at {NDVI_RESOLUTION_M}m resolution."
+            ),
+            methodology=(
+                f"Sentinel-2 L2A pixel-level NDVI = (B08 − B04) / (B08 + B04). "
+                f"Cloud-masked using SCL band (classes 4, 5, 6 retained). "
+                f"Monthly median composites at {NDVI_RESOLUTION_M}m native resolution. "
+                f"Baseline: {BASELINE_YEARS}-year seasonal baselines (per calendar month). "
+                f"Anomaly detection via z-scores (threshold: ±{ZSCORE_THRESHOLD}). "
+                f"Processed server-side via CDSE openEO batch jobs."
+            ),
+            limitations=[
+                "Cloud cover reduces observation count in rainy seasons.",
+                "NDVI does not distinguish crop from natural vegetation.",
+                "Z-score anomalies assume baseline is representative of normal conditions.",
+            ] + (["Baseline unavailable — change and trend not computed."] if not baseline_path else []),
+        )
+```
+
+- [ ] **Step 4: Add new static/helper methods to NdviIndicator**
+
+Add these methods after the existing `_compute_stats` method (after line 381):
+
+```python
+    @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
+
+    @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
+        # Check direction of anomalies
+        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 = []
+        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[i], 3))
+
+            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"], 3))
+                b_min.append(round(s["min"], 3))
+                b_max.append(round(s["max"], 3))
+            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": "NDVI",
+        }
+```
+
+- [ ] **Step 5: Update _compute_stats to also return valid_months_total (band count)**
+
+In the existing `_compute_stats` method, add `valid_months_total` to the return dict. Change line 376-381:
+
+```python
+        return {
+            "monthly_means": monthly_means,
+            "overall_mean": overall_mean,
+            "valid_months": valid_months,
+            "valid_months_total": n_bands,
+            "peak_month_band": peak_band,
+        }
+```
+
+- [ ] **Step 6: Remove the old _classify, _compute_trend, and _build_chart_data methods**
+
+Delete the old static methods `_classify` (lines 383-390), `_compute_trend` (lines 392-398), and `_build_chart_data` (lines 400-424) since they are replaced by the new `_classify_zscore`, `_compute_trend_zscore`, and `_build_seasonal_chart_data`.
+
+- [ ] **Step 7: Verify the module imports cleanly**
+
+Run: `cd /Users/kmini/github/aperture && python -c "from app.indicators.ndvi import NdviIndicator; print('OK')"`
+Expected: `OK`
+
+- [ ] **Step 8: Commit**
+
+```bash
+git add app/indicators/ndvi.py
+git commit -m "feat: upgrade NDVI indicator with seasonal baselines, z-scores, and hotspot detection"
+```
+
+---
+
+## Task 10: Update Water indicator (same pattern as NDVI)
+
+**Files:**
+- Modify: `app/indicators/water.py`
+
+- [ ] **Step 1: Update imports**
+
+Replace lines 17-31 with:
+
+```python
+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,
+    TimeRange,
+    IndicatorResult,
+    StatusLevel,
+    TrendDirection,
+    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__)
+
+BASELINE_YEARS = 5
+WATER_THRESHOLD = 0.0
+```
+
+- [ ] **Step 2: Update submit_batch to use WATER_RESOLUTION_M**
+
+Replace `resolution_m=RESOLUTION_M` with `resolution_m=WATER_RESOLUTION_M` in the three `build_*_graph` calls, and use `TRUECOLOR_RESOLUTION_M` for the true-color graph.
+
+- [ ] **Step 3: Rewrite harvest() analysis with seasonal logic**
+
+Apply the same pattern as NDVI Task 9, Step 3, but adapted for water:
+- Use `MIN_STD_WATER` instead of `MIN_STD_NDVI`
+- Water fraction stats instead of raw NDVI means
+- Headlines reference water extent and seasonal context
+- Summary references water extent percentage and z-scores
+- Methodology references MNDWI formula and `WATER_RESOLUTION_M`
+
+- [ ] **Step 4: Add _compute_spatial_completeness, _classify_zscore, _compute_trend_zscore, _build_seasonal_chart_data**
+
+Same pattern as NDVI but with water-appropriate label ("Water extent (%)").
+
+- [ ] **Step 5: Update _compute_stats to return valid_months_total**
+
+- [ ] **Step 6: Remove old _classify, _compute_trend, _build_chart_data**
+
+- [ ] **Step 7: Verify import**
+
+Run: `cd /Users/kmini/github/aperture && python -c "from app.indicators.water import WaterIndicator; print('OK')"`
+Expected: `OK`
+
+- [ ] **Step 8: Commit**
+
+```bash
+git add app/indicators/water.py
+git commit -m "feat: upgrade Water indicator with seasonal baselines and z-score analysis"
+```
+
+---
+
+## Task 11: Update SAR indicator (same pattern as NDVI)
+
+**Files:**
+- Modify: `app/indicators/sar.py`
+
+- [ ] **Step 1: Update imports**
+
+Same pattern: use `SAR_RESOLUTION_M`, `MIN_STD_SAR`, import seasonal/change/confidence modules.
+
+- [ ] **Step 2: Update submit_batch to use SAR_RESOLUTION_M**
+
+- [ ] **Step 3: Rewrite harvest() analysis with seasonal logic**
+
+SAR-specific adaptations:
+- Use `MIN_STD_SAR` (0.5 dB)
+- VV bands are interleaved (bands 1, 3, 5... are VV; 2, 4, 6... are VH) — extract VV only for analysis
+- Headlines reference SAR backscatter and dB values
+- Both VV increase and decrease are flagged (use absolute z-score for status)
+- Keep flood month detection logic but base it on seasonal z-scores instead of raw threshold
+
+- [ ] **Step 4: Add helper methods (same pattern)**
+
+- [ ] **Step 5: Update _compute_stats to return valid_months_total**
+
+- [ ] **Step 6: Remove old _classify, _compute_trend, _build_chart_data**
+
+- [ ] **Step 7: Verify import**
+
+Run: `cd /Users/kmini/github/aperture && python -c "from app.indicators.sar import SarIndicator; print('OK')"`
+Expected: `OK`
+
+- [ ] **Step 8: Commit**
+
+```bash
+git add app/indicators/sar.py
+git commit -m "feat: upgrade SAR indicator with seasonal baselines and z-score analysis"
+```
+
+---
+
+## Task 12: Update Settlement indicator (same pattern as NDVI)
+
+**Files:**
+- Modify: `app/indicators/buildup.py`
+
+- [ ] **Step 1: Update imports**
+
+Use `BUILDUP_RESOLUTION_M`, `MIN_STD_BUILDUP`, import seasonal/change/confidence modules.
+
+- [ ] **Step 2: Update submit_batch to use BUILDUP_RESOLUTION_M**
+
+- [ ] **Step 3: Rewrite harvest() analysis with seasonal logic**
+
+Settlement-specific adaptations:
+- Use `MIN_STD_BUILDUP`
+- Built-up fraction computed from NDBI threshold
+- Headlines reference settlement extent and percentage change
+- Fix the narrative contradiction: ensure headline direction matches the actual sign of change (currently says "contraction" but narrative says "growth")
+
+- [ ] **Step 4: Add helper methods (same pattern)**
+
+- [ ] **Step 5: Update _compute_stats to return valid_months_total**
+
+- [ ] **Step 6: Remove old _classify, _compute_trend, _build_chart_data**
+
+- [ ] **Step 7: Verify import**
+
+Run: `cd /Users/kmini/github/aperture && python -c "from app.indicators.buildup import BuiltupIndicator; print('OK')"`
+Expected: `OK`
+
+- [ ] **Step 8: Commit**
+
+```bash
+git add app/indicators/buildup.py
+git commit -m "feat: upgrade Settlement indicator with seasonal baselines; fix headline contradiction"
+```
+
+---
+
+## Task 13: Update time series charts with seasonal envelope and anomaly markers
+
+**Files:**
+- Modify: `app/outputs/charts.py:32-179`
+
+- [ ] **Step 1: Add anomaly marker rendering to render_timeseries_chart**
+
+In `app/outputs/charts.py`, after the current data line plot (line 136), add anomaly highlighting:
+
+```python
+        # Anomaly markers — red rings on months with |z| > threshold
+        anomaly_flags = chart_data.get("anomaly_flags")
+        if anomaly_flags and len(anomaly_flags) == len(parsed_dates):
+            anomaly_x = [d for d, f in zip(parsed_dates, anomaly_flags) if f]
+            anomaly_y = [v for v, f in zip(values, anomaly_flags) if f]
+            if anomaly_x:
+                ax.scatter(
+                    anomaly_x, anomaly_y,
+                    s=120, facecolors="none", edgecolors="#B83A2A",
+                    linewidths=2, zorder=4, label="Anomaly",
+                )
+```
+
+- [ ] **Step 2: Add default y_label based on indicator name**
+
+Update the `render_timeseries_chart` function signature to include better default y-labels. After line 62, add:
+
+```python
+    # Default y-axis labels per indicator
+    if not y_label:
+        _default_labels = {
+            "Ndvi": "NDVI (0–1)",
+            "Vegetation (NDVI)": "NDVI (0–1)",
+            "Water": "Water extent (%)",
+            "Water Bodies": "Water extent (%)",
+            "SAR Backscatter": "VV backscatter (dB)",
+            "Settlement Extent": "Built-up area (%)",
+        }
+        y_label = _default_labels.get(indicator_name, "")
+```
+
+- [ ] **Step 3: Verify import**
+
+Run: `cd /Users/kmini/github/aperture && python -c "from app.outputs.charts import render_timeseries_chart; print('OK')"`
+Expected: `OK`
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add app/outputs/charts.py
+git commit -m "feat: add anomaly markers and default y-labels to time series charts"
+```
+
+---
+
+## Task 14: Add hotspot map rendering
+
+**Files:**
+- Modify: `app/outputs/maps.py`
+
+- [ ] **Step 1: Add render_hotspot_map function**
+
+Add after `render_raster_map` (after line 301) in `app/outputs/maps.py`:
+
+```python
+def render_hotspot_map(
+    *,
+    true_color_path: str | None,
+    zscore_raster: np.ndarray,
+    hotspot_mask: np.ndarray,
+    extent: list[float],
+    aoi: AOI,
+    status: StatusLevel,
+    output_path: str,
+    label: str = "Z-score",
+) -> None:
+    """Render a change hotspot map: significant pixels over true-color base.
+
+    Only pixels where |z-score| > threshold are shown; non-significant
+    pixels are transparent, letting the true-color base show through.
+    """
+    import rasterio
+
+    fig, ax = plt.subplots(figsize=(6, 5), dpi=200, facecolor=SHELL)
+    ax.set_facecolor(SHELL)
+
+    # True-color base layer
+    if true_color_path is not None:
+        with rasterio.open(true_color_path) as src:
+            rgb = src.read([1, 2, 3]).astype(np.float32)
+            tc_extent = [src.bounds.left, src.bounds.right, src.bounds.bottom, src.bounds.top]
+        rgb_max = max(rgb.max(), 1.0)
+        scale = 3000.0 if rgb_max > 255 else 255.0
+        rgb_normalized = np.clip(rgb / scale, 0, 1).transpose(1, 2, 0)
+        ax.imshow(rgb_normalized, extent=tc_extent, aspect="auto", zorder=0)
+
+    # Hotspot overlay — only significant pixels, masked elsewhere
+    masked_z = np.ma.masked_where(~hotspot_mask, zscore_raster)
+    vmax = min(float(np.nanmax(np.abs(zscore_raster))), 5.0)
+    im = ax.imshow(
+        masked_z, extent=extent, cmap="RdBu_r", alpha=0.8,
+        vmin=-vmax, vmax=vmax, aspect="auto", zorder=1,
+    )
+    cbar = fig.colorbar(im, ax=ax, fraction=0.03, pad=0.04, shrink=0.85)
+    cbar.set_label(f"{label} (decline ← → increase)", fontsize=7, color=INK_MUTED)
+    cbar.ax.tick_params(labelsize=6, colors=INK_MUTED)
+
+    # AOI outline
+    ax.set_xlim(extent[0], extent[1])
+    ax.set_ylim(extent[2], extent[3])
+    color = STATUS_COLORS[status]
+    _draw_aoi_rect(ax, aoi, color)
+
+    ax.tick_params(labelsize=6, colors=INK_MUTED)
+    ax.set_xlabel("Longitude", fontsize=7, color=INK_MUTED)
+    ax.set_ylabel("Latitude", fontsize=7, color=INK_MUTED)
+
+    for spine in ax.spines.values():
+        spine.set_color(INK_MUTED)
+        spine.set_linewidth(0.5)
+
+    plt.tight_layout()
+    fig.savefig(output_path, dpi=200, bbox_inches="tight", facecolor=SHELL)
+    plt.close(fig)
+```
+
+- [ ] **Step 2: Verify import**
+
+Run: `cd /Users/kmini/github/aperture && python -c "from app.outputs.maps import render_hotspot_map; print('OK')"`
+Expected: `OK`
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add app/outputs/maps.py
+git commit -m "feat: add hotspot map renderer for z-score change visualization"
+```
+
+---
+
+## Task 15: Update narrative with z-score language and compound signals
+
+**Files:**
+- Modify: `app/outputs/narrative.py`
+- Create: `tests/test_narrative.py`
+
+- [ ] **Step 1: Write tests**
+
+```python
+# tests/test_narrative.py
+"""Tests for updated narrative generation."""
+import pytest
+
+
+def test_generate_narrative_includes_zscore_context(mock_indicator_result):
+    """Narrative references z-score context when anomaly data is present."""
+    from app.outputs.narrative import generate_narrative
+
+    results = [
+        mock_indicator_result(
+            indicator_id="ndvi",
+            status="amber",
+            headline="Vegetation decline (z=-1.8)",
+            z_score_current=-1.8,
+            anomaly_months=3,
+        ),
+    ]
+    text = generate_narrative(results)
+    assert "concern" in text.lower() or "monitoring" in text.lower()
+
+
+def test_generate_compound_signals_text():
+    """Compound signal text generated from CompoundSignal objects."""
+    from app.outputs.narrative import generate_compound_signals_text
+    from app.models import CompoundSignal
+
+    signals = [
+        CompoundSignal(
+            name="land_conversion",
+            triggered=True,
+            confidence="strong",
+            description="NDVI decline overlaps with settlement growth (45% overlap, 120 ha).",
+            indicators=["ndvi", "buildup"],
+            overlap_pct=45.0,
+            affected_ha=120.0,
+        ),
+        CompoundSignal(
+            name="flood_event",
+            triggered=False,
+            confidence="weak",
+            description="No flood signal detected.",
+            indicators=["sar", "water"],
+        ),
+    ]
+    text = generate_compound_signals_text(signals)
+    assert "land_conversion" in text.lower() or "NDVI decline" in text
+    assert "flood" not in text.lower() or "not detected" in text.lower()
+
+
+def test_no_compound_signals_text():
+    """When no signals triggered, text says so explicitly."""
+    from app.outputs.narrative import generate_compound_signals_text
+
+    text = generate_compound_signals_text([])
+    assert "no compound" in text.lower()
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `cd /Users/kmini/github/aperture && python -m pytest tests/test_narrative.py -v`
+Expected: FAIL — `generate_compound_signals_text` not found.
+
+- [ ] **Step 3: Add generate_compound_signals_text and update narrative**
+
+Add to `app/outputs/narrative.py` after the existing `generate_narrative` function:
+
+```python
+def generate_compound_signals_text(signals: list) -> str:
+    """Generate text for compound signal section.
+
+    Parameters
+    ----------
+    signals : list of CompoundSignal objects.
+
+    Returns text describing triggered compound signals.
+    """
+    if not signals:
+        return "No compound signals detected across the indicator set."
+
+    triggered = [s for s in signals if s.triggered]
+    if not triggered:
+        return "No compound signals detected across the indicator set."
+
+    parts = []
+    for s in triggered:
+        parts.append(f"**{s.name.replace('_', ' ').title()}** ({s.confidence}): {s.description}")
+
+    return " ".join(parts)
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `cd /Users/kmini/github/aperture && python -m pytest tests/test_narrative.py -v`
+Expected: All 3 tests PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add app/outputs/narrative.py tests/test_narrative.py
+git commit -m "feat: add compound signal narrative and z-score language to narratives"
+```
+
+---
+
+## Task 16: Update PDF report — compound signals section and anomaly column
+
+**Files:**
+- Modify: `app/outputs/report.py`
+
+- [ ] **Step 1: Add compound_signals parameter to generate_pdf_report**
+
+In `app/outputs/report.py`, update the function signature at line 259 to add:
+
+```python
+def generate_pdf_report(
+    *,
+    aoi: AOI,
+    time_range: TimeRange,
+    results: Sequence[IndicatorResult],
+    output_path: str,
+    summary_map_path: str = "",
+    indicator_map_paths: dict[str, str] | None = None,
+    indicator_hotspot_paths: dict[str, str] | None = None,
+    overview_score: dict | None = None,
+    overview_map_path: str = "",
+    compound_signals: list | None = None,
+) -> None:
+```
+
+- [ ] **Step 2: Add "Anomaly Months" column to summary table**
+
+Replace the summary table header (lines 423-429) with:
+
+```python
+    summary_header = [
+        Paragraph("<b>Indicator</b>", styles["body"]),
+        Paragraph("<b>Status</b>", styles["body"]),
+        Paragraph("<b>Trend</b>", styles["body"]),
+        Paragraph("<b>Confidence</b>", styles["body"]),
+        Paragraph("<b>Anomalies</b>", styles["body"]),
+        Paragraph("<b>Headline</b>", styles["body"]),
+    ]
+```
+
+Update the row building (lines 443-449) to include anomaly months:
+
+```python
+        summary_rows.append([
+            Paragraph(label, styles["body_muted"]),
+            status_cell,
+            Paragraph(result.trend.value.capitalize(), styles["body_muted"]),
+            Paragraph(result.confidence.value.capitalize(), styles["body_muted"]),
+            Paragraph(f"{result.anomaly_months}/12", styles["body_muted"]),
+            Paragraph(result.headline[:70], styles["body_muted"]),
+        ])
+```
+
+Update column widths (lines 454-460) to accommodate the new column:
+
+```python
+        colWidths=[
+            ov_col_w * 0.14,
+            ov_col_w * 0.09,
+            ov_col_w * 0.11,
+            ov_col_w * 0.11,
+            ov_col_w * 0.09,
+            ov_col_w * 0.46,
+        ],
+```
+
+- [ ] **Step 3: Add compound signals section after summary table**
+
+After the summary table (after line 480), add:
+
+```python
+    # Compound signals section
+    if compound_signals:
+        from app.outputs.narrative import generate_compound_signals_text
+        triggered = [s for s in compound_signals if s.triggered]
+        if triggered:
+            story.append(Spacer(1, 4 * mm))
+            story.append(Paragraph("Compound Signals", styles["section_heading"]))
+            story.append(Spacer(1, 2 * mm))
+            for s in triggered:
+                signal_text = (
+                    f"<b>{s.name.replace('_', ' ').title()}</b> "
+                    f"({s.confidence}): {s.description}"
+                )
+                story.append(Paragraph(signal_text, styles["body"]))
+                story.append(Spacer(1, 2 * mm))
+        else:
+            story.append(Spacer(1, 2 * mm))
+            story.append(Paragraph(
+                "No compound signals detected across the indicator set.",
+                styles["body_muted"],
+            ))
+```
+
+- [ ] **Step 4: Add hotspot map to indicator blocks**
+
+In the `_indicator_block` function, add a `hotspot_path` parameter and render it alongside the existing map:
+
+Update the function signature at line 161:
+
+```python
+def _indicator_block(
+    result: IndicatorResult,
+    styles: dict,
+    map_path: str = "",
+    chart_path: str = "",
+    hotspot_path: str = "",
+) -> list:
+```
+
+After the existing map+chart side-by-side block (after line 208), add hotspot map rendering:
+
+```python
+    # Hotspot change map (if available)
+    hotspot_exists = hotspot_path and os.path.exists(hotspot_path)
+    if hotspot_exists:
+        from reportlab.platypus import Image as RLImage
+        hotspot_img = RLImage(hotspot_path, width=14 * cm, height=5.5 * cm)
+        hotspot_img.hAlign = "CENTER"
+        elements.append(hotspot_img)
+        elements.append(Spacer(1, 2 * mm))
+```
+
+- [ ] **Step 5: Update _indicator_block caller to pass hotspot_path**
+
+In the indicator deep-dive loop (line 488-499), update the call:
+
+```python
+    for result in results:
+        indicator_label = _indicator_label(result.indicator_id)
+        map_path = (indicator_map_paths or {}).get(result.indicator_id, "")
+        hotspot_path = (indicator_hotspot_paths or {}).get(result.indicator_id, "")
+
+        chart_path = os.path.join(output_dir, f"{result.indicator_id}_chart.png")
+        if not os.path.exists(chart_path):
+            chart_path = ""
+
+        block = [Paragraph(indicator_label, styles["section_heading"])]
+        block += _indicator_block(result, styles, map_path=map_path, chart_path=chart_path, hotspot_path=hotspot_path)
+        story.append(KeepTogether(block))
+```
+
+- [ ] **Step 6: Add confidence breakdown to Technical Annex (new subsection)**
+
+After the methodology subsection (after line 517), add:
+
+```python
+    # Confidence breakdown table
+    story.append(Paragraph("Confidence Breakdown", styles["section_heading"]))
+    story.append(Spacer(1, 2 * mm))
+
+    conf_header = [
+        Paragraph("<b>Indicator</b>", styles["body"]),
+        Paragraph("<b>Temporal</b>", styles["body"]),
+        Paragraph("<b>Obs. Density</b>", styles["body"]),
+        Paragraph("<b>Baseline Depth</b>", styles["body"]),
+        Paragraph("<b>Spatial Compl.</b>", styles["body"]),
+        Paragraph("<b>Overall</b>", styles["body"]),
+    ]
+    conf_rows = [conf_header]
+    for result in results:
+        f = result.confidence_factors
+        if f:
+            conf_rows.append([
+                Paragraph(_indicator_label(result.indicator_id), styles["body_muted"]),
+                Paragraph(f"{f.get('temporal', 0):.2f}", styles["body_muted"]),
+                Paragraph(f"{f.get('observation_density', 0):.2f}", styles["body_muted"]),
+                Paragraph(f"{f.get('baseline_depth', 0):.2f}", styles["body_muted"]),
+                Paragraph(f"{f.get('spatial_completeness', 0):.2f}", styles["body_muted"]),
+                Paragraph(result.confidence.value.capitalize(), styles["body_muted"]),
+            ])
+
+    if len(conf_rows) > 1:
+        conf_col_w = PAGE_W - 2 * MARGIN
+        conf_table = Table(
+            conf_rows,
+            colWidths=[conf_col_w * 0.18] + [conf_col_w * 0.164] * 5,
+        )
+        conf_table.setStyle(TableStyle([
+            ("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#E8E6E0")),
+            ("GRID", (0, 0), (-1, -1), 0.3, colors.HexColor("#D8D5CF")),
+            ("TOPPADDING", (0, 0), (-1, -1), 3),
+            ("BOTTOMPADDING", (0, 0), (-1, -1), 3),
+            ("LEFTPADDING", (0, 0), (-1, -1), 4),
+        ]))
+        story.append(conf_table)
+    story.append(Spacer(1, 4 * mm))
+```
+
+- [ ] **Step 6: Verify import**
+
+Run: `cd /Users/kmini/github/aperture && python -c "from app.outputs.report import generate_pdf_report; print('OK')"`
+Expected: `OK`
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add app/outputs/report.py
+git commit -m "feat: add compound signals section, anomaly column, confidence breakdown to PDF report"
+```
+
+---
+
+## Task 17: Update worker pipeline to generate hotspot maps and compound signals
+
+**Files:**
+- Modify: `app/worker.py:170-291`
+
+- [ ] **Step 1: Add hotspot map generation after indicator maps**
+
+In `app/worker.py`, after the map generation loop (after line 225), add hotspot map generation:
+
+```python
+        # Generate hotspot maps for indicators with z-score data
+        from app.outputs.maps import render_hotspot_map
+        indicator_hotspot_paths = {}
+        for result in job.results:
+            indicator_obj = registry.get(result.indicator_id)
+            zscore_raster = getattr(indicator_obj, '_zscore_raster', None)
+            hotspot_mask = getattr(indicator_obj, '_hotspot_mask', None)
+            true_color_path = getattr(indicator_obj, '_true_color_path', None)
+
+            if zscore_raster is not None and hotspot_mask is not None:
+                hotspot_path = os.path.join(results_dir, f"{result.indicator_id}_hotspot.png")
+
+                # Get extent from the indicator raster
+                raster_path = getattr(indicator_obj, '_indicator_raster_path', None)
+                if raster_path:
+                    import rasterio
+                    with rasterio.open(raster_path) as src:
+                        extent = [src.bounds.left, src.bounds.right, src.bounds.bottom, src.bounds.top]
+                else:
+                    b = job.request.aoi.bbox
+                    extent = [b[0], b[2], b[1], b[3]]
+
+                render_hotspot_map(
+                    true_color_path=true_color_path,
+                    zscore_raster=zscore_raster,
+                    hotspot_mask=hotspot_mask,
+                    extent=extent,
+                    aoi=job.request.aoi,
+                    status=result.status,
+                    output_path=hotspot_path,
+                    label=result.indicator_id.upper(),
+                )
+                indicator_hotspot_paths[result.indicator_id] = hotspot_path
+                output_files.append(hotspot_path)
+```
+
+- [ ] **Step 2: Add compound signal detection**
+
+After the hotspot map generation, add compound signal detection:
+
+```python
+        # Cross-indicator compound signal detection
+        from app.analysis.compound import detect_compound_signals
+        import numpy as np
+
+        zscore_rasters = {}
+        for result in job.results:
+            indicator_obj = registry.get(result.indicator_id)
+            z = getattr(indicator_obj, '_zscore_raster', None)
+            if z is not None:
+                zscore_rasters[result.indicator_id] = z
+
+        compound_signals = []
+        if len(zscore_rasters) >= 2:
+            # Resample all to common shape (use the smallest raster dimensions)
+            shapes = [z.shape for z in zscore_rasters.values()]
+            target_shape = min(shapes, key=lambda s: s[0] * s[1])
+
+            resampled = {}
+            for ind_id, z in zscore_rasters.items():
+                if z.shape != target_shape:
+                    from scipy.ndimage import zoom
+                    factors = (target_shape[0] / z.shape[0], target_shape[1] / z.shape[1])
+                    resampled[ind_id] = zoom(z, factors, order=0)  # nearest-neighbor
+                else:
+                    resampled[ind_id] = z
+
+            # Estimate pixel area in hectares
+            b = job.request.aoi.bbox
+            pixel_area_ha = (job.request.aoi.area_km2 * 100) / (target_shape[0] * target_shape[1])
+
+            compound_signals = detect_compound_signals(
+                zscore_rasters=resampled,
+                pixel_area_ha=pixel_area_ha,
+                threshold=2.0,
+            )
+
+        # Save compound signals as JSON
+        if compound_signals:
+            signals_path = os.path.join(results_dir, "compound_signals.json")
+            with open(signals_path, "w") as f:
+                json.dump([s.model_dump() for s in compound_signals], f, indent=2)
+            output_files.append(signals_path)
+```
+
+- [ ] **Step 3: Pass new data to PDF report generation**
+
+Update the `generate_pdf_report` call (lines 277-286) to include the new parameters:
+
+```python
+        generate_pdf_report(
+            aoi=job.request.aoi,
+            time_range=job.request.time_range,
+            results=job.results,
+            output_path=report_path,
+            summary_map_path=summary_map_path,
+            indicator_map_paths=indicator_map_paths,
+            indicator_hotspot_paths=indicator_hotspot_paths,
+            overview_score=overview_score,
+            overview_map_path=overview_map_path if true_color_path else "",
+            compound_signals=compound_signals,
+        )
+```
+
+- [ ] **Step 4: Verify import**
+
+Run: `cd /Users/kmini/github/aperture && python -c "from app.worker import process_job; print('OK')"`
+Expected: `OK`
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add app/worker.py
+git commit -m "feat: generate hotspot maps, detect compound signals, pass to PDF report"
+```
+
+---
+
+## Task 18: Run full test suite and fix any issues
+
+- [ ] **Step 1: Run all tests**
+
+Run: `cd /Users/kmini/github/aperture && python -m pytest tests/ -v`
+Expected: All tests PASS.
+
+- [ ] **Step 2: Verify all modules import cleanly**
+
+Run: `cd /Users/kmini/github/aperture && python -c "
+from app.models import IndicatorResult, CompoundSignal
+from app.config import NDVI_RESOLUTION_M, ZSCORE_THRESHOLD
+from app.analysis.seasonal import compute_seasonal_stats_aoi
+from app.analysis.change import compute_zscore_raster, detect_hotspots, cluster_hotspots
+from app.analysis.compound import detect_compound_signals
+from app.analysis.confidence import compute_confidence
+from app.indicators.ndvi import NdviIndicator
+from app.indicators.water import WaterIndicator
+from app.indicators.sar import SarIndicator
+from app.indicators.buildup import BuiltupIndicator
+from app.outputs.charts import render_timeseries_chart
+from app.outputs.maps import render_hotspot_map
+from app.outputs.narrative import generate_compound_signals_text
+from app.outputs.report import generate_pdf_report
+print('All imports OK')
+"`
+Expected: `All imports OK`
+
+- [ ] **Step 3: Fix any failures found in steps 1-2**
+
+- [ ] **Step 4: Commit any fixes**
+
+```bash
+git add -A
+git commit -m "fix: resolve import/test issues from EO product overhaul"
+```
+
+---
+
+## Task 19: Review checkpoint
+
+This is the review gate before considering the work complete.
+
+- [ ] **Step 1: Verify spec coverage**
+
+Cross-reference each section of the spec (`docs/superpowers/specs/2026-04-06-eo-product-overhaul-design.md`) against the implemented code:
+
+| Spec Section | Implemented In |
+|---|---|
+| 1. Resolution upgrade | `openeo_client.py`, `config.py` |
+| 2. Seasonal baselines | `analysis/seasonal.py`, indicator harvest methods |
+| 3. Pixel-level change | `analysis/change.py`, indicator harvest methods |
+| 4. Cross-indicator correlation | `analysis/compound.py`, `worker.py` |
+| 5. Confidence model | `analysis/confidence.py`, indicator harvest methods |
+| 6. Report improvements | `charts.py`, `maps.py`, `narrative.py`, `report.py` |
+| 7. Status classification | Indicator `_classify_zscore` methods |
+| 8. Data model changes | `models.py` |
+
+- [ ] **Step 2: Run tests one final time**
+
+Run: `cd /Users/kmini/github/aperture && python -m pytest tests/ -v --tb=short`
+Expected: All tests PASS.