docs: add Phase B implementation plan — migrate 4 indicators

Water (MNDWI via openEO), LST (Sentinel-3 SLSTR via openEO),
Rainfall (CHIRPS direct download), Nightlights (VIIRS EOG direct
download). 7 tasks with full TDD code.

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>

docs/superpowers/plans/2026-03-31-phase-b-migrate-indicators.md

@@ -0,0 +1,2007 @@
+# Phase B: Migrate Remaining Indicators to openEO / Direct Download — 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:** Migrate water, LST, rainfall, and nightlights indicators from scene-level metadata / centroid queries to pixel-level raster products — water and LST via CDSE openEO, rainfall via CHIRPS direct download, nightlights via VIIRS EOG direct download.
+
+**Architecture:** openEO indicators (water, LST) follow the NDVI pattern from Phase A: build processing graph → download GeoTIFF → compute stats → classify. Direct download indicators (rainfall, nightlights) use `httpx` to fetch GeoTIFFs from public archives, then follow the same post-processing pipeline. All indicators set `SpatialData(map_type="raster")` with indicator-specific `vmin`/`vmax` stored on the SpatialData dataclass.
+
+**Tech Stack:** Python 3.11, openeo, rasterio, httpx, numpy, matplotlib
+
+**Spec:** `docs/superpowers/specs/2026-03-31-openeo-eo-upgrade-design.md`
+
+---
+
+## File Map
+
+| File | Action | Responsibility |
+|------|--------|----------------|
+| `app/indicators/base.py` | Modify | Add `vmin`/`vmax` fields to `SpatialData` |
+| `app/worker.py` | Modify | Read `vmin`/`vmax` from SpatialData instead of hardcoding |
+| `app/openeo_client.py` | Modify | Add `build_mndwi_graph()` and `build_lst_graph()` |
+| `app/indicators/water.py` | Rewrite | MNDWI pixel-level water classification via openEO |
+| `app/indicators/lst.py` | Rewrite | Sentinel-3 SLSTR LST via openEO |
+| `app/indicators/rainfall.py` | Rewrite | CHIRPS precipitation via direct download |
+| `app/indicators/nightlights.py` | Rewrite | VIIRS DNB monthly via EOG direct download |
+| `tests/test_openeo_client.py` | Modify | Add tests for new graph builders |
+| `tests/test_indicator_water.py` | Rewrite | Tests for openEO-based water indicator |
+| `tests/test_indicator_lst.py` | Rewrite | Tests for openEO-based LST indicator |
+| `tests/test_indicator_rainfall.py` | Rewrite | Tests for CHIRPS-based rainfall |
+| `tests/test_indicator_nightlights.py` | Rewrite | Tests for VIIRS-based nightlights |
+
+---
+
+### Task 1: Generalize Raster Map vmin/vmax in SpatialData and Worker
+
+**Files:**
+- Modify: `app/indicators/base.py:13-22`
+- Modify: `app/worker.py:95-113`
+- Modify: `app/indicators/ndvi.py` (set vmin/vmax on SpatialData)
+
+- [ ] **Step 1: Add vmin/vmax fields to SpatialData**
+
+In `app/indicators/base.py`, replace the `SpatialData` dataclass (lines 13-22):
+
+```python
+@dataclass
+class SpatialData:
+    """Spatial data produced by an indicator for map rendering."""
+    data: np.ndarray | None = None
+    lons: np.ndarray | None = None
+    lats: np.ndarray | None = None
+    label: str = ""
+    colormap: str = "RdYlGn"
+    geojson: dict | None = None
+    map_type: str = "grid"
+    vmin: float | None = None
+    vmax: float | None = None
+```
+
+- [ ] **Step 2: Update NDVI indicator to set vmin/vmax on SpatialData**
+
+In `app/indicators/ndvi.py`, find the line where `self._spatial_data` is assigned (in `_process_openeo`). Replace:
+
+```python
+        self._spatial_data = SpatialData(
+            map_type="raster",
+            label="NDVI",
+            colormap="RdYlGn",
+        )
+```
+
+With:
+
+```python
+        self._spatial_data = SpatialData(
+            map_type="raster",
+            label="NDVI",
+            colormap="RdYlGn",
+            vmin=-0.2,
+            vmax=0.9,
+        )
+```
+
+- [ ] **Step 3: Update worker to read vmin/vmax from SpatialData**
+
+In `app/worker.py`, replace lines 95-113 (the raster map rendering block):
+
+```python
+            if spatial is not None and spatial.map_type == "raster":
+                # Raster-on-true-color rendering for openEO/download indicators
+                indicator_obj = registry.get(result.indicator_id)
+                raster_path = getattr(indicator_obj, '_indicator_raster_path', None)
+                true_color_path = getattr(indicator_obj, '_true_color_path', None)
+                render_band = getattr(indicator_obj, '_render_band', 1)
+                from app.outputs.maps import render_raster_map
+                render_raster_map(
+                    true_color_path=true_color_path,
+                    indicator_path=raster_path,
+                    indicator_band=render_band,
+                    aoi=job.request.aoi,
+                    status=result.status,
+                    output_path=map_path,
+                    cmap=spatial.colormap,
+                    vmin=spatial.vmin,
+                    vmax=spatial.vmax,
+                    label=spatial.label,
+                )
+```
+
+Note: renamed `_ndvi_peak_band` to generic `_render_band` in the worker. Update NDVI indicator to match:
+
+In `app/indicators/ndvi.py`, find `self._ndvi_peak_band = current_stats["peak_month_band"]` and add after it:
+
+```python
+        self._render_band = current_stats["peak_month_band"]
+```
+
+- [ ] **Step 4: Run all tests**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/ -v --timeout=120 2>&1 | tail -10`
+
+Expected: All 136 tests PASS (the worker test and NDVI tests should still work since `_ndvi_peak_band` still exists alongside `_render_band`).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add app/indicators/base.py app/worker.py app/indicators/ndvi.py
+git commit -m "refactor: generalize raster map vmin/vmax via SpatialData fields
+
+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>"
+```
+
+---
+
+### Task 2: Add MNDWI and LST Graph Builders to openEO Client
+
+**Files:**
+- Modify: `app/openeo_client.py`
+- Modify: `tests/test_openeo_client.py`
+
+- [ ] **Step 1: Write tests for new graph builders**
+
+Append to `tests/test_openeo_client.py`:
+
+```python
+def test_build_mndwi_graph():
+    """build_mndwi_graph() loads Sentinel-2 with water index bands."""
+    mock_conn = MagicMock()
+    mock_cube = MagicMock()
+    mock_conn.load_collection.return_value = mock_cube
+
+    from app.openeo_client import build_mndwi_graph
+
+    bbox = {"west": 32.45, "south": 15.65, "east": 32.65, "north": 15.8}
+    result = build_mndwi_graph(
+        conn=mock_conn,
+        bbox=bbox,
+        temporal_extent=["2025-03-01", "2026-03-01"],
+        resolution_m=100,
+    )
+
+    mock_conn.load_collection.assert_called_once()
+    call_kwargs = mock_conn.load_collection.call_args
+    assert call_kwargs[1]["collection_id"] == "SENTINEL2_L2A"
+    assert "B03" in call_kwargs[1]["bands"]
+    assert "B11" in call_kwargs[1]["bands"]
+    assert "SCL" in call_kwargs[1]["bands"]
+
+
+def test_build_lst_graph():
+    """build_lst_graph() loads Sentinel-3 SLSTR LST data."""
+    mock_conn = MagicMock()
+    mock_cube = MagicMock()
+    mock_conn.load_collection.return_value = mock_cube
+
+    from app.openeo_client import build_lst_graph
+
+    bbox = {"west": 32.45, "south": 15.65, "east": 32.65, "north": 15.8}
+    result = build_lst_graph(
+        conn=mock_conn,
+        bbox=bbox,
+        temporal_extent=["2025-03-01", "2026-03-01"],
+        resolution_m=1000,
+    )
+
+    mock_conn.load_collection.assert_called_once()
+    call_kwargs = mock_conn.load_collection.call_args
+    # Should load Sentinel-3 SLSTR
+    assert "SENTINEL3" in call_kwargs[1]["collection_id"].upper() or "SLSTR" in call_kwargs[1]["collection_id"].upper()
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_openeo_client.py::test_build_mndwi_graph tests/test_openeo_client.py::test_build_lst_graph -v`
+
+Expected: FAIL — `ImportError`
+
+- [ ] **Step 3: Implement graph builders**
+
+Append to `app/openeo_client.py` after the `build_true_color_graph` function:
+
+```python
+
+
+def build_mndwi_graph(
+    *,
+    conn: openeo.Connection,
+    bbox: dict[str, float],
+    temporal_extent: list[str],
+    resolution_m: int = 100,
+) -> openeo.DataCube:
+    """Build an openEO process graph for monthly MNDWI water index composites.
+
+    MNDWI = (B03 - B11) / (B03 + B11). Positive values indicate water.
+    Cloud-masked via SCL band, aggregated to monthly medians.
+    """
+    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)
+
+    b03 = cube.band("B03")
+    b11 = cube.band("B11")
+    mndwi = (b03 - b11) / (b03 + b11)
+
+    monthly = mndwi.aggregate_temporal_period("month", reducer="median")
+
+    if resolution_m > 10:
+        monthly = monthly.resample_spatial(resolution=resolution_m / 111320)
+
+    return monthly
+
+
+def build_lst_graph(
+    *,
+    conn: openeo.Connection,
+    bbox: dict[str, float],
+    temporal_extent: list[str],
+    resolution_m: int = 1000,
+) -> openeo.DataCube:
+    """Build an openEO process graph for Sentinel-3 SLSTR land surface temperature.
+
+    Loads LST from Sentinel-3 SLSTR Level-2 product, aggregated to monthly means.
+    Resolution is typically 1km (SLSTR native).
+    """
+    cube = conn.load_collection(
+        collection_id="SENTINEL3_SLSTR_L2_LST",
+        spatial_extent=bbox,
+        temporal_extent=temporal_extent,
+        bands=["LST"],
+    )
+
+    monthly = cube.aggregate_temporal_period("month", reducer="mean")
+
+    if resolution_m > 1000:
+        monthly = monthly.resample_spatial(resolution=resolution_m / 111320)
+
+    return monthly
+```
+
+- [ ] **Step 4: Run tests**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_openeo_client.py -v`
+
+Expected: All PASS (6 tests now).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add app/openeo_client.py tests/test_openeo_client.py
+git commit -m "feat: add MNDWI and LST graph builders to openEO client
+
+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>"
+```
+
+---
+
+### Task 3: Rewrite Water Indicator (MNDWI via openEO)
+
+**Files:**
+- Rewrite: `app/indicators/water.py`
+- Rewrite: `tests/test_indicator_water.py`
+
+- [ ] **Step 1: Write tests for openEO-based water indicator**
+
+Replace `tests/test_indicator_water.py` entirely:
+
+```python
+"""Tests for app.indicators.water — pixel-level MNDWI via openEO."""
+from __future__ import annotations
+
+import os
+import tempfile
+from unittest.mock import MagicMock, patch
+from datetime import date
+
+import numpy as np
+import rasterio
+from rasterio.transform import from_bounds
+import pytest
+
+from app.models import AOI, TimeRange, StatusLevel, TrendDirection, ConfidenceLevel
+
+BBOX = [32.45, 15.65, 32.65, 15.8]
+
+
+@pytest.fixture
+def test_aoi():
+    return AOI(name="Test", bbox=BBOX)
+
+
+@pytest.fixture
+def test_time_range():
+    return TimeRange(start=date(2025, 3, 1), end=date(2026, 3, 1))
+
+
+def _mock_mndwi_tif(path: str, n_months: int = 12, water_fraction: float = 0.15):
+    """Create synthetic MNDWI GeoTIFF. Values > 0 are water."""
+    rng = np.random.default_rng(44)
+    data = np.zeros((n_months, 10, 10), dtype=np.float32)
+    for m in range(n_months):
+        vals = rng.normal(-0.2, 0.3, (10, 10))
+        # Set some pixels as water (positive MNDWI)
+        water_mask = rng.random((10, 10)) < water_fraction
+        vals[water_mask] = rng.uniform(0.1, 0.6, water_mask.sum())
+        data[m] = vals
+    with rasterio.open(
+        path, "w", driver="GTiff", height=10, width=10, count=n_months,
+        dtype="float32", crs="EPSG:4326",
+        transform=from_bounds(*BBOX, 10, 10), nodata=-9999.0,
+    ) as dst:
+        for i in range(n_months):
+            dst.write(data[i], i + 1)
+
+
+def _mock_rgb_tif(path: str):
+    rng = np.random.default_rng(43)
+    data = rng.integers(500, 1500, (3, 10, 10), dtype=np.uint16)
+    with rasterio.open(
+        path, "w", driver="GTiff", height=10, width=10, count=3,
+        dtype="uint16", crs="EPSG:4326",
+        transform=from_bounds(*BBOX, 10, 10), nodata=0,
+    ) as dst:
+        for i in range(3):
+            dst.write(data[i], i + 1)
+
+
+@pytest.mark.asyncio
+async def test_water_process_returns_result(test_aoi, test_time_range):
+    """WaterIndicator.process() returns a valid IndicatorResult."""
+    from app.indicators.water import WaterIndicator
+
+    indicator = WaterIndicator()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        mndwi_path = os.path.join(tmpdir, "mndwi.tif")
+        rgb_path = os.path.join(tmpdir, "rgb.tif")
+        _mock_mndwi_tif(mndwi_path)
+        _mock_rgb_tif(rgb_path)
+
+        mock_cube = MagicMock()
+
+        def fake_download(path, **kwargs):
+            import shutil
+            if "mndwi" in path or "water" in path:
+                shutil.copy(mndwi_path, path)
+            else:
+                shutil.copy(rgb_path, path)
+
+        mock_cube.download = MagicMock(side_effect=fake_download)
+
+        with patch("app.indicators.water.get_connection"), \
+             patch("app.indicators.water.build_mndwi_graph", return_value=mock_cube), \
+             patch("app.indicators.water.build_true_color_graph", return_value=mock_cube):
+            result = await indicator.process(test_aoi, test_time_range)
+
+    assert result.indicator_id == "water"
+    assert result.status in (StatusLevel.GREEN, StatusLevel.AMBER, StatusLevel.RED)
+    assert "MNDWI" in result.methodology or "water" in result.methodology.lower()
+    assert result.data_source == "satellite"
+    assert len(result.chart_data.get("dates", [])) > 0
+
+
+@pytest.mark.asyncio
+async def test_water_falls_back_on_failure(test_aoi, test_time_range):
+    """WaterIndicator falls back gracefully when openEO fails."""
+    from app.indicators.water import WaterIndicator
+
+    indicator = WaterIndicator()
+
+    with patch("app.indicators.water.get_connection", side_effect=Exception("CDSE down")):
+        result = await indicator.process(test_aoi, test_time_range)
+
+    assert result.indicator_id == "water"
+    assert result.data_source == "placeholder"
+
+
+def test_water_compute_stats():
+    """_compute_stats() extracts water fraction from MNDWI raster."""
+    from app.indicators.water import WaterIndicator
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        path = os.path.join(tmpdir, "mndwi.tif")
+        _mock_mndwi_tif(path, n_months=12, water_fraction=0.2)
+        stats = WaterIndicator._compute_stats(path)
+
+    assert "monthly_water_fractions" in stats
+    assert len(stats["monthly_water_fractions"]) == 12
+    assert "overall_water_fraction" in stats
+    assert 0 < stats["overall_water_fraction"] < 1
+    assert "valid_months" in stats
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_indicator_water.py -v`
+
+Expected: FAIL — the old WaterIndicator doesn't have `_compute_stats` or the new import pattern.
+
+- [ ] **Step 3: Rewrite water indicator**
+
+Replace `app/indicators/water.py` entirely:
+
+```python
+"""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 3-year baseline.
+"""
+from __future__ import annotations
+
+import logging
+import os
+import tempfile
+from datetime import date
+from typing import Any
+
+import numpy as np
+import rasterio
+
+from app.config import RESOLUTION_M
+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
+
+logger = logging.getLogger(__name__)
+
+BASELINE_YEARS = 3
+WATER_THRESHOLD = 0.0  # MNDWI > 0 = water
+
+
+class WaterIndicator(BaseIndicator):
+    id = "water"
+    name = "Water Bodies"
+    category = "D9"
+    question = "Are rivers and lakes stable?"
+    estimated_minutes = 8
+
+    _true_color_path: str | None = None
+
+    async def process(
+        self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None
+    ) -> IndicatorResult:
+        try:
+            return await self._process_openeo(aoi, time_range, season_months)
+        except Exception as exc:
+            logger.warning("Water openEO processing failed, using placeholder: %s", exc)
+            return self._fallback(aoi, time_range)
+
+    async def _process_openeo(
+        self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None
+    ) -> IndicatorResult:
+        import asyncio
+
+        conn = get_connection()
+        bbox = _bbox_dict(aoi.bbox)
+
+        current_start = time_range.start.isoformat()
+        current_end = time_range.end.isoformat()
+        baseline_start = date(
+            time_range.start.year - BASELINE_YEARS,
+            time_range.start.month,
+            time_range.start.day,
+        ).isoformat()
+        baseline_end = time_range.start.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,
+        )
+        baseline_cube = build_mndwi_graph(
+            conn=conn, bbox=bbox,
+            temporal_extent=[baseline_start, baseline_end],
+            resolution_m=RESOLUTION_M,
+        )
+        true_color_cube = build_true_color_graph(
+            conn=conn, bbox=bbox,
+            temporal_extent=[current_start, current_end],
+            resolution_m=RESOLUTION_M,
+        )
+
+        loop = asyncio.get_event_loop()
+        current_path = os.path.join(results_dir, "mndwi_current.tif")
+        baseline_path = os.path.join(results_dir, "mndwi_baseline.tif")
+        true_color_path = os.path.join(results_dir, "true_color.tif")
+
+        await loop.run_in_executor(None, current_cube.download, current_path)
+        await loop.run_in_executor(None, baseline_cube.download, baseline_path)
+        await loop.run_in_executor(None, true_color_cube.download, true_color_path)
+
+        self._true_color_path = true_color_path
+
+        current_stats = self._compute_stats(current_path)
+        baseline_stats = self._compute_stats(baseline_path)
+
+        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
+        )
+
+        chart_data = self._build_chart_data(
+            current_stats["monthly_water_fractions"],
+            baseline_stats["monthly_water_fractions"],
+            time_range,
+        )
+
+        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)"
+        else:
+            headline = f"Water extent {direction} ({change_pp:+.1f}pp vs baseline)"
+
+        self._spatial_data = SpatialData(
+            map_type="raster",
+            label="MNDWI",
+            colormap="Blues",
+            vmin=-0.5,
+            vmax=0.5,
+        )
+        self._indicator_raster_path = current_path
+        self._true_color_path = true_color_path
+        self._render_band = current_stats["peak_water_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",
+            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."
+            ),
+            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."
+            ),
+            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.",
+            ],
+        )
+
+    @staticmethod
+    def _compute_stats(tif_path: str) -> dict[str, Any]:
+        """Extract monthly water fraction statistics from MNDWI GeoTIFF."""
+        with rasterio.open(tif_path) as src:
+            n_bands = src.count
+            monthly_fractions = []
+            peak_frac = -1.0
+            peak_band = 1
+            for band in range(1, n_bands + 1):
+                data = src.read(band).astype(np.float32)
+                nodata = src.nodata
+                if nodata is not None:
+                    valid = data[data != nodata]
+                else:
+                    valid = data.ravel()
+                if len(valid) > 0:
+                    water_pixels = np.sum(valid > WATER_THRESHOLD)
+                    frac = float(water_pixels / len(valid))
+                    monthly_fractions.append(frac)
+                    if frac > peak_frac:
+                        peak_frac = frac
+                        peak_band = band
+                else:
+                    monthly_fractions.append(0.0)
+
+        valid_months = sum(1 for f in monthly_fractions if f > 0)
+        overall = float(np.mean(monthly_fractions)) if monthly_fractions else 0.0
+
+        return {
+            "monthly_water_fractions": monthly_fractions,
+            "overall_water_fraction": overall,
+            "valid_months": max(valid_months, len(monthly_fractions)),
+            "peak_water_band": peak_band,
+        }
+
+    @staticmethod
+    def _classify(change_pp: float) -> StatusLevel:
+        if change_pp <= 10:
+            return StatusLevel.GREEN
+        if change_pp <= 25:
+            return StatusLevel.AMBER
+        return StatusLevel.RED
+
+    @staticmethod
+    def _compute_trend(change_pp: float) -> TrendDirection:
+        if abs(change_pp) <= 5:
+            return TrendDirection.STABLE
+        if change_pp > 0:
+            return TrendDirection.DETERIORATING  # flooding
+        return TrendDirection.DETERIORATING  # drought
+
+    @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 * 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]]
+
+        return {
+            "dates": dates,
+            "values": values,
+            "baseline_mean": b_mean,
+            "baseline_min": b_min,
+            "baseline_max": b_max,
+            "label": "Water extent (%)",
+        }
+
+    def _fallback(self, aoi: AOI, time_range: TimeRange) -> IndicatorResult:
+        rng = np.random.default_rng(9)
+        baseline = float(rng.uniform(5, 20))
+        current = baseline * float(rng.uniform(0.85, 1.15))
+        change = current - baseline
+
+        return IndicatorResult(
+            indicator_id=self.id,
+            headline=f"Water data degraded ({current:.1f}% extent)",
+            status=StatusLevel.GREEN if abs(change) < 5 else StatusLevel.AMBER,
+            trend=TrendDirection.STABLE,
+            confidence=ConfidenceLevel.LOW,
+            map_layer_path="",
+            chart_data={
+                "dates": [str(time_range.start.year), str(time_range.end.year)],
+                "values": [round(baseline, 1), round(current, 1)],
+                "label": "Water extent (%)",
+            },
+            data_source="placeholder",
+            summary="openEO processing unavailable. Showing placeholder values.",
+            methodology="Placeholder \u2014 no satellite data processed.",
+            limitations=["Data is synthetic. openEO backend was unreachable."],
+        )
+```
+
+- [ ] **Step 4: Run tests**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_indicator_water.py -v`
+
+Expected: All PASS.
+
+- [ ] **Step 5: Run full suite**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/ --timeout=120 2>&1 | tail -5`
+
+Expected: All tests PASS.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add app/indicators/water.py tests/test_indicator_water.py
+git commit -m "feat: rewrite water indicator with pixel-level MNDWI via openEO
+
+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>"
+```
+
+---
+
+### Task 4: Rewrite LST Indicator (Sentinel-3 SLSTR via openEO)
+
+**Files:**
+- Rewrite: `app/indicators/lst.py`
+- Rewrite: `tests/test_indicator_lst.py`
+
+- [ ] **Step 1: Write tests for openEO-based LST indicator**
+
+Replace `tests/test_indicator_lst.py` entirely:
+
+```python
+"""Tests for app.indicators.lst — Sentinel-3 SLSTR LST via openEO."""
+from __future__ import annotations
+
+import os
+import tempfile
+from unittest.mock import MagicMock, patch
+from datetime import date
+
+import numpy as np
+import rasterio
+from rasterio.transform import from_bounds
+import pytest
+
+from app.models import AOI, TimeRange, StatusLevel, ConfidenceLevel
+
+BBOX = [32.45, 15.65, 32.65, 15.8]
+
+
+@pytest.fixture
+def test_aoi():
+    return AOI(name="Test", bbox=BBOX)
+
+
+@pytest.fixture
+def test_time_range():
+    return TimeRange(start=date(2025, 3, 1), end=date(2026, 3, 1))
+
+
+def _mock_lst_tif(path: str, n_months: int = 12, mean_k: float = 310.0):
+    """Create synthetic LST GeoTIFF in Kelvin."""
+    rng = np.random.default_rng(45)
+    data = np.zeros((n_months, 10, 10), dtype=np.float32)
+    for m in range(n_months):
+        seasonal = 5.0 * np.sin(np.pi * (m - 1) / 6)
+        data[m] = mean_k + seasonal + rng.normal(0, 2, (10, 10))
+    with rasterio.open(
+        path, "w", driver="GTiff", height=10, width=10, count=n_months,
+        dtype="float32", crs="EPSG:4326",
+        transform=from_bounds(*BBOX, 10, 10), nodata=-9999.0,
+    ) as dst:
+        for i in range(n_months):
+            dst.write(data[i], i + 1)
+
+
+def _mock_rgb_tif(path: str):
+    rng = np.random.default_rng(43)
+    data = rng.integers(500, 1500, (3, 10, 10), dtype=np.uint16)
+    with rasterio.open(
+        path, "w", driver="GTiff", height=10, width=10, count=3,
+        dtype="uint16", crs="EPSG:4326",
+        transform=from_bounds(*BBOX, 10, 10), nodata=0,
+    ) as dst:
+        for i in range(3):
+            dst.write(data[i], i + 1)
+
+
+@pytest.mark.asyncio
+async def test_lst_process_returns_result(test_aoi, test_time_range):
+    from app.indicators.lst import LSTIndicator
+
+    indicator = LSTIndicator()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        lst_path = os.path.join(tmpdir, "lst.tif")
+        rgb_path = os.path.join(tmpdir, "rgb.tif")
+        _mock_lst_tif(lst_path)
+        _mock_lst_tif(os.path.join(tmpdir, "lst_baseline.tif"), mean_k=308.0)
+        _mock_rgb_tif(rgb_path)
+
+        mock_cube = MagicMock()
+
+        def fake_download(path, **kwargs):
+            import shutil
+            if "lst" in path and "baseline" not in path:
+                shutil.copy(lst_path, path)
+            elif "lst" in path:
+                shutil.copy(os.path.join(tmpdir, "lst_baseline.tif"), path)
+            else:
+                shutil.copy(rgb_path, path)
+
+        mock_cube.download = MagicMock(side_effect=fake_download)
+
+        with patch("app.indicators.lst.get_connection"), \
+             patch("app.indicators.lst.build_lst_graph", return_value=mock_cube), \
+             patch("app.indicators.lst.build_true_color_graph", return_value=mock_cube):
+            result = await indicator.process(test_aoi, test_time_range)
+
+    assert result.indicator_id == "lst"
+    assert result.data_source == "satellite"
+    assert len(result.chart_data.get("dates", [])) > 0
+
+
+@pytest.mark.asyncio
+async def test_lst_falls_back_on_failure(test_aoi, test_time_range):
+    from app.indicators.lst import LSTIndicator
+    indicator = LSTIndicator()
+
+    with patch("app.indicators.lst.get_connection", side_effect=Exception("CDSE down")):
+        result = await indicator.process(test_aoi, test_time_range)
+
+    assert result.indicator_id == "lst"
+    assert result.data_source == "placeholder"
+
+
+def test_lst_compute_stats():
+    from app.indicators.lst import LSTIndicator
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        path = os.path.join(tmpdir, "lst.tif")
+        _mock_lst_tif(path, mean_k=310.0)
+        stats = LSTIndicator._compute_stats(path)
+
+    assert "monthly_means_celsius" in stats
+    assert len(stats["monthly_means_celsius"]) == 12
+    assert "overall_mean_celsius" in stats
+    assert 30 < stats["overall_mean_celsius"] < 45  # ~310K = ~37°C
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_indicator_lst.py -v`
+
+Expected: FAIL — old LSTIndicator doesn't match new interface.
+
+- [ ] **Step 3: Rewrite LST indicator**
+
+Replace `app/indicators/lst.py` entirely:
+
+```python
+"""Land Surface Temperature Indicator — Sentinel-3 SLSTR via CDSE openEO.
+
+Retrieves monthly mean LST from Sentinel-3 SLSTR, compares to 5-year
+baseline, and classifies using Z-score anomaly thresholds.
+"""
+from __future__ import annotations
+
+import logging
+import os
+import tempfile
+from datetime import date
+from typing import Any
+
+import numpy as np
+import rasterio
+
+from app.config import RESOLUTION_M
+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_lst_graph, build_true_color_graph, _bbox_dict
+
+logger = logging.getLogger(__name__)
+
+BASELINE_YEARS = 5
+
+
+class LSTIndicator(BaseIndicator):
+    id = "lst"
+    name = "Land Surface Temperature"
+    category = "D6"
+    question = "Unusual heat patterns?"
+    estimated_minutes = 8
+
+    _true_color_path: str | None = None
+
+    async def process(
+        self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None
+    ) -> IndicatorResult:
+        try:
+            return await self._process_openeo(aoi, time_range, season_months)
+        except Exception as exc:
+            logger.warning("LST openEO processing failed, using placeholder: %s", exc)
+            return self._fallback(aoi, time_range)
+
+    async def _process_openeo(
+        self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None
+    ) -> IndicatorResult:
+        import asyncio
+
+        conn = get_connection()
+        bbox = _bbox_dict(aoi.bbox)
+
+        current_start = time_range.start.isoformat()
+        current_end = time_range.end.isoformat()
+        baseline_start = date(
+            time_range.start.year - BASELINE_YEARS,
+            time_range.start.month,
+            time_range.start.day,
+        ).isoformat()
+        baseline_end = time_range.start.isoformat()
+
+        results_dir = tempfile.mkdtemp(prefix="aperture_lst_")
+
+        # LST at 1km (SLSTR native)
+        lst_resolution = max(RESOLUTION_M, 1000)
+
+        current_cube = build_lst_graph(
+            conn=conn, bbox=bbox,
+            temporal_extent=[current_start, current_end],
+            resolution_m=lst_resolution,
+        )
+        baseline_cube = build_lst_graph(
+            conn=conn, bbox=bbox,
+            temporal_extent=[baseline_start, baseline_end],
+            resolution_m=lst_resolution,
+        )
+        true_color_cube = build_true_color_graph(
+            conn=conn, bbox=bbox,
+            temporal_extent=[current_start, current_end],
+            resolution_m=RESOLUTION_M,
+        )
+
+        loop = asyncio.get_event_loop()
+        current_path = os.path.join(results_dir, "lst_current.tif")
+        baseline_path = os.path.join(results_dir, "lst_baseline.tif")
+        true_color_path = os.path.join(results_dir, "true_color.tif")
+
+        await loop.run_in_executor(None, current_cube.download, current_path)
+        await loop.run_in_executor(None, baseline_cube.download, baseline_path)
+        await loop.run_in_executor(None, true_color_cube.download, true_color_path)
+
+        self._true_color_path = true_color_path
+
+        current_stats = self._compute_stats(current_path)
+        baseline_stats = self._compute_stats(baseline_path)
+
+        current_temp = current_stats["overall_mean_celsius"]
+        baseline_temp = baseline_stats["overall_mean_celsius"]
+        baseline_std = float(np.std(baseline_stats["monthly_means_celsius"])) if baseline_stats["monthly_means_celsius"] else 1.0
+        z_score = (current_temp - baseline_temp) / max(baseline_std, 0.1)
+
+        status = self._classify(abs(z_score))
+        trend = self._compute_trend(z_score)
+        confidence = (
+            ConfidenceLevel.HIGH if current_stats["valid_months"] >= 6
+            else ConfidenceLevel.MODERATE if current_stats["valid_months"] >= 3
+            else ConfidenceLevel.LOW
+        )
+
+        chart_data = self._build_chart_data(
+            current_stats["monthly_means_celsius"],
+            baseline_stats["monthly_means_celsius"],
+            time_range,
+        )
+
+        anomaly = current_temp - baseline_temp
+        if abs(z_score) < 1.0:
+            headline = f"Temperature normal ({current_temp:.1f}\u00b0C, z={z_score:+.1f})"
+        elif z_score > 0:
+            headline = f"Above-normal temperature ({current_temp:.1f}\u00b0C, +{anomaly:.1f}\u00b0C)"
+        else:
+            headline = f"Below-normal temperature ({current_temp:.1f}\u00b0C, {anomaly:.1f}\u00b0C)"
+
+        self._spatial_data = SpatialData(
+            map_type="raster",
+            label="LST (\u00b0C)",
+            colormap="coolwarm",
+            vmin=current_temp - 10,
+            vmax=current_temp + 10,
+        )
+        self._indicator_raster_path = current_path
+        self._true_color_path = true_color_path
+        self._render_band = current_stats.get("hottest_band", 1)
+
+        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",
+            summary=(
+                f"Mean LST is {current_temp:.1f}\u00b0C compared to "
+                f"{baseline_temp:.1f}\u00b0C baseline (z-score: {z_score:+.2f}). "
+                f"Sentinel-3 SLSTR at 1km resolution."
+            ),
+            methodology=(
+                f"Sentinel-3 SLSTR Level-2 LST product. "
+                f"Monthly mean composites. "
+                f"Baseline: {BASELINE_YEARS}-year monthly means. "
+                f"Z-score anomaly classification. "
+                f"Processed via CDSE openEO."
+            ),
+            limitations=[
+                "Sentinel-3 SLSTR resolution is ~1km \u2014 urban heat islands may be smoothed.",
+                "Cloud cover creates data gaps in monthly composites.",
+                "LST varies with land cover; change may reflect land use, not climate.",
+                "Daytime overpass only \u2014 nighttime temperatures not captured.",
+            ],
+        )
+
+    @staticmethod
+    def _compute_stats(tif_path: str) -> dict[str, Any]:
+        """Extract monthly LST statistics, converting Kelvin to Celsius."""
+        with rasterio.open(tif_path) as src:
+            n_bands = src.count
+            monthly_means_c = []
+            hottest = -999.0
+            hottest_band = 1
+            for band in range(1, n_bands + 1):
+                data = src.read(band).astype(np.float32)
+                nodata = src.nodata
+                if nodata is not None:
+                    valid = data[data != nodata]
+                else:
+                    valid = data.ravel()
+                if len(valid) > 0:
+                    mean_k = float(np.nanmean(valid))
+                    # Convert Kelvin to Celsius if needed (values > 100 assumed Kelvin)
+                    mean_c = mean_k - 273.15 if mean_k > 100 else mean_k
+                    monthly_means_c.append(mean_c)
+                    if mean_c > hottest:
+                        hottest = mean_c
+                        hottest_band = band
+                else:
+                    monthly_means_c.append(0.0)
+
+        valid_months = sum(1 for m in monthly_means_c if m != 0.0)
+        overall = float(np.mean([m for m in monthly_means_c if m != 0.0])) if valid_months > 0 else 0.0
+
+        return {
+            "monthly_means_celsius": monthly_means_c,
+            "overall_mean_celsius": overall,
+            "valid_months": valid_months,
+            "hottest_band": hottest_band,
+        }
+
+    @staticmethod
+    def _classify(abs_z: float) -> StatusLevel:
+        if abs_z < 1.0:
+            return StatusLevel.GREEN
+        if abs_z < 2.0:
+            return StatusLevel.AMBER
+        return StatusLevel.RED
+
+    @staticmethod
+    def _compute_trend(z_score: float) -> TrendDirection:
+        if abs(z_score) < 1.0:
+            return TrendDirection.STABLE
+        if z_score > 0:
+            return TrendDirection.DETERIORATING
+        return TrendDirection.IMPROVING
+
+    @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, 1) for v in current_monthly[:n]]
+        b_mean = [round(v, 1) for v in baseline_monthly[:n]]
+        b_min = [round(v - 3.0, 1) for v in baseline_monthly[:n]]
+        b_max = [round(v + 3.0, 1) for v in baseline_monthly[:n]]
+
+        return {
+            "dates": dates,
+            "values": values,
+            "baseline_mean": b_mean,
+            "baseline_min": b_min,
+            "baseline_max": b_max,
+            "label": "Temperature (\u00b0C)",
+        }
+
+    def _fallback(self, aoi: AOI, time_range: TimeRange) -> IndicatorResult:
+        rng = np.random.default_rng(6)
+        baseline = float(rng.uniform(30, 38))
+        current = baseline + float(rng.uniform(-2, 3))
+        z = (current - baseline) / 2.0
+
+        return IndicatorResult(
+            indicator_id=self.id,
+            headline=f"Temperature data degraded ({current:.1f}\u00b0C)",
+            status=self._classify(abs(z)),
+            trend=self._compute_trend(z),
+            confidence=ConfidenceLevel.LOW,
+            map_layer_path="",
+            chart_data={
+                "dates": [str(time_range.start.year), str(time_range.end.year)],
+                "values": [round(baseline, 1), round(current, 1)],
+                "label": "Temperature (\u00b0C)",
+            },
+            data_source="placeholder",
+            summary="openEO processing unavailable. Showing placeholder values.",
+            methodology="Placeholder \u2014 no satellite data processed.",
+            limitations=["Data is synthetic. openEO backend was unreachable."],
+        )
+```
+
+- [ ] **Step 4: Run tests**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_indicator_lst.py -v`
+
+Expected: All PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add app/indicators/lst.py tests/test_indicator_lst.py
+git commit -m "feat: rewrite LST indicator with Sentinel-3 SLSTR via openEO
+
+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>"
+```
+
+---
+
+### Task 5: Rewrite Rainfall Indicator (CHIRPS Direct Download)
+
+**Files:**
+- Rewrite: `app/indicators/rainfall.py`
+- Rewrite: `tests/test_indicator_rainfall.py`
+
+- [ ] **Step 1: Write tests for CHIRPS-based rainfall indicator**
+
+Replace `tests/test_indicator_rainfall.py` entirely:
+
+```python
+"""Tests for app.indicators.rainfall — CHIRPS precipitation via direct download."""
+from __future__ import annotations
+
+import os
+import tempfile
+from unittest.mock import MagicMock, patch, AsyncMock
+from datetime import date
+
+import numpy as np
+import rasterio
+from rasterio.transform import from_bounds
+import pytest
+
+from app.models import AOI, TimeRange, StatusLevel, ConfidenceLevel
+
+BBOX = [32.45, 15.65, 32.65, 15.8]
+
+
+@pytest.fixture
+def test_aoi():
+    return AOI(name="Test", bbox=BBOX)
+
+
+@pytest.fixture
+def test_time_range():
+    return TimeRange(start=date(2025, 3, 1), end=date(2026, 3, 1))
+
+
+def _mock_precip_tif(path: str, n_months: int = 12, mean_mm: float = 50.0):
+    """Create synthetic monthly precipitation GeoTIFF in mm."""
+    rng = np.random.default_rng(46)
+    data = np.zeros((n_months, 10, 10), dtype=np.float32)
+    for m in range(n_months):
+        seasonal = mean_mm * (0.5 + 0.8 * np.sin(np.pi * (m - 2) / 6))
+        data[m] = np.maximum(0, seasonal + rng.normal(0, 10, (10, 10)))
+    with rasterio.open(
+        path, "w", driver="GTiff", height=10, width=10, count=n_months,
+        dtype="float32", crs="EPSG:4326",
+        transform=from_bounds(*BBOX, 10, 10), nodata=-9999.0,
+    ) as dst:
+        for i in range(n_months):
+            dst.write(data[i], i + 1)
+
+
+@pytest.mark.asyncio
+async def test_rainfall_process_returns_result(test_aoi, test_time_range):
+    from app.indicators.rainfall import RainfallIndicator
+
+    indicator = RainfallIndicator()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        current_path = os.path.join(tmpdir, "precip_current.tif")
+        baseline_path = os.path.join(tmpdir, "precip_baseline.tif")
+        _mock_precip_tif(current_path, mean_mm=45.0)
+        _mock_precip_tif(baseline_path, mean_mm=50.0)
+
+        with patch.object(indicator, '_download_chirps', new_callable=AsyncMock) as mock_dl:
+            async def fake_dl(bbox, start, end, output_path):
+                import shutil
+                if "current" in output_path:
+                    shutil.copy(current_path, output_path)
+                else:
+                    shutil.copy(baseline_path, output_path)
+
+            mock_dl.side_effect = fake_dl
+            result = await indicator.process(test_aoi, test_time_range)
+
+    assert result.indicator_id == "rainfall"
+    assert result.data_source == "satellite"
+    assert "CHIRPS" in result.methodology
+    assert len(result.chart_data.get("dates", [])) > 0
+
+
+@pytest.mark.asyncio
+async def test_rainfall_falls_back_on_failure(test_aoi, test_time_range):
+    from app.indicators.rainfall import RainfallIndicator
+    indicator = RainfallIndicator()
+
+    with patch.object(indicator, '_download_chirps', new_callable=AsyncMock, side_effect=Exception("Download failed")):
+        result = await indicator.process(test_aoi, test_time_range)
+
+    assert result.indicator_id == "rainfall"
+    assert result.data_source == "placeholder"
+
+
+def test_rainfall_compute_stats():
+    from app.indicators.rainfall import RainfallIndicator
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        path = os.path.join(tmpdir, "precip.tif")
+        _mock_precip_tif(path, mean_mm=50.0)
+        stats = RainfallIndicator._compute_stats(path)
+
+    assert "monthly_means_mm" in stats
+    assert len(stats["monthly_means_mm"]) == 12
+    assert "total_mm" in stats
+    assert stats["total_mm"] > 0
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_indicator_rainfall.py -v`
+
+Expected: FAIL — old RainfallIndicator interface doesn't match.
+
+- [ ] **Step 3: Rewrite rainfall indicator**
+
+Replace `app/indicators/rainfall.py` entirely:
+
+```python
+"""Rainfall Indicator — CHIRPS v2.0 precipitation via direct download.
+
+Downloads monthly CHIRPS GeoTIFFs, computes SPI-like deviation from
+a 5-year climatological baseline, and classifies drought severity.
+"""
+from __future__ import annotations
+
+import logging
+import os
+import tempfile
+from datetime import date
+from typing import Any
+
+import numpy as np
+import rasterio
+import httpx
+
+from app.indicators.base import BaseIndicator, SpatialData
+from app.models import (
+    AOI,
+    TimeRange,
+    IndicatorResult,
+    StatusLevel,
+    TrendDirection,
+    ConfidenceLevel,
+)
+
+logger = logging.getLogger(__name__)
+
+BASELINE_YEARS = 5
+
+# CHIRPS monthly data URL pattern (public, no auth needed)
+# Format: https://data.chc.ucsb.edu/products/CHIRPS-2.0/global_monthly/tifs/chirps-v2.0.YYYY.MM.tif.gz
+CHIRPS_BASE = "https://data.chc.ucsb.edu/products/CHIRPS-2.0/global_monthly/tifs"
+
+
+class RainfallIndicator(BaseIndicator):
+    id = "rainfall"
+    name = "Rainfall Adequacy"
+    category = "D5"
+    question = "Is this area getting enough rain?"
+    estimated_minutes = 10
+
+    _true_color_path: str | None = None
+
+    async def process(
+        self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None
+    ) -> IndicatorResult:
+        try:
+            return await self._process_chirps(aoi, time_range, season_months)
+        except Exception as exc:
+            logger.warning("Rainfall CHIRPS processing failed, using placeholder: %s", exc)
+            return self._fallback(aoi, time_range)
+
+    async def _process_chirps(
+        self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None
+    ) -> IndicatorResult:
+        results_dir = tempfile.mkdtemp(prefix="aperture_rainfall_")
+
+        current_path = os.path.join(results_dir, "precip_current.tif")
+        baseline_path = os.path.join(results_dir, "precip_baseline.tif")
+
+        await self._download_chirps(
+            aoi.bbox, time_range.start, time_range.end, current_path,
+        )
+        baseline_start = date(
+            time_range.start.year - BASELINE_YEARS,
+            time_range.start.month,
+            time_range.start.day,
+        )
+        await self._download_chirps(
+            aoi.bbox, baseline_start, time_range.start, baseline_path,
+        )
+
+        current_stats = self._compute_stats(current_path)
+        baseline_stats = self._compute_stats(baseline_path)
+
+        current_total = current_stats["total_mm"]
+        baseline_total = baseline_stats["total_mm"]
+        deviation_pct = (
+            ((current_total - baseline_total) / baseline_total * 100.0)
+            if baseline_total > 0 else 0.0
+        )
+
+        status = self._classify(deviation_pct)
+        trend = self._compute_trend(deviation_pct)
+        confidence = (
+            ConfidenceLevel.HIGH if current_stats["valid_months"] >= 6
+            else ConfidenceLevel.MODERATE if current_stats["valid_months"] >= 3
+            else ConfidenceLevel.LOW
+        )
+
+        chart_data = self._build_chart_data(
+            current_stats["monthly_means_mm"],
+            baseline_stats["monthly_means_mm"],
+            time_range,
+        )
+
+        if abs(deviation_pct) <= 15:
+            headline = f"Rainfall near normal ({current_total:.0f}mm, {deviation_pct:+.0f}%)"
+        elif deviation_pct < 0:
+            headline = f"Rainfall deficit ({deviation_pct:.0f}% below baseline)"
+        else:
+            headline = f"Above-normal rainfall ({deviation_pct:+.0f}% above baseline)"
+
+        self._spatial_data = SpatialData(
+            map_type="raster",
+            label="Precipitation (mm)",
+            colormap="YlGnBu",
+            vmin=0,
+            vmax=max(current_stats["monthly_means_mm"]) * 1.5 if current_stats["monthly_means_mm"] else 100,
+        )
+        self._indicator_raster_path = current_path
+        self._true_color_path = None  # No true-color for rainfall (different resolution)
+        self._render_band = current_stats.get("wettest_band", 1)
+
+        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",
+            summary=(
+                f"Total precipitation is {current_total:.0f}mm compared to "
+                f"{baseline_total:.0f}mm baseline ({deviation_pct:+.1f}%). "
+                f"CHIRPS v2.0 at ~5km resolution."
+            ),
+            methodology=(
+                f"CHIRPS v2.0 monthly precipitation estimates (0.05\u00b0 resolution). "
+                f"Clipped to AOI bounding box. "
+                f"Baseline: {BASELINE_YEARS}-year monthly climatology. "
+                f"Deviation from baseline classified as drought severity."
+            ),
+            limitations=[
+                "CHIRPS resolution is ~5km \u2014 local rainfall variability not captured.",
+                "Satellite-gauge blend may underestimate in data-sparse regions.",
+                "Orographic effects poorly represented at this resolution.",
+                "No distinction between effective and non-effective rainfall.",
+            ],
+        )
+
+    async def _download_chirps(
+        self,
+        bbox: list[float],
+        start: date,
+        end: date,
+        output_path: str,
+    ) -> None:
+        """Download CHIRPS monthly data and create a multi-band GeoTIFF clipped to AOI.
+
+        Each band is one month of precipitation data (mm).
+        """
+        import asyncio
+        from rasterio.windows import from_bounds as window_from_bounds
+
+        monthly_data = []
+        transform = None
+        height = width = None
+
+        async def _fetch_month(year: int, month: int) -> np.ndarray | None:
+            url = f"{CHIRPS_BASE}/chirps-v2.0.{year}.{month:02d}.tif.gz"
+            try:
+                async with httpx.AsyncClient(timeout=60) as client:
+                    resp = await client.get(url)
+                    if resp.status_code != 200:
+                        logger.warning("CHIRPS download failed for %d-%02d: %d", year, month, resp.status_code)
+                        return None
+
+                # Decompress and read the subset
+                import gzip
+                import io
+                decompressed = gzip.decompress(resp.content)
+                with rasterio.open(io.BytesIO(decompressed)) as src:
+                    window = window_from_bounds(*bbox, transform=src.transform)
+                    data = src.read(1, window=window).astype(np.float32)
+                    return data
+            except Exception as exc:
+                logger.warning("CHIRPS fetch error for %d-%02d: %s", year, month, exc)
+                return None
+
+        # Collect monthly data
+        current = date(start.year, start.month, 1)
+        months_collected = []
+        while current < end:
+            data = await _fetch_month(current.year, current.month)
+            if data is not None:
+                monthly_data.append(data)
+                months_collected.append(current)
+            if current.month == 12:
+                current = date(current.year + 1, 1, 1)
+            else:
+                current = date(current.year, current.month + 1, 1)
+
+        if not monthly_data:
+            raise ValueError("No CHIRPS data available for the requested period")
+
+        # Write as multi-band GeoTIFF
+        h, w = monthly_data[0].shape
+        from rasterio.transform import from_bounds as transform_from_bounds
+        t = transform_from_bounds(*bbox, w, h)
+
+        with rasterio.open(
+            output_path, "w", driver="GTiff",
+            height=h, width=w, count=len(monthly_data),
+            dtype="float32", crs="EPSG:4326",
+            transform=t, nodata=-9999.0,
+        ) as dst:
+            for i, data in enumerate(monthly_data):
+                dst.write(data, i + 1)
+
+    @staticmethod
+    def _compute_stats(tif_path: str) -> dict[str, Any]:
+        """Extract monthly precipitation statistics from a multi-band GeoTIFF."""
+        with rasterio.open(tif_path) as src:
+            n_bands = src.count
+            monthly_means = []
+            peak_val = -1.0
+            peak_band = 1
+            for band in range(1, n_bands + 1):
+                data = src.read(band).astype(np.float32)
+                nodata = src.nodata
+                if nodata is not None:
+                    valid = data[data != nodata]
+                else:
+                    valid = data.ravel()
+                if len(valid) > 0:
+                    mean = float(np.nanmean(valid))
+                    monthly_means.append(mean)
+                    if mean > peak_val:
+                        peak_val = mean
+                        peak_band = band
+                else:
+                    monthly_means.append(0.0)
+
+        valid_months = sum(1 for m in monthly_means if m > 0)
+        total = float(np.sum(monthly_means))
+
+        return {
+            "monthly_means_mm": monthly_means,
+            "total_mm": total,
+            "valid_months": valid_months,
+            "wettest_band": peak_band,
+        }
+
+    @staticmethod
+    def _classify(deviation_pct: float) -> StatusLevel:
+        if deviation_pct >= -15:
+            return StatusLevel.GREEN
+        if deviation_pct >= -30:
+            return StatusLevel.AMBER
+        return StatusLevel.RED
+
+    @staticmethod
+    def _compute_trend(deviation_pct: float) -> TrendDirection:
+        if abs(deviation_pct) <= 15:
+            return TrendDirection.STABLE
+        if deviation_pct < 0:
+            return TrendDirection.DETERIORATING
+        return TrendDirection.IMPROVING
+
+    @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, 1) for v in current_monthly[:n]]
+        b_mean = [round(v, 1) for v in baseline_monthly[:n]]
+        b_min = [round(max(v - 15, 0), 1) for v in baseline_monthly[:n]]
+        b_max = [round(v + 15, 1) for v in baseline_monthly[:n]]
+
+        return {
+            "dates": dates,
+            "values": values,
+            "baseline_mean": b_mean,
+            "baseline_min": b_min,
+            "baseline_max": b_max,
+            "label": "Precipitation (mm)",
+        }
+
+    def _fallback(self, aoi: AOI, time_range: TimeRange) -> IndicatorResult:
+        rng = np.random.default_rng(5)
+        baseline = float(rng.uniform(300, 600))
+        current = baseline * float(rng.uniform(0.7, 1.1))
+        deviation = ((current - baseline) / baseline) * 100
+
+        return IndicatorResult(
+            indicator_id=self.id,
+            headline=f"Rainfall data degraded ({current:.0f}mm)",
+            status=self._classify(deviation),
+            trend=self._compute_trend(deviation),
+            confidence=ConfidenceLevel.LOW,
+            map_layer_path="",
+            chart_data={
+                "dates": [str(time_range.start.year), str(time_range.end.year)],
+                "values": [round(baseline, 0), round(current, 0)],
+                "label": "Precipitation (mm)",
+            },
+            data_source="placeholder",
+            summary="CHIRPS download unavailable. Showing placeholder values.",
+            methodology="Placeholder \u2014 no satellite data processed.",
+            limitations=["Data is synthetic. CHIRPS data was unreachable."],
+        )
+```
+
+- [ ] **Step 4: Run tests**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_indicator_rainfall.py -v`
+
+Expected: All PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add app/indicators/rainfall.py tests/test_indicator_rainfall.py
+git commit -m "feat: rewrite rainfall indicator with CHIRPS direct download
+
+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>"
+```
+
+---
+
+### Task 6: Rewrite Nightlights Indicator (VIIRS EOG Direct Download)
+
+**Files:**
+- Rewrite: `app/indicators/nightlights.py`
+- Rewrite: `tests/test_indicator_nightlights.py`
+
+- [ ] **Step 1: Write tests**
+
+Replace `tests/test_indicator_nightlights.py` entirely:
+
+```python
+"""Tests for app.indicators.nightlights — VIIRS DNB via EOG direct download."""
+from __future__ import annotations
+
+import os
+import tempfile
+from unittest.mock import MagicMock, patch, AsyncMock
+from datetime import date
+
+import numpy as np
+import rasterio
+from rasterio.transform import from_bounds
+import pytest
+
+from app.models import AOI, TimeRange, StatusLevel, ConfidenceLevel
+
+BBOX = [32.45, 15.65, 32.65, 15.8]
+
+
+@pytest.fixture
+def test_aoi():
+    return AOI(name="Test", bbox=BBOX)
+
+
+@pytest.fixture
+def test_time_range():
+    return TimeRange(start=date(2025, 3, 1), end=date(2026, 3, 1))
+
+
+def _mock_radiance_tif(path: str, mean_nw: float = 5.0):
+    """Create synthetic VIIRS DNB radiance GeoTIFF (nW/cm²/sr)."""
+    rng = np.random.default_rng(47)
+    data = np.maximum(0, mean_nw + rng.normal(0, 2, (10, 10))).astype(np.float32)
+    with rasterio.open(
+        path, "w", driver="GTiff", height=10, width=10, count=1,
+        dtype="float32", crs="EPSG:4326",
+        transform=from_bounds(*BBOX, 10, 10), nodata=-9999.0,
+    ) as dst:
+        dst.write(data, 1)
+
+
+@pytest.mark.asyncio
+async def test_nightlights_process_returns_result(test_aoi, test_time_range):
+    from app.indicators.nightlights import NightlightsIndicator
+
+    indicator = NightlightsIndicator()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        current_path = os.path.join(tmpdir, "viirs_current.tif")
+        baseline_path = os.path.join(tmpdir, "viirs_baseline.tif")
+        _mock_radiance_tif(current_path, mean_nw=5.0)
+        _mock_radiance_tif(baseline_path, mean_nw=6.0)
+
+        with patch.object(indicator, '_download_viirs', new_callable=AsyncMock) as mock_dl:
+            async def fake_dl(bbox, year, output_path):
+                import shutil
+                if "current" in output_path:
+                    shutil.copy(current_path, output_path)
+                else:
+                    shutil.copy(baseline_path, output_path)
+
+            mock_dl.side_effect = fake_dl
+            result = await indicator.process(test_aoi, test_time_range)
+
+    assert result.indicator_id == "nightlights"
+    assert result.data_source == "satellite"
+    assert len(result.chart_data.get("dates", [])) > 0
+
+
+@pytest.mark.asyncio
+async def test_nightlights_falls_back_on_failure(test_aoi, test_time_range):
+    from app.indicators.nightlights import NightlightsIndicator
+    indicator = NightlightsIndicator()
+
+    with patch.object(indicator, '_download_viirs', new_callable=AsyncMock, side_effect=Exception("Download failed")):
+        result = await indicator.process(test_aoi, test_time_range)
+
+    assert result.indicator_id == "nightlights"
+    assert result.data_source == "placeholder"
+
+
+def test_nightlights_compute_stats():
+    from app.indicators.nightlights import NightlightsIndicator
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        path = os.path.join(tmpdir, "viirs.tif")
+        _mock_radiance_tif(path, mean_nw=5.0)
+        stats = NightlightsIndicator._compute_stats(path)
+
+    assert "mean_radiance" in stats
+    assert stats["mean_radiance"] > 0
+    assert "valid_pixel_fraction" in stats
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_indicator_nightlights.py -v`
+
+Expected: FAIL.
+
+- [ ] **Step 3: Rewrite nightlights indicator**
+
+Replace `app/indicators/nightlights.py` entirely:
+
+```python
+"""Nighttime Lights Indicator — VIIRS DNB via EOG direct download.
+
+Downloads annual VIIRS DNB composites from Colorado School of Mines EOG,
+compares current-year radiance to a 3-year baseline.
+"""
+from __future__ import annotations
+
+import logging
+import os
+import tempfile
+from datetime import date
+from typing import Any
+
+import numpy as np
+import rasterio
+import httpx
+
+from app.indicators.base import BaseIndicator, SpatialData
+from app.models import (
+    AOI,
+    TimeRange,
+    IndicatorResult,
+    StatusLevel,
+    TrendDirection,
+    ConfidenceLevel,
+)
+
+logger = logging.getLogger(__name__)
+
+BASELINE_YEARS = 3
+
+# EOG VIIRS DNB annual composites (public, COG format)
+EOG_BASE = "https://eogdata.mines.edu/nighttime_light/annual/v22"
+
+
+class NightlightsIndicator(BaseIndicator):
+    id = "nightlights"
+    name = "Nighttime Lights"
+    category = "D3"
+    question = "Is the local economy active?"
+    estimated_minutes = 10
+
+    _true_color_path: str | None = None
+
+    async def process(
+        self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None
+    ) -> IndicatorResult:
+        try:
+            return await self._process_viirs(aoi, time_range)
+        except Exception as exc:
+            logger.warning("Nightlights download failed, using placeholder: %s", exc)
+            return self._fallback(aoi, time_range)
+
+    async def _process_viirs(
+        self, aoi: AOI, time_range: TimeRange
+    ) -> IndicatorResult:
+        results_dir = tempfile.mkdtemp(prefix="aperture_nightlights_")
+
+        current_year = time_range.end.year
+        current_path = os.path.join(results_dir, "viirs_current.tif")
+        baseline_path = os.path.join(results_dir, "viirs_baseline.tif")
+
+        await self._download_viirs(aoi.bbox, current_year, current_path)
+        await self._download_viirs(aoi.bbox, current_year - BASELINE_YEARS, baseline_path)
+
+        current_stats = self._compute_stats(current_path)
+        baseline_stats = self._compute_stats(baseline_path)
+
+        current_rad = current_stats["mean_radiance"]
+        baseline_rad = baseline_stats["mean_radiance"]
+        pct_change = ((current_rad - baseline_rad) / baseline_rad * 100) if baseline_rad > 0 else 0.0
+
+        status = self._classify(pct_change)
+        trend = self._compute_trend(pct_change)
+        confidence = (
+            ConfidenceLevel.HIGH if current_stats["valid_pixel_fraction"] >= 0.7
+            else ConfidenceLevel.MODERATE if current_stats["valid_pixel_fraction"] >= 0.4
+            else ConfidenceLevel.LOW
+        )
+
+        chart_data = {
+            "dates": [str(current_year - BASELINE_YEARS), str(current_year)],
+            "values": [round(baseline_rad, 2), round(current_rad, 2)],
+            "baseline_range_mean": round(baseline_rad, 2),
+            "baseline_range_min": round(baseline_rad * 0.85, 2),
+            "baseline_range_max": round(baseline_rad * 1.15, 2),
+            "label": "Radiance (nW/cm\u00b2/sr)",
+        }
+
+        if abs(pct_change) <= 15:
+            headline = f"Nighttime lights stable ({current_rad:.1f} nW, {pct_change:+.0f}%)"
+        elif pct_change < 0:
+            headline = f"Nighttime lights declining ({pct_change:.0f}%)"
+        else:
+            headline = f"Nighttime lights increasing (+{pct_change:.0f}%)"
+
+        self._spatial_data = SpatialData(
+            map_type="raster",
+            label="Radiance (nW/cm\u00b2/sr)",
+            colormap="inferno",
+            vmin=0,
+            vmax=max(current_rad * 2, 10),
+        )
+        self._indicator_raster_path = current_path
+        self._true_color_path = None
+        self._render_band = 1
+
+        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",
+            summary=(
+                f"Mean radiance is {current_rad:.2f} nW/cm\u00b2/sr compared to "
+                f"{baseline_rad:.2f} baseline ({pct_change:+.1f}%). "
+                f"VIIRS DNB annual composite at ~500m resolution."
+            ),
+            methodology=(
+                f"VIIRS Day-Night Band annual composites from Colorado School of Mines EOG. "
+                f"Stray-light corrected, cloud-free composite. "
+                f"Clipped to AOI bounding box. "
+                f"Baseline: {BASELINE_YEARS}-year prior annual composite."
+            ),
+            limitations=[
+                "Annual composites \u2014 cannot detect sub-annual changes.",
+                "Moonlight, fires, and gas flaring inflate radiance values.",
+                "~500m resolution smooths urban-rural boundaries.",
+                "Most recent annual composite may lag by several months.",
+            ],
+        )
+
+    async def _download_viirs(
+        self, bbox: list[float], year: int, output_path: str
+    ) -> None:
+        """Download VIIRS DNB annual composite and clip to AOI bbox.
+
+        Uses COG (Cloud-Optimized GeoTIFF) with HTTP range requests
+        to read only the AOI window from the full global file.
+        """
+        # Try reading via rasterio with HTTP range requests (COG)
+        import asyncio
+        from rasterio.windows import from_bounds as window_from_bounds
+
+        loop = asyncio.get_event_loop()
+
+        def _read_cog():
+            # EOG provides global annual composites as COGs
+            url = f"{EOG_BASE}/{year}/VNP46A4_t{year}.average_masked.tif"
+
+            with rasterio.open(url) as src:
+                window = window_from_bounds(*bbox, transform=src.transform)
+                data = src.read(1, window=window).astype(np.float32)
+                win_transform = src.window_transform(window)
+
+            from rasterio.transform import from_bounds
+            h, w = data.shape
+            t = from_bounds(*bbox, w, h)
+
+            with rasterio.open(
+                output_path, "w", driver="GTiff",
+                height=h, width=w, count=1,
+                dtype="float32", crs="EPSG:4326",
+                transform=t, nodata=-9999.0,
+            ) as dst:
+                dst.write(data, 1)
+
+        await loop.run_in_executor(None, _read_cog)
+
+    @staticmethod
+    def _compute_stats(tif_path: str) -> dict[str, Any]:
+        """Extract radiance statistics from VIIRS GeoTIFF."""
+        with rasterio.open(tif_path) as src:
+            data = src.read(1).astype(np.float32)
+            nodata = src.nodata
+            if nodata is not None:
+                valid = data[data != nodata]
+            else:
+                valid = data.ravel()
+
+            valid = valid[valid >= 0]  # Remove negative radiance
+            total_pixels = data.size
+            valid_fraction = len(valid) / total_pixels if total_pixels > 0 else 0.0
+
+        return {
+            "mean_radiance": float(np.mean(valid)) if len(valid) > 0 else 0.0,
+            "valid_pixel_fraction": valid_fraction,
+        }
+
+    @staticmethod
+    def _classify(pct_change: float) -> StatusLevel:
+        if pct_change > -15:
+            return StatusLevel.GREEN
+        if pct_change > -40:
+            return StatusLevel.AMBER
+        return StatusLevel.RED
+
+    @staticmethod
+    def _compute_trend(pct_change: float) -> TrendDirection:
+        if abs(pct_change) <= 15:
+            return TrendDirection.STABLE
+        if pct_change < 0:
+            return TrendDirection.DETERIORATING
+        return TrendDirection.IMPROVING
+
+    def _fallback(self, aoi: AOI, time_range: TimeRange) -> IndicatorResult:
+        rng = np.random.default_rng(3)
+        baseline = float(rng.uniform(2, 10))
+        current = baseline * float(rng.uniform(0.7, 1.1))
+        pct = ((current - baseline) / baseline) * 100
+
+        return IndicatorResult(
+            indicator_id=self.id,
+            headline=f"Nightlights data degraded ({current:.1f} nW)",
+            status=self._classify(pct),
+            trend=self._compute_trend(pct),
+            confidence=ConfidenceLevel.LOW,
+            map_layer_path="",
+            chart_data={
+                "dates": [str(time_range.start.year), str(time_range.end.year)],
+                "values": [round(baseline, 2), round(current, 2)],
+                "label": "Radiance (nW/cm\u00b2/sr)",
+            },
+            data_source="placeholder",
+            summary="VIIRS download unavailable. Showing placeholder values.",
+            methodology="Placeholder \u2014 no satellite data processed.",
+            limitations=["Data is synthetic. VIIRS data was unreachable."],
+        )
+```
+
+- [ ] **Step 4: Run tests**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_indicator_nightlights.py -v`
+
+Expected: All PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add app/indicators/nightlights.py tests/test_indicator_nightlights.py
+git commit -m "feat: rewrite nightlights indicator with VIIRS EOG direct download
+
+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>"
+```
+
+---
+
+### Task 7: Full Test Suite Verification
+
+- [ ] **Step 1: Run complete test suite**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/ -v --timeout=120 2>&1 | tail -30`
+
+Expected: All tests PASS. Count should be ~136+ (existing tests, some rewritten).
+
+- [ ] **Step 2: Verify all indicators register**
+
+Run: `cd /Users/kmini/Github/Aperture && python -c "from app.indicators import registry; ids = registry.list_ids(); print(f'{len(ids)} indicators:', ids)"`
+
+Expected: `10 indicators: ['ndvi', 'fires', 'cropland', 'vegetation', 'rainfall', 'water', 'no2', 'lst', 'nightlights', 'food_security']`
+
+- [ ] **Step 3: Verify imports don't cycle**
+
+Run: `cd /Users/kmini/Github/Aperture && python -c "from app.indicators.water import WaterIndicator; from app.indicators.lst import LSTIndicator; from app.indicators.rainfall import RainfallIndicator; from app.indicators.nightlights import NightlightsIndicator; print('All imports OK')"`
+
+Expected: `All imports OK`
+
+- [ ] **Step 4: Check git log**
+
+Run: `cd /Users/kmini/Github/Aperture && git log --oneline -8`
+
+Expected: 6-7 new commits from this plan.