docs: add Phase C spec and implementation plan — SAR, built-up, visual overview

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-c-sar-buildup-overview.md

@@ -0,0 +1,1971 @@
+# Phase C — SAR Backscatter, Built-up Extent, Visual Overview
+
+> **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:** Add SAR backscatter and built-up settlement indicators via openEO, plus a visual overview post-processing step that produces a composite score and true-color satellite snapshot.
+
+**Architecture:** Two new `BaseIndicator` subclasses follow the Phase B openEO pattern (graph builder → GeoTIFF download → zonal stats → classify). The visual overview is a post-processing step in the worker that synthesizes indicator results into a weighted composite score and renders a standalone true-color map. Report PDF gains an overview page with summary table.
+
+**Tech Stack:** openEO (CDSE), rasterio, numpy, matplotlib/cartopy, reportlab — all existing dependencies.
+
+**Spec:** `docs/superpowers/specs/2026-03-31-phase-c-sar-buildup-overview-design.md`
+
+---
+
+### Task 1: Add SAR and built-up graph builders to openEO client
+
+**Files:**
+- Modify: `app/openeo_client.py`
+- Modify: `tests/test_openeo_client.py`
+
+- [ ] **Step 1: Write failing tests for `build_sar_graph` and `build_buildup_graph`**
+
+Append to `tests/test_openeo_client.py`:
+
+```python
+def test_build_sar_graph():
+    """build_sar_graph() loads Sentinel-1 GRD with VV and VH bands."""
+    mock_conn = MagicMock()
+    mock_cube = MagicMock()
+    mock_conn.load_collection.return_value = mock_cube
+
+    from app.openeo_client import build_sar_graph
+
+    bbox = {"west": 32.45, "south": 15.65, "east": 32.65, "north": 15.8}
+    result = build_sar_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"] == "SENTINEL1_GRD"
+    assert "VV" in call_kwargs[1]["bands"]
+    assert "VH" in call_kwargs[1]["bands"]
+
+
+def test_build_buildup_graph():
+    """build_buildup_graph() loads Sentinel-2 with SWIR, NIR, Red, and SCL bands."""
+    mock_conn = MagicMock()
+    mock_cube = MagicMock()
+    mock_conn.load_collection.return_value = mock_cube
+
+    from app.openeo_client import build_buildup_graph
+
+    bbox = {"west": 32.45, "south": 15.65, "east": 32.65, "north": 15.8}
+    result = build_buildup_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 "B04" in call_kwargs[1]["bands"]
+    assert "B08" in call_kwargs[1]["bands"]
+    assert "B11" in call_kwargs[1]["bands"]
+    assert "SCL" in call_kwargs[1]["bands"]
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `pytest tests/test_openeo_client.py::test_build_sar_graph tests/test_openeo_client.py::test_build_buildup_graph -v`
+Expected: FAIL with `ImportError` — functions don't exist yet.
+
+- [ ] **Step 3: Implement `build_sar_graph` in `app/openeo_client.py`**
+
+Add after the `build_lst_graph` function (after line 200):
+
+```python
+def build_sar_graph(
+    *,
+    conn: openeo.Connection,
+    bbox: dict[str, float],
+    temporal_extent: list[str],
+    resolution_m: int = 100,
+) -> openeo.DataCube:
+    """Build an openEO process graph for Sentinel-1 GRD SAR backscatter.
+
+    Loads VV and VH polarizations, filters ascending orbits, converts
+    to dB scale, and aggregates to monthly median composites.
+
+    Returns an openEO DataCube (not yet executed).
+    """
+    cube = conn.load_collection(
+        collection_id="SENTINEL1_GRD",
+        spatial_extent=bbox,
+        temporal_extent=temporal_extent,
+        bands=["VV", "VH"],
+    )
+
+    # Filter ascending orbits for radiometric consistency
+    cube = cube.filter_labels(
+        condition=lambda x: x == "ASCENDING",
+        dimension="sar:orbit_state",
+    )
+
+    # Convert linear backscatter to dB: 10 * log10(linear)
+    cube = cube.apply(lambda x: 10.0 * x.log(base=10))
+
+    # Monthly median composite
+    monthly = cube.aggregate_temporal_period("month", reducer="median")
+
+    # Resample to target resolution
+    if resolution_m > 10:
+        monthly = monthly.resample_spatial(resolution=resolution_m / 111320)
+
+    return monthly
+```
+
+- [ ] **Step 4: Implement `build_buildup_graph` in `app/openeo_client.py`**
+
+Add after `build_sar_graph`:
+
+```python
+def build_buildup_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 NDBI built-up index composites.
+
+    NDBI = (B11 - B08) / (B11 + B08). Higher values indicate impervious surfaces.
+    Cloud-masked via SCL band, aggregated to monthly medians.
+
+    The binary built-up mask (NDBI > 0 AND NDVI < 0.2) is computed in the
+    indicator's process() method, not here — keeping the graph builder simple.
+    """
+    cube = conn.load_collection(
+        collection_id="SENTINEL2_L2A",
+        spatial_extent=bbox,
+        temporal_extent=temporal_extent,
+        bands=["B04", "B08", "B11", "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)
+
+    # NDBI = (SWIR - NIR) / (SWIR + NIR)
+    b11 = cube.band("B11")
+    b08 = cube.band("B08")
+    ndbi = (b11 - b08) / (b11 + b08)
+
+    # Monthly median composite
+    monthly = ndbi.aggregate_temporal_period("month", reducer="median")
+
+    # Resample to target resolution
+    if resolution_m > 10:
+        monthly = monthly.resample_spatial(resolution=resolution_m / 111320)
+
+    return monthly
+```
+
+- [ ] **Step 5: Run tests to verify they pass**
+
+Run: `pytest tests/test_openeo_client.py -v`
+Expected: ALL PASS (6 tests total — 4 existing + 2 new).
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add app/openeo_client.py tests/test_openeo_client.py
+git commit -m "feat: add SAR and built-up graph builders to openEO client"
+```
+
+---
+
+### Task 2: Implement SAR backscatter indicator
+
+**Files:**
+- Create: `app/indicators/sar.py`
+- Create: `tests/test_indicator_sar.py`
+
+- [ ] **Step 1: Write failing tests for SAR indicator**
+
+Create `tests/test_indicator_sar.py`:
+
+```python
+"""Tests for app.indicators.sar — SAR backscatter 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_sar_tif(path: str, n_months: int = 12):
+    """Create synthetic SAR backscatter GeoTIFF in dB scale.
+
+    Interleaved bands: VV_m1, VH_m1, VV_m2, VH_m2, ...
+    Total bands = n_months * 2.
+    """
+    rng = np.random.default_rng(50)
+    n_bands = n_months * 2
+    data = np.zeros((n_bands, 10, 10), dtype=np.float32)
+    for m in range(n_months):
+        # VV: typical range -15 to -5 dB
+        data[m * 2] = rng.uniform(-12, -6, (10, 10))
+        # VH: typically 5-8 dB lower than VV
+        data[m * 2 + 1] = data[m * 2] - rng.uniform(5, 8, (10, 10))
+    with rasterio.open(
+        path, "w", driver="GTiff", height=10, width=10, count=n_bands,
+        dtype="float32", crs="EPSG:4326",
+        transform=from_bounds(*BBOX, 10, 10), nodata=-9999.0,
+    ) as dst:
+        for i in range(n_bands):
+            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_sar_process_returns_result(test_aoi, test_time_range):
+    """SarIndicator.process() returns a valid IndicatorResult."""
+    from app.indicators.sar import SarIndicator
+
+    indicator = SarIndicator()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        sar_path = os.path.join(tmpdir, "sar.tif")
+        rgb_path = os.path.join(tmpdir, "rgb.tif")
+        _mock_sar_tif(sar_path)
+        _mock_rgb_tif(rgb_path)
+
+        mock_cube = MagicMock()
+
+        def fake_download(path, **kwargs):
+            import shutil
+            if "sar" in path:
+                shutil.copy(sar_path, path)
+            else:
+                shutil.copy(rgb_path, path)
+
+        mock_cube.download = MagicMock(side_effect=fake_download)
+
+        with patch("app.indicators.sar.get_connection"), \
+             patch("app.indicators.sar.build_sar_graph", return_value=mock_cube), \
+             patch("app.indicators.sar.build_true_color_graph", return_value=mock_cube):
+            result = await indicator.process(test_aoi, test_time_range)
+
+    assert result.indicator_id == "sar"
+    assert result.status in (StatusLevel.GREEN, StatusLevel.AMBER, StatusLevel.RED)
+    assert result.trend in (TrendDirection.IMPROVING, TrendDirection.STABLE, TrendDirection.DETERIORATING)
+    assert result.data_source == "satellite"
+    assert "SAR" in result.methodology or "backscatter" in result.methodology.lower()
+    assert len(result.chart_data.get("dates", [])) > 0
+
+
+@pytest.mark.asyncio
+async def test_sar_falls_back_on_failure(test_aoi, test_time_range):
+    """SarIndicator falls back gracefully when openEO fails."""
+    from app.indicators.sar import SarIndicator
+
+    indicator = SarIndicator()
+
+    with patch("app.indicators.sar.get_connection", side_effect=Exception("CDSE down")):
+        result = await indicator.process(test_aoi, test_time_range)
+
+    assert result.indicator_id == "sar"
+    assert result.confidence == ConfidenceLevel.LOW
+    assert "Insufficient" in result.headline or "placeholder" in result.data_source
+
+
+def test_sar_compute_stats():
+    """_compute_stats() extracts VV monthly means from interleaved SAR raster."""
+    from app.indicators.sar import SarIndicator
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        path = os.path.join(tmpdir, "sar.tif")
+        _mock_sar_tif(path, n_months=12)
+        stats = SarIndicator._compute_stats(path)
+
+    assert "monthly_vv_means" in stats
+    assert len(stats["monthly_vv_means"]) == 12
+    assert "overall_vv_mean" in stats
+    # VV should be negative dB values
+    assert stats["overall_vv_mean"] < 0
+    assert "valid_months" in stats
+    assert stats["valid_months"] == 12
+
+
+def test_sar_classify_change():
+    """_classify() maps change area percentage to correct status."""
+    from app.indicators.sar import SarIndicator
+
+    assert SarIndicator._classify(change_pct=3.0, flood_months=0) == StatusLevel.GREEN
+    assert SarIndicator._classify(change_pct=10.0, flood_months=0) == StatusLevel.AMBER
+    assert SarIndicator._classify(change_pct=10.0, flood_months=2) == StatusLevel.AMBER
+    assert SarIndicator._classify(change_pct=20.0, flood_months=0) == StatusLevel.RED
+    assert SarIndicator._classify(change_pct=3.0, flood_months=3) == StatusLevel.RED
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `pytest tests/test_indicator_sar.py -v`
+Expected: FAIL with `ModuleNotFoundError` — module doesn't exist yet.
+
+- [ ] **Step 3: Implement SAR indicator**
+
+Create `app/indicators/sar.py`:
+
+```python
+"""SAR Backscatter Indicator — Sentinel-1 GRD via CDSE openEO.
+
+Computes monthly VV/VH median composites, detects ground surface change
+and potential flood events against a baseline period.
+"""
+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_sar_graph, build_true_color_graph, _bbox_dict
+
+logger = logging.getLogger(__name__)
+
+BASELINE_YEARS = 3
+CHANGE_THRESHOLD_DB = 3.0  # dB change considered significant
+FLOOD_SIGMA = 2.0  # Standard deviations below baseline mean
+
+
+class SarIndicator(BaseIndicator):
+    id = "sar"
+    name = "SAR Backscatter"
+    category = "D10"
+    question = "Is ground surface changing?"
+    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_openeo(aoi, time_range, season_months)
+        except Exception as exc:
+            logger.warning("SAR openEO processing failed: %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_sar_")
+
+        current_cube = build_sar_graph(
+            conn=conn, bbox=bbox,
+            temporal_extent=[current_start, current_end],
+            resolution_m=RESOLUTION_M,
+        )
+        baseline_cube = build_sar_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, "sar_current.tif")
+        baseline_path = os.path.join(results_dir, "sar_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)
+
+        # Check for insufficient data
+        if current_stats["valid_months"] == 0:
+            return self._insufficient_data(aoi, time_range)
+
+        # Change detection: mean VV difference per pixel
+        change_db = current_stats["overall_vv_mean"] - baseline_stats["overall_vv_mean"]
+
+        # Compute % of area with significant change
+        change_pct = self._compute_change_area_pct(
+            current_path, baseline_path, current_stats, baseline_stats
+        )
+
+        # Flood detection: months where VV < baseline_mean - 2σ
+        flood_months = self._count_flood_months(
+            current_stats["monthly_vv_means"],
+            baseline_stats["overall_vv_mean"],
+            baseline_stats["vv_std"],
+        )
+
+        status = self._classify(change_pct, flood_months)
+        trend = self._compute_trend(current_stats["monthly_vv_means"])
+        confidence = (
+            ConfidenceLevel.HIGH if current_stats["valid_months"] >= 6
+            else ConfidenceLevel.MODERATE if current_stats["valid_months"] >= 3
+            else ConfidenceLevel.LOW
+        )
+
+        chart_data = self._build_chart_data(
+            current_stats["monthly_vv_means"],
+            baseline_stats["monthly_vv_means"],
+            time_range,
+        )
+
+        # Headline
+        parts = []
+        if change_pct >= 5:
+            parts.append(f"{change_pct:.0f}% ground surface change")
+        if flood_months > 0:
+            parts.append(f"{flood_months} potential flood event{'s' if flood_months > 1 else ''}")
+        if parts:
+            headline = f"SAR detects {', '.join(parts)}"
+        else:
+            headline = "Stable backscatter conditions — no significant ground change detected"
+
+        # Store raster path for map rendering — write a change map
+        change_map_path = os.path.join(results_dir, "sar_change.tif")
+        self._write_change_raster(current_path, baseline_path, change_map_path)
+
+        self._spatial_data = SpatialData(
+            map_type="raster",
+            label="SAR VV Change (dB)",
+            colormap="RdBu_r",
+            vmin=-6,
+            vmax=6,
+        )
+        self._indicator_raster_path = change_map_path
+        self._render_band = 1
+
+        return IndicatorResult(
+            indicator_id=self.id,
+            headline=headline,
+            status=status,
+            trend=trend,
+            confidence=confidence,
+            map_layer_path=change_map_path,
+            chart_data=chart_data,
+            data_source="satellite",
+            summary=(
+                f"Mean VV backscatter change: {change_db:+.1f} dB. "
+                f"{change_pct:.1f}% of AOI shows significant change (>{CHANGE_THRESHOLD_DB} dB). "
+                f"{flood_months} month(s) with potential flood signals. "
+                f"Pixel-level analysis at {RESOLUTION_M}m resolution from "
+                f"{current_stats['valid_months']} monthly composites."
+            ),
+            methodology=(
+                f"Sentinel-1 GRD IW VV/VH polarizations, ascending orbit. "
+                f"Linear backscatter converted to dB (10·log₁₀). "
+                f"Monthly median composites at {RESOLUTION_M}m resolution. "
+                f"Change detection: >{CHANGE_THRESHOLD_DB} dB difference vs "
+                f"{BASELINE_YEARS}-year baseline. "
+                f"Flood mapping: VV < baseline_mean − {FLOOD_SIGMA}σ. "
+                f"Processed via CDSE openEO."
+            ),
+            limitations=[
+                f"Resampled to {RESOLUTION_M}m — fine-scale changes not captured.",
+                "Ascending orbit filter may reduce temporal coverage in some areas.",
+                "Sentinel-1 coverage over East Africa can be inconsistent.",
+                "VV decrease may indicate flooding, moisture, or vegetation change — not uniquely flood.",
+            ],
+        )
+
+    @staticmethod
+    def _compute_stats(tif_path: str) -> dict[str, Any]:
+        """Extract monthly VV statistics from interleaved SAR GeoTIFF.
+
+        Bands are interleaved: VV_m1, VH_m1, VV_m2, VH_m2, ...
+        """
+        with rasterio.open(tif_path) as src:
+            n_bands = src.count
+            n_months = n_bands // 2
+            monthly_vv_means: list[float] = []
+            all_vv_values: list[float] = []
+
+            for m in range(n_months):
+                vv_band = m * 2 + 1  # 1-based: bands 1, 3, 5, ...
+                data = src.read(vv_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_val = float(np.nanmean(valid))
+                    monthly_vv_means.append(mean_val)
+                    all_vv_values.extend(valid.tolist())
+                else:
+                    monthly_vv_means.append(0.0)
+
+        valid_months = sum(1 for m in monthly_vv_means if m != 0.0)
+        valid_means = [m for m in monthly_vv_means if m != 0.0]
+        overall_vv_mean = float(np.mean(valid_means)) if valid_means else 0.0
+        vv_std = float(np.std(all_vv_values)) if all_vv_values else 1.0
+
+        return {
+            "monthly_vv_means": monthly_vv_means,
+            "overall_vv_mean": overall_vv_mean,
+            "vv_std": vv_std,
+            "valid_months": valid_months,
+        }
+
+    @staticmethod
+    def _compute_change_area_pct(
+        current_path: str, baseline_path: str,
+        current_stats: dict, baseline_stats: dict,
+    ) -> float:
+        """Compute % of AOI area with >3 dB VV change (pixel-level)."""
+        with rasterio.open(current_path) as csrc, rasterio.open(baseline_path) as bsrc:
+            c_months = csrc.count // 2
+            b_months = bsrc.count // 2
+
+            # Read all VV bands and compute per-pixel means
+            c_vv = []
+            for m in range(c_months):
+                c_vv.append(csrc.read(m * 2 + 1).astype(np.float32))
+            c_mean = np.nanmean(np.stack(c_vv), axis=0)
+
+            b_vv = []
+            for m in range(b_months):
+                b_vv.append(bsrc.read(m * 2 + 1).astype(np.float32))
+            b_mean = np.nanmean(np.stack(b_vv), axis=0)
+
+        diff = np.abs(c_mean - b_mean)
+        significant = np.sum(diff > CHANGE_THRESHOLD_DB)
+        total = diff.size
+        return float(significant / total * 100) if total > 0 else 0.0
+
+    @staticmethod
+    def _count_flood_months(
+        monthly_vv: list[float], baseline_mean: float, baseline_std: float
+    ) -> int:
+        """Count months where mean VV is anomalously low (potential flood)."""
+        threshold = baseline_mean - FLOOD_SIGMA * baseline_std
+        return sum(1 for v in monthly_vv if v != 0.0 and v < threshold)
+
+    @staticmethod
+    def _classify(change_pct: float, flood_months: int) -> StatusLevel:
+        if change_pct >= 15 or flood_months >= 3:
+            return StatusLevel.RED
+        if change_pct >= 5 or flood_months >= 1:
+            return StatusLevel.AMBER
+        return StatusLevel.GREEN
+
+    @staticmethod
+    def _compute_trend(monthly_vv: list[float]) -> TrendDirection:
+        valid = [v for v in monthly_vv if v != 0.0]
+        if len(valid) < 4:
+            return TrendDirection.STABLE
+        mid = len(valid) // 2
+        first_half = np.mean(valid[:mid])
+        second_half = np.mean(valid[mid:])
+        diff = abs(second_half - first_half)
+        if diff < 1.0:
+            return TrendDirection.STABLE
+        if second_half > first_half:
+            return TrendDirection.IMPROVING
+        return TrendDirection.DETERIORATING
+
+    @staticmethod
+    def _build_chart_data(
+        current_monthly: list[float],
+        baseline_monthly: list[float],
+        time_range: TimeRange,
+    ) -> dict[str, Any]:
+        year = time_range.end.year
+        n = len(current_monthly)
+        dates = [f"{year}-{m + 1:02d}" for m in range(n)]
+        values = [round(v, 2) for v in current_monthly]
+        b_mean = [round(v, 2) for v in baseline_monthly[:n]] if baseline_monthly else []
+        b_min = [round(v - 2.0, 2) for v in b_mean]
+        b_max = [round(v + 2.0, 2) for v in b_mean]
+
+        return {
+            "dates": dates,
+            "values": values,
+            "baseline_mean": b_mean,
+            "baseline_min": b_min,
+            "baseline_max": b_max,
+            "label": "VV Backscatter (dB)",
+        }
+
+    @staticmethod
+    def _write_change_raster(current_path: str, baseline_path: str, output_path: str) -> None:
+        """Write a single-band GeoTIFF of VV change (current_mean - baseline_mean)."""
+        with rasterio.open(current_path) as csrc:
+            c_months = csrc.count // 2
+            c_vv = [csrc.read(m * 2 + 1).astype(np.float32) for m in range(c_months)]
+            c_mean = np.nanmean(np.stack(c_vv), axis=0)
+            profile = csrc.profile.copy()
+
+        with rasterio.open(baseline_path) as bsrc:
+            b_months = bsrc.count // 2
+            b_vv = [bsrc.read(m * 2 + 1).astype(np.float32) for m in range(b_months)]
+            b_mean = np.nanmean(np.stack(b_vv), axis=0)
+
+        change = c_mean - b_mean
+        profile.update(count=1, dtype="float32")
+        with rasterio.open(output_path, "w", **profile) as dst:
+            dst.write(change, 1)
+
+    def _insufficient_data(self, aoi: AOI, time_range: TimeRange) -> IndicatorResult:
+        """Return result when no Sentinel-1 data is available."""
+        return IndicatorResult(
+            indicator_id=self.id,
+            headline="Insufficient SAR data for this area and time period",
+            status=StatusLevel.GREEN,
+            trend=TrendDirection.STABLE,
+            confidence=ConfidenceLevel.LOW,
+            map_layer_path="",
+            chart_data={"dates": [], "values": [], "label": "VV Backscatter (dB)"},
+            data_source="placeholder",
+            summary=(
+                "No Sentinel-1 GRD scenes were available for the requested "
+                "area and time period. SAR coverage over parts of East Africa "
+                "is inconsistent."
+            ),
+            methodology="Sentinel-1 GRD — no data available for processing.",
+            limitations=["No SAR data available. This indicator was skipped."],
+        )
+
+    def _fallback(self, aoi: AOI, time_range: TimeRange) -> IndicatorResult:
+        return self._insufficient_data(aoi, time_range)
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `pytest tests/test_indicator_sar.py -v`
+Expected: ALL PASS (4 tests).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add app/indicators/sar.py tests/test_indicator_sar.py
+git commit -m "feat: add SAR backscatter indicator with change detection and flood mapping"
+```
+
+---
+
+### Task 3: Implement built-up settlement extent indicator
+
+**Files:**
+- Create: `app/indicators/buildup.py`
+- Create: `tests/test_indicator_buildup.py`
+
+- [ ] **Step 1: Write failing tests for built-up indicator**
+
+Create `tests/test_indicator_buildup.py`:
+
+```python
+"""Tests for app.indicators.buildup — built-up extent via NDBI from 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_ndbi_tif(path: str, n_months: int = 12, buildup_fraction: float = 0.15):
+    """Create synthetic NDBI GeoTIFF. Values > 0 with low NDVI = built-up."""
+    rng = np.random.default_rng(55)
+    data = np.zeros((n_months, 10, 10), dtype=np.float32)
+    for m in range(n_months):
+        vals = rng.normal(-0.15, 0.2, (10, 10))
+        buildup_mask = rng.random((10, 10)) < buildup_fraction
+        vals[buildup_mask] = rng.uniform(0.05, 0.4, buildup_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_buildup_process_returns_result(test_aoi, test_time_range):
+    """BuiltupIndicator.process() returns a valid IndicatorResult."""
+    from app.indicators.buildup import BuiltupIndicator
+
+    indicator = BuiltupIndicator()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        ndbi_path = os.path.join(tmpdir, "ndbi.tif")
+        rgb_path = os.path.join(tmpdir, "rgb.tif")
+        _mock_ndbi_tif(ndbi_path)
+        _mock_rgb_tif(rgb_path)
+
+        mock_cube = MagicMock()
+
+        def fake_download(path, **kwargs):
+            import shutil
+            if "ndbi" in path or "buildup" in path:
+                shutil.copy(ndbi_path, path)
+            else:
+                shutil.copy(rgb_path, path)
+
+        mock_cube.download = MagicMock(side_effect=fake_download)
+
+        with patch("app.indicators.buildup.get_connection"), \
+             patch("app.indicators.buildup.build_buildup_graph", return_value=mock_cube), \
+             patch("app.indicators.buildup.build_true_color_graph", return_value=mock_cube):
+            result = await indicator.process(test_aoi, test_time_range)
+
+    assert result.indicator_id == "buildup"
+    assert result.status in (StatusLevel.GREEN, StatusLevel.AMBER, StatusLevel.RED)
+    assert result.data_source == "satellite"
+    assert "NDBI" in result.methodology or "built-up" in result.methodology.lower()
+    assert len(result.chart_data.get("dates", [])) > 0
+
+
+@pytest.mark.asyncio
+async def test_buildup_falls_back_on_failure(test_aoi, test_time_range):
+    """BuiltupIndicator falls back gracefully when openEO fails."""
+    from app.indicators.buildup import BuiltupIndicator
+
+    indicator = BuiltupIndicator()
+
+    with patch("app.indicators.buildup.get_connection", side_effect=Exception("CDSE down")):
+        result = await indicator.process(test_aoi, test_time_range)
+
+    assert result.indicator_id == "buildup"
+    assert result.data_source == "placeholder"
+
+
+def test_buildup_compute_stats():
+    """_compute_stats() extracts built-up fraction from NDBI raster."""
+    from app.indicators.buildup import BuiltupIndicator
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        path = os.path.join(tmpdir, "ndbi.tif")
+        _mock_ndbi_tif(path, n_months=12, buildup_fraction=0.2)
+        stats = BuiltupIndicator._compute_stats(path)
+
+    assert "monthly_buildup_fractions" in stats
+    assert len(stats["monthly_buildup_fractions"]) == 12
+    assert "overall_buildup_fraction" in stats
+    assert 0 < stats["overall_buildup_fraction"] < 1
+    assert "valid_months" in stats
+
+
+def test_buildup_classify():
+    """_classify() maps change percentage to correct status."""
+    from app.indicators.buildup import BuiltupIndicator
+
+    assert BuiltupIndicator._classify(change_pct=5.0) == StatusLevel.GREEN
+    assert BuiltupIndicator._classify(change_pct=15.0) == StatusLevel.AMBER
+    assert BuiltupIndicator._classify(change_pct=35.0) == StatusLevel.RED
+    assert BuiltupIndicator._classify(change_pct=-25.0) == StatusLevel.AMBER
+    assert BuiltupIndicator._classify(change_pct=-35.0) == StatusLevel.RED
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `pytest tests/test_indicator_buildup.py -v`
+Expected: FAIL with `ModuleNotFoundError`.
+
+- [ ] **Step 3: Implement built-up indicator**
+
+Create `app/indicators/buildup.py`:
+
+```python
+"""Built-up / Settlement Extent Indicator — NDBI via CDSE openEO.
+
+Computes monthly NDBI composites from Sentinel-2 L2A, classifies built-up
+pixels (NDBI > 0 AND NDVI < 0.2), and tracks settlement extent change
+against a baseline period.
+"""
+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_buildup_graph, build_true_color_graph, _bbox_dict
+
+logger = logging.getLogger(__name__)
+
+BASELINE_YEARS = 3
+NDBI_THRESHOLD = 0.0  # NDBI > 0 = potential built-up
+
+
+class BuiltupIndicator(BaseIndicator):
+    id = "buildup"
+    name = "Settlement Extent"
+    category = "D11"
+    question = "Is settlement area changing?"
+    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("Built-up 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_buildup_")
+
+        current_cube = build_buildup_graph(
+            conn=conn, bbox=bbox,
+            temporal_extent=[current_start, current_end],
+            resolution_m=RESOLUTION_M,
+        )
+        baseline_cube = build_buildup_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, "ndbi_current.tif")
+        baseline_path = os.path.join(results_dir, "ndbi_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_buildup_fraction"]
+        baseline_frac = baseline_stats["overall_buildup_fraction"]
+
+        # Convert fractions to area using AOI size
+        aoi_ha = aoi.area_km2 * 100  # km² → hectares
+        current_ha = current_frac * aoi_ha
+        baseline_ha = baseline_frac * aoi_ha
+
+        if baseline_frac > 0:
+            change_pct = ((current_frac - baseline_frac) / baseline_frac) * 100
+        else:
+            change_pct = 100.0 if current_frac > 0 else 0.0
+
+        status = self._classify(change_pct)
+        trend = self._compute_trend(change_pct)
+        confidence = (
+            ConfidenceLevel.HIGH if current_stats["valid_months"] >= 6
+            else ConfidenceLevel.MODERATE if current_stats["valid_months"] >= 3
+            else ConfidenceLevel.LOW
+        )
+
+        chart_data = self._build_chart_data(
+            current_stats["monthly_buildup_fractions"],
+            baseline_stats["monthly_buildup_fractions"],
+            time_range,
+            aoi_ha,
+        )
+
+        # Headline
+        if abs(change_pct) < 10:
+            headline = f"Built-up extent stable at approximately {current_ha:.0f} ha"
+        elif change_pct > 0:
+            headline = f"Settlement area expanded {change_pct:.0f}% ({baseline_ha:.0f} → {current_ha:.0f} ha) compared to baseline"
+        else:
+            headline = f"Potential settlement contraction: {abs(change_pct):.0f}% decrease in built-up area"
+
+        # Write change raster for map rendering
+        change_map_path = os.path.join(results_dir, "buildup_change.tif")
+        self._write_change_raster(current_path, baseline_path, change_map_path)
+
+        self._spatial_data = SpatialData(
+            map_type="raster",
+            label="Built-up Change",
+            colormap="PiYG",
+            vmin=-1,
+            vmax=1,
+        )
+        self._indicator_raster_path = change_map_path
+        self._render_band = 1
+
+        return IndicatorResult(
+            indicator_id=self.id,
+            headline=headline,
+            status=status,
+            trend=trend,
+            confidence=confidence,
+            map_layer_path=change_map_path,
+            chart_data=chart_data,
+            data_source="satellite",
+            summary=(
+                f"Built-up area covers {current_frac*100:.1f}% of the AOI "
+                f"({current_ha:.0f} ha) compared to {baseline_frac*100:.1f}% baseline "
+                f"({baseline_ha:.0f} ha), a {change_pct:+.1f}% change. "
+                f"Pixel-level NDBI analysis at {RESOLUTION_M}m resolution."
+            ),
+            methodology=(
+                f"Sentinel-2 L2A pixel-level NDBI = (B11 − B08) / (B11 + B08). "
+                f"Built-up classified as NDBI > {NDBI_THRESHOLD}. "
+                f"Cloud-masked using SCL band. "
+                f"Monthly median composites at {RESOLUTION_M}m. "
+                f"Baseline: {BASELINE_YEARS}-year built-up extent. "
+                f"Processed via CDSE openEO."
+            ),
+            limitations=[
+                f"Resampled to {RESOLUTION_M}m — detects settlement extent, not individual buildings.",
+                "NDBI may confuse bare rock/sand with built-up in arid landscapes.",
+                "Seasonal vegetation cycles can cause false positives at settlement fringes.",
+                "For building-level analysis, the SR4S pipeline (GPU-dependent) would be needed.",
+            ],
+        )
+
+    @staticmethod
+    def _compute_stats(tif_path: str) -> dict[str, Any]:
+        """Extract monthly built-up fraction from NDBI GeoTIFF.
+
+        Built-up = NDBI > 0 (simplified; full pipeline would also check NDVI < 0.2
+        but the graph builder only outputs NDBI).
+        """
+        with rasterio.open(tif_path) as src:
+            n_bands = src.count
+            monthly_fractions: list[float] = []
+            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:
+                    buildup_pixels = np.sum(valid > NDBI_THRESHOLD)
+                    frac = float(buildup_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_buildup_fractions": monthly_fractions,
+            "overall_buildup_fraction": overall,
+            "valid_months": max(valid_months, len(monthly_fractions)),
+            "peak_buildup_band": peak_band,
+        }
+
+    @staticmethod
+    def _classify(change_pct: float) -> StatusLevel:
+        abs_change = abs(change_pct)
+        if abs_change < 10:
+            return StatusLevel.GREEN
+        if abs_change < 30:
+            return StatusLevel.AMBER
+        return StatusLevel.RED
+
+    @staticmethod
+    def _compute_trend(change_pct: float) -> TrendDirection:
+        if abs(change_pct) < 10:
+            return TrendDirection.STABLE
+        if change_pct > 30:
+            return TrendDirection.DETERIORATING  # rapid expansion = potential displacement
+        if change_pct < -10:
+            return TrendDirection.DETERIORATING  # contraction = potential destruction
+        return TrendDirection.STABLE
+
+    @staticmethod
+    def _build_chart_data(
+        current_monthly: list[float],
+        baseline_monthly: list[float],
+        time_range: TimeRange,
+        aoi_ha: float,
+    ) -> 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 * aoi_ha, 1) for v in current_monthly[:n]]
+        b_mean = [round(v * aoi_ha, 1) for v in baseline_monthly[:n]]
+        b_min = [round(max(v * aoi_ha - aoi_ha * 0.02, 0), 1) for v in baseline_monthly[:n]]
+        b_max = [round(v * aoi_ha + aoi_ha * 0.02, 1) for v in baseline_monthly[:n]]
+
+        return {
+            "dates": dates,
+            "values": values,
+            "baseline_mean": b_mean,
+            "baseline_min": b_min,
+            "baseline_max": b_max,
+            "label": "Built-up area (ha)",
+        }
+
+    @staticmethod
+    def _write_change_raster(current_path: str, baseline_path: str, output_path: str) -> None:
+        """Write single-band change raster: current built-up mask minus baseline."""
+        with rasterio.open(current_path) as csrc:
+            c_data = [csrc.read(b + 1).astype(np.float32) for b in range(csrc.count)]
+            c_mean = np.nanmean(np.stack(c_data), axis=0)
+            profile = csrc.profile.copy()
+
+        with rasterio.open(baseline_path) as bsrc:
+            b_data = [bsrc.read(b + 1).astype(np.float32) for b in range(bsrc.count)]
+            b_mean = np.nanmean(np.stack(b_data), axis=0)
+
+        # Built-up masks
+        c_buildup = (c_mean > NDBI_THRESHOLD).astype(np.float32)
+        b_buildup = (b_mean > NDBI_THRESHOLD).astype(np.float32)
+        change = c_buildup - b_buildup  # +1 = new, -1 = lost, 0 = no change
+
+        profile.update(count=1, dtype="float32")
+        with rasterio.open(output_path, "w", **profile) as dst:
+            dst.write(change, 1)
+
+    def _fallback(self, aoi: AOI, time_range: TimeRange) -> IndicatorResult:
+        rng = np.random.default_rng(11)
+        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"Settlement 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": "Built-up area (ha)",
+            },
+            data_source="placeholder",
+            summary="openEO processing unavailable. Showing placeholder values.",
+            methodology="Placeholder — no satellite data processed.",
+            limitations=["Data is synthetic. openEO backend was unreachable."],
+        )
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `pytest tests/test_indicator_buildup.py -v`
+Expected: ALL PASS (4 tests).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add app/indicators/buildup.py tests/test_indicator_buildup.py
+git commit -m "feat: add built-up settlement extent indicator via NDBI"
+```
+
+---
+
+### Task 4: Register new indicators
+
+**Files:**
+- Modify: `app/indicators/__init__.py`
+
+- [ ] **Step 1: Add imports and register both new indicators**
+
+Add to the end of the import block in `app/indicators/__init__.py`:
+
+```python
+from app.indicators.sar import SarIndicator
+from app.indicators.buildup import BuiltupIndicator
+```
+
+Add to the end of the registration block:
+
+```python
+registry.register(SarIndicator())
+registry.register(BuiltupIndicator())
+```
+
+- [ ] **Step 2: Verify the registry lists the new indicators**
+
+Run: `python -c "from app.indicators import registry; ids = registry.list_ids(); assert 'sar' in ids; assert 'buildup' in ids; print('OK:', ids)"`
+Expected: Prints `OK:` followed by list including `sar` and `buildup`.
+
+- [ ] **Step 3: Run full test suite to verify no regressions**
+
+Run: `pytest tests/ -v --tb=short`
+Expected: All existing tests still pass, plus the new tests from Tasks 1-3.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add app/indicators/__init__.py
+git commit -m "feat: register SAR and built-up indicators in registry"
+```
+
+---
+
+### Task 5: Add composite score computation and overview weights
+
+**Files:**
+- Modify: `app/config.py`
+- Create: `app/outputs/overview.py`
+- Create: `tests/test_overview.py`
+
+- [ ] **Step 1: Add overview weights to config**
+
+Append to `app/config.py`:
+
+```python
+# Expert weights for the visual overview composite score.
+# Normalized to 1.0. Indicators not selected or skipped are excluded
+# and weights are re-normalized.
+OVERVIEW_WEIGHTS: dict[str, float] = {
+    "fires": 0.20,
+    "sar": 0.15,
+    "buildup": 0.15,
+    "ndvi": 0.12,
+    "water": 0.10,
+    "rainfall": 0.10,
+    "lst": 0.08,
+    "no2": 0.05,
+    "nightlights": 0.05,
+}
+```
+
+- [ ] **Step 2: Write failing tests for composite score**
+
+Create `tests/test_overview.py`:
+
+```python
+"""Tests for app.outputs.overview — composite score computation."""
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+
+import pytest
+
+from app.models import (
+    IndicatorResult,
+    StatusLevel,
+    TrendDirection,
+    ConfidenceLevel,
+)
+
+
+def _make_result(indicator_id: str, status: StatusLevel) -> IndicatorResult:
+    return IndicatorResult(
+        indicator_id=indicator_id,
+        headline="Test",
+        status=status,
+        trend=TrendDirection.STABLE,
+        confidence=ConfidenceLevel.HIGH,
+        map_layer_path="",
+        chart_data={},
+        summary="Test summary",
+        methodology="Test methodology",
+        limitations=[],
+    )
+
+
+def test_composite_score_all_green():
+    """All GREEN indicators produce score >= 70 and GREEN status."""
+    from app.outputs.overview import compute_composite_score
+
+    results = [
+        _make_result("ndvi", StatusLevel.GREEN),
+        _make_result("water", StatusLevel.GREEN),
+        _make_result("fires", StatusLevel.GREEN),
+    ]
+    score = compute_composite_score(results)
+
+    assert score["score"] == 100
+    assert score["status"] == "GREEN"
+    assert "GREEN" in score["headline"]
+
+
+def test_composite_score_mixed():
+    """Mix of statuses produces weighted score and correct status."""
+    from app.outputs.overview import compute_composite_score
+
+    results = [
+        _make_result("fires", StatusLevel.RED),     # weight 0.20, score 0
+        _make_result("ndvi", StatusLevel.GREEN),     # weight 0.12, score 100
+        _make_result("buildup", StatusLevel.AMBER),  # weight 0.15, score 50
+    ]
+    score = compute_composite_score(results)
+
+    # Renormalized weights: fires=0.20/0.47=0.426, ndvi=0.12/0.47=0.255, buildup=0.15/0.47=0.319
+    # Score = 0.426*0 + 0.255*100 + 0.319*50 = 0 + 25.5 + 15.96 = 41.5 → AMBER
+    assert 30 <= score["score"] <= 50
+    assert score["status"] == "AMBER"
+
+
+def test_composite_score_all_red():
+    """All RED indicators produce score < 40 and RED status."""
+    from app.outputs.overview import compute_composite_score
+
+    results = [
+        _make_result("fires", StatusLevel.RED),
+        _make_result("sar", StatusLevel.RED),
+    ]
+    score = compute_composite_score(results)
+
+    assert score["score"] == 0
+    assert score["status"] == "RED"
+
+
+def test_composite_score_empty():
+    """Empty results produce neutral score."""
+    from app.outputs.overview import compute_composite_score
+
+    score = compute_composite_score([])
+
+    assert score["score"] == 0
+    assert score["status"] == "RED"
+
+
+def test_composite_score_headline_mentions_drivers():
+    """Headline identifies the top contributing indicator(s) to concern."""
+    from app.outputs.overview import compute_composite_score
+
+    results = [
+        _make_result("fires", StatusLevel.RED),
+        _make_result("ndvi", StatusLevel.GREEN),
+        _make_result("water", StatusLevel.GREEN),
+    ]
+    score = compute_composite_score(results)
+
+    assert "fires" in score["headline"].lower() or "fire" in score["headline"].lower()
+
+
+def test_write_overview_score_json():
+    """write_overview_score() writes valid JSON to disk."""
+    from app.outputs.overview import compute_composite_score, write_overview_score
+
+    results = [
+        _make_result("ndvi", StatusLevel.GREEN),
+        _make_result("fires", StatusLevel.AMBER),
+    ]
+    score_data = compute_composite_score(results)
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        path = os.path.join(tmpdir, "overview_score.json")
+        write_overview_score(score_data, path)
+
+        assert os.path.exists(path)
+        with open(path) as f:
+            loaded = json.load(f)
+        assert loaded["score"] == score_data["score"]
+        assert loaded["status"] == score_data["status"]
+```
+
+- [ ] **Step 3: Run tests to verify they fail**
+
+Run: `pytest tests/test_overview.py -v`
+Expected: FAIL with `ModuleNotFoundError`.
+
+- [ ] **Step 4: Implement overview module**
+
+Create `app/outputs/overview.py`:
+
+```python
+"""Visual overview — composite score computation and overview outputs."""
+from __future__ import annotations
+
+import json
+from typing import Any, Sequence
+
+from app.config import OVERVIEW_WEIGHTS
+from app.models import IndicatorResult, StatusLevel
+
+_STATUS_SCORES = {
+    StatusLevel.GREEN: 100,
+    StatusLevel.AMBER: 50,
+    StatusLevel.RED: 0,
+}
+
+# Display names for headline generation
+_INDICATOR_NAMES = {
+    "fires": "fires",
+    "sar": "SAR ground change",
+    "buildup": "settlement expansion",
+    "ndvi": "vegetation decline",
+    "water": "water extent change",
+    "rainfall": "rainfall anomaly",
+    "lst": "thermal stress",
+    "no2": "air quality",
+    "nightlights": "nighttime lights",
+}
+
+
+def compute_composite_score(results: Sequence[IndicatorResult]) -> dict[str, Any]:
+    """Compute weighted composite score from indicator results.
+
+    Returns a dict with: score (0-100), status (GREEN/AMBER/RED),
+    headline, weights_used, per_indicator breakdown.
+    """
+    if not results:
+        return {
+            "score": 0,
+            "status": "RED",
+            "headline": "Area conditions: RED (score 0/100) — no indicators available",
+            "weights_used": {},
+            "per_indicator": {},
+        }
+
+    # Gather scores for completed indicators (exclude status=None-like edge cases)
+    per_indicator: dict[str, dict] = {}
+    active_weights: dict[str, float] = {}
+
+    for result in results:
+        ind_id = result.indicator_id
+        weight = OVERVIEW_WEIGHTS.get(ind_id, 0.05)
+        ind_score = _STATUS_SCORES.get(result.status, 50)
+        per_indicator[ind_id] = {
+            "status": result.status.value.upper(),
+            "score": ind_score,
+        }
+        active_weights[ind_id] = weight
+
+    # Re-normalize weights
+    total_weight = sum(active_weights.values())
+    if total_weight == 0:
+        total_weight = 1.0
+    norm_weights = {k: v / total_weight for k, v in active_weights.items()}
+
+    # Weighted average
+    composite = sum(
+        norm_weights[ind_id] * per_indicator[ind_id]["score"]
+        for ind_id in norm_weights
+    )
+    composite = round(composite)
+
+    # Classify
+    if composite >= 70:
+        status = "GREEN"
+    elif composite >= 40:
+        status = "AMBER"
+    else:
+        status = "RED"
+
+    # Headline: identify top 1-2 drivers of concern
+    headline = _build_headline(composite, status, per_indicator, norm_weights)
+
+    return {
+        "score": composite,
+        "status": status,
+        "headline": headline,
+        "weights_used": {k: round(v, 3) for k, v in norm_weights.items()},
+        "per_indicator": per_indicator,
+    }
+
+
+def _build_headline(
+    score: int, status: str,
+    per_indicator: dict, weights: dict,
+) -> str:
+    """Build a human-readable headline identifying concern drivers."""
+    if status == "GREEN":
+        return f"Area conditions: GREEN (score {score}/100) — stable across all indicators"
+
+    # Find indicators contributing most to non-GREEN score
+    # Impact = weight * (100 - indicator_score) — higher means more concern
+    impacts = []
+    for ind_id, data in per_indicator.items():
+        if data["score"] < 100:
+            impact = weights.get(ind_id, 0) * (100 - data["score"])
+            name = _INDICATOR_NAMES.get(ind_id, ind_id)
+            impacts.append((impact, name))
+
+    impacts.sort(reverse=True)
+    drivers = [name for _, name in impacts[:2]]
+    driver_str = " and ".join(drivers) if drivers else "multiple indicators"
+
+    return f"Area conditions: {status} (score {score}/100) — {driver_str} drive concern"
+
+
+def write_overview_score(score_data: dict[str, Any], output_path: str) -> None:
+    """Write composite score data to a JSON file."""
+    with open(output_path, "w") as f:
+        json.dump(score_data, f, indent=2)
+```
+
+- [ ] **Step 5: Run tests to verify they pass**
+
+Run: `pytest tests/test_overview.py -v`
+Expected: ALL PASS (6 tests).
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add app/config.py app/outputs/overview.py tests/test_overview.py
+git commit -m "feat: add composite score computation with expert weights"
+```
+
+---
+
+### Task 6: Add overview map renderer
+
+**Files:**
+- Modify: `app/outputs/maps.py`
+- Modify: `tests/test_overview.py`
+
+- [ ] **Step 1: Write failing test for `render_overview_map`**
+
+Append to `tests/test_overview.py`:
+
+```python
+def test_render_overview_map():
+    """render_overview_map() produces a PNG file."""
+    import rasterio
+    from rasterio.transform import from_bounds
+    import numpy as np
+    from app.models import AOI
+    from app.outputs.maps import render_overview_map
+
+    aoi = AOI(name="Test Khartoum", bbox=[32.45, 15.65, 32.65, 15.8])
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Create synthetic true-color GeoTIFF
+        rgb_path = os.path.join(tmpdir, "rgb.tif")
+        rng = np.random.default_rng(43)
+        data = rng.integers(500, 1500, (3, 10, 10), dtype=np.uint16)
+        with rasterio.open(
+            rgb_path, "w", driver="GTiff", height=10, width=10, count=3,
+            dtype="uint16", crs="EPSG:4326",
+            transform=from_bounds(32.45, 15.65, 32.65, 15.8, 10, 10), nodata=0,
+        ) as dst:
+            for i in range(3):
+                dst.write(data[i], i + 1)
+
+        output_path = os.path.join(tmpdir, "overview_map.png")
+        render_overview_map(
+            true_color_path=rgb_path,
+            aoi=aoi,
+            output_path=output_path,
+            title="Test Khartoum — Satellite Overview",
+            date_range="2025-03 to 2026-03",
+        )
+
+        assert os.path.exists(output_path)
+        assert os.path.getsize(output_path) > 1000  # Not an empty/trivial file
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `pytest tests/test_overview.py::test_render_overview_map -v`
+Expected: FAIL with `ImportError`.
+
+- [ ] **Step 3: Implement `render_overview_map` in `app/outputs/maps.py`**
+
+Add at the end of `app/outputs/maps.py`:
+
+```python
+def render_overview_map(
+    *,
+    true_color_path: str,
+    aoi: AOI,
+    output_path: str,
+    title: str = "",
+    date_range: str = "",
+) -> None:
+    """Render a standalone true-color satellite overview (no indicator overlay).
+
+    Parameters
+    ----------
+    true_color_path:
+        Path to a 3-band (R,G,B) GeoTIFF.
+    aoi:
+        AOI for bounding box overlay and title.
+    output_path:
+        Path to write the output PNG.
+    title:
+        Title text rendered above the image.
+    date_range:
+        Date range annotation rendered below the title.
+    """
+    import rasterio
+
+    fig, ax = plt.subplots(figsize=(8, 6), dpi=200, facecolor=SHELL)
+    ax.set_facecolor(SHELL)
+
+    with rasterio.open(true_color_path) as src:
+        rgb = src.read([1, 2, 3]).astype(np.float32)
+        extent = [src.bounds.left, src.bounds.right, src.bounds.bottom, src.bounds.top]
+
+    # Sentinel-2 reflectance scaling
+    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=extent, aspect="auto")
+
+    # AOI outline
+    _draw_aoi_rect(ax, aoi, INK)
+
+    # Title and date range
+    if title:
+        ax.set_title(title, fontsize=10, color=INK, fontweight="bold", pad=8)
+    if date_range:
+        ax.text(
+            0.5, -0.05, date_range,
+            transform=ax.transAxes, ha="center", fontsize=7, color=INK_MUTED,
+        )
+
+    ax.set_xlim(extent[0], extent[1])
+    ax.set_ylim(extent[2], extent[3])
+    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 4: Run test to verify it passes**
+
+Run: `pytest tests/test_overview.py -v`
+Expected: ALL PASS (7 tests).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add app/outputs/maps.py tests/test_overview.py
+git commit -m "feat: add standalone true-color overview map renderer"
+```
+
+---
+
+### Task 7: Integrate visual overview into the worker pipeline
+
+**Files:**
+- Modify: `app/worker.py`
+
+- [ ] **Step 1: Add overview post-processing to `process_job` in `app/worker.py`**
+
+Add the overview import at the top of `app/worker.py` (after existing imports):
+
+```python
+from app.outputs.overview import compute_composite_score, write_overview_score
+from app.outputs.maps import render_overview_map
+```
+
+Then, in the `process_job` function, insert the following block **after** the summary map generation (after line 148: `output_files.append(summary_map_path)`) and **before** the PDF report generation (before line 151: `report_path = ...`):
+
+```python
+        # --- Visual Overview ---
+        overview_score = compute_composite_score(job.results)
+
+        overview_score_path = os.path.join(results_dir, "overview_score.json")
+        write_overview_score(overview_score, overview_score_path)
+        output_files.append(overview_score_path)
+
+        # Overview map: reuse true-color from any raster indicator, or skip
+        overview_map_path = os.path.join(results_dir, "overview_map.png")
+        true_color_path = None
+        for ind_id in job.request.indicator_ids:
+            ind_obj = registry.get(ind_id)
+            tc = getattr(ind_obj, '_true_color_path', None)
+            if tc and os.path.exists(tc):
+                true_color_path = tc
+                break
+
+        if true_color_path:
+            render_overview_map(
+                true_color_path=true_color_path,
+                aoi=job.request.aoi,
+                output_path=overview_map_path,
+                title=f"{job.request.aoi.name} — Satellite Overview",
+                date_range=f"{job.request.time_range.start} to {job.request.time_range.end}",
+            )
+            output_files.append(overview_map_path)
+```
+
+- [ ] **Step 2: Update `generate_pdf_report` call to pass overview data**
+
+Replace the existing `generate_pdf_report(...)` call (around line 151-159) with:
+
+```python
+        # Generate PDF report
+        report_path = os.path.join(results_dir, "report.pdf")
+        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,
+            overview_score=overview_score,
+            overview_map_path=overview_map_path if true_color_path else "",
+        )
+        output_files.append(report_path)
+```
+
+- [ ] **Step 3: Run existing worker test to verify no regressions**
+
+Run: `pytest tests/test_worker.py -v --tb=short`
+Expected: PASS (the worker test may need a minor mock update — if it fails, check that `compute_composite_score` doesn't break on mock results).
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add app/worker.py
+git commit -m "feat: integrate visual overview into worker pipeline"
+```
+
+---
+
+### Task 8: Add overview page and summary table to PDF report
+
+**Files:**
+- Modify: `app/outputs/report.py`
+
+- [ ] **Step 1: Update `generate_pdf_report` signature to accept overview data**
+
+In `app/outputs/report.py`, update the function signature (around line 224):
+
+```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,
+    overview_score: dict | None = None,
+    overview_map_path: str = "",
+) -> None:
+```
+
+- [ ] **Step 2: Add overview page to the story, after the title block and before "How to Read"**
+
+Insert the following after the title block's horizontal rule (after line ~307, the `story.append(Spacer(1, 6 * mm))` line that follows the `HRFlowable`):
+
+```python
+    # ------------------------------------------------------------------ #
+    #  Visual Overview                                                    #
+    # ------------------------------------------------------------------ #
+    if overview_score:
+        story.append(Paragraph("Area Overview", styles["section_heading"]))
+
+        # Overview map (full width)
+        if overview_map_path and os.path.exists(overview_map_path):
+            from reportlab.platypus import Image
+            img = Image(overview_map_path, width=14 * cm, height=10.5 * cm)
+            img.hAlign = "CENTER"
+            story.append(img)
+            story.append(Spacer(1, 3 * mm))
+
+        # Composite score badge + headline
+        composite_status_enum = {
+            "GREEN": StatusLevel.GREEN,
+            "AMBER": StatusLevel.AMBER,
+            "RED": StatusLevel.RED,
+        }.get(overview_score.get("status", "RED"), StatusLevel.RED)
+
+        badge = _status_badge_table(composite_status_enum, styles)
+        headline = Paragraph(
+            overview_score.get("headline", ""),
+            styles["indicator_headline"],
+        )
+        row = Table(
+            [[badge, headline]],
+            colWidths=[2.2 * cm, None],
+        )
+        row.setStyle(TableStyle([
+            ("VALIGN", (0, 0), (-1, -1), "MIDDLE"),
+            ("LEFTPADDING", (1, 0), (1, 0), 8),
+            ("TOPPADDING", (0, 0), (-1, -1), 0),
+            ("BOTTOMPADDING", (0, 0), (-1, -1), 0),
+        ]))
+        story.append(row)
+        story.append(Spacer(1, 4 * mm))
+
+        # Summary table: all indicators in compact grid
+        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>Headline</b>", styles["body"]),
+        ]
+        summary_rows = [summary_header]
+        for result in results:
+            label = _indicator_label(result.indicator_id)
+            status_color = STATUS_COLORS[result.status]
+            status_cell = Paragraph(
+                f'<font color="white"><b>{STATUS_LABELS[result.status]}</b></font>',
+                ParagraphStyle(
+                    "ov_badge",
+                    fontName="Helvetica-Bold",
+                    fontSize=7,
+                    textColor=colors.white,
+                    alignment=TA_CENTER,
+                ),
+            )
+            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(result.headline[:80], styles["body_muted"]),
+            ])
+
+        ov_col_w = (PAGE_W - 2 * MARGIN)
+        ov_table = Table(
+            summary_rows,
+            colWidths=[ov_col_w * 0.15, ov_col_w * 0.10, ov_col_w * 0.12, ov_col_w * 0.13, ov_col_w * 0.50],
+        )
+        ov_ts = TableStyle([
+            ("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#E8E6E0")),
+            ("ROWBACKGROUNDS", (0, 1), (-1, -1), [colors.white, colors.HexColor(_SHELL_HEX)]),
+            ("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),
+            ("RIGHTPADDING", (0, 0), (-1, -1), 4),
+            ("VALIGN", (0, 0), (-1, -1), "MIDDLE"),
+            ("ALIGN", (1, 1), (1, -1), "CENTER"),
+        ])
+        for row_idx, result in enumerate(results, start=1):
+            ov_ts.add("BACKGROUND", (1, row_idx), (1, row_idx), STATUS_COLORS[result.status])
+        ov_table.setStyle(ov_ts)
+        story.append(ov_table)
+
+        story.append(Spacer(1, 6 * mm))
+        story.append(HRFlowable(width="100%", thickness=0.5, color=colors.HexColor("#D8D5CF")))
+        story.append(Spacer(1, 4 * mm))
+```
+
+- [ ] **Step 3: Run report test to verify no regressions**
+
+Run: `pytest tests/test_report.py -v --tb=short`
+Expected: PASS. The existing test passes `overview_score=None` by default (keyword arg defaults to None), so it should still work.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add app/outputs/report.py
+git commit -m "feat: add overview page with composite score and summary table to PDF report"
+```
+
+---
+
+### Task 9: Update display names and add overview outputs to package
+
+**Files:**
+- Modify: `app/outputs/report.py` (display names)
+- Modify: `app/outputs/package.py` (no changes needed — already packages all `output_files`)
+
+- [ ] **Step 1: Add display names for new indicators**
+
+In `app/outputs/report.py`, update the `_DISPLAY_NAMES` dict (around line 28-31):
+
+```python
+_DISPLAY_NAMES: dict[str, str] = {
+    "no2": "NO2",
+    "lst": "LST",
+    "sar": "SAR Backscatter",
+    "buildup": "Settlement Extent",
+}
+```
+
+- [ ] **Step 2: Verify package already includes overview files**
+
+The worker already appends `overview_score_path` and `overview_map_path` to `output_files` (from Task 7), and `create_data_package` iterates `output_files`. No changes needed to `package.py`.
+
+Verify: `grep -n "output_files.append" app/worker.py` — confirm `overview_score_path` and `overview_map_path` are listed.
+
+- [ ] **Step 3: Run full test suite**
+
+Run: `pytest tests/ -v --tb=short`
+Expected: ALL PASS.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add app/outputs/report.py
+git commit -m "feat: add display names for SAR and built-up indicators"
+```
+
+---
+
+### Task 10: Full integration verification
+
+- [ ] **Step 1: Count total tests**
+
+Run: `pytest tests/ -v --tb=short 2>&1 | tail -5`
+Expected: All tests pass. Should be ~135+ tests (121 existing + ~14 new).
+
+- [ ] **Step 2: Verify new indicators appear in API catalogue**
+
+Run: `python -c "
+from app.indicators import registry
+cat = registry.catalogue()
+ids = [m.id for m in cat]
+print('Registered:', ids)
+assert 'sar' in ids, 'SAR not registered'
+assert 'buildup' in ids, 'Built-up not registered'
+print('Phase C indicators registered OK')
+"`
+Expected: Prints registered indicator list including `sar` and `buildup`.
+
+- [ ] **Step 3: Verify imports are clean**
+
+Run: `python -c "
+from app.indicators.sar import SarIndicator
+from app.indicators.buildup import BuiltupIndicator
+from app.outputs.overview import compute_composite_score, write_overview_score
+from app.outputs.maps import render_overview_map
+print('All Phase C imports OK')
+"`
+Expected: Prints `All Phase C imports OK`.
+
+- [ ] **Step 4: Final commit (if any stray changes)**
+
+```bash
+git status
+# If clean, no commit needed.
+# If there are changes:
+git add -A && git commit -m "chore: Phase C integration cleanup"
+```

docs/superpowers/specs/2026-03-31-phase-c-sar-buildup-overview-design.md

@@ -0,0 +1,291 @@
+# Phase C Design Spec — SAR Backscatter, Built-up Extent, Visual Overview
+
+**Date:** 2026-03-31
+**Status:** Approved
+**Depends on:** Phase A (openEO foundation), Phase B (indicator migration)
+
+## Summary
+
+Phase C adds two new satellite indicators (SAR backscatter, built-up extent) and a visual overview post-processing step. Both indicators follow the established openEO graph builder + raster indicator pattern from Phases A and B. The visual overview is a worker post-processing step (not an indicator) that synthesizes results into a composite score and true-color satellite snapshot.
+
+**Approach:** Two new `BaseIndicator` subclasses + post-processing in the worker pipeline + report enhancements.
+
+## Context
+
+### SR4S Heritage
+
+The built-up indicator is informed by the SR4S research pipeline (Super-Resolution for Conflict Settlement Monitoring), which uses OpenSR latent diffusion to upscale Sentinel-2 to 2.5m and U-Net building segmentation for settlement detection. SR4S requires GPU and cannot run on Aperture's current cpu-basic HF Space. The index-based NDBI approach adopted here answers the same question (settlement extent and change) at 10m resolution without GPU, trading building-level precision for operational feasibility.
+
+SR4S's validation methodology (Open Buildings V3, IOM DTM correlation) informs the thresholds and limitations documented below.
+
+### Architecture Fit
+
+Both new indicators follow the exact pattern established in Phase B:
+
+1. openEO graph builder in `openeo_client.py` → downloads GeoTIFF
+2. Indicator `process()` reads raster, computes zonal statistics, classifies status
+3. Sets `SpatialData(map_type="raster", vmin, vmax, colormap)` for map rendering
+4. Returns `IndicatorResult` with chart data (monthly arrays + baseline)
+
+The visual overview is a new post-processing step in the worker, alongside existing summary map, PDF report, and ZIP package generation.
+
+---
+
+## Indicator 1: SAR Backscatter (`sar`)
+
+### Data Source
+
+**Sentinel-1 GRD IW** via CDSE openEO (`SENTINEL1_GRD` collection). VV and VH polarizations, ascending orbit direction preferred for radiometric consistency.
+
+### Graph Builder: `build_sar_graph(bbox, temporal_extent, resolution)`
+
+- Load `SENTINEL1_GRD`, bands `VV` and `VH`
+- Filter by orbit direction: ascending
+- Convert linear backscatter to dB: `10 * log10(linear)`
+- Aggregate: monthly median composites
+- Resample to configurable resolution (default 100m via `config.RESOLUTION_M`)
+- Output: multi-band GeoTIFF (months × 2 polarizations, interleaved: VV_m1, VH_m1, VV_m2, VH_m2, ...)
+
+### Analysis
+
+The indicator splits monthly data into baseline (first half of time range) and analysis (second half) periods, consistent with all other indicators. Three analyses from the same monthly composites:
+
+**1. Change detection**
+- Mean VV backscatter (dB) in analysis period vs baseline period, per pixel
+- Percentage of AOI area with >3 dB change = "significant change area"
+
+**2. Time series monitoring**
+- Monthly mean VV and VH over AOI
+- Chart data: `dates` (YYYY-MM), `values` (monthly VV mean), `baseline_mean/min/max` arrays
+- Same chart renderer as all other monthly indicators
+
+**3. Flood / wet surface mapping**
+- Flag pixels where VV < baseline_mean - 2σ as potential inundation
+- Report: % of AOI flagged, number of anomalous months
+
+### Status Classification
+
+| Status | Condition |
+|--------|-----------|
+| GREEN | <5% area with significant change, no flood anomalies |
+| AMBER | 5–15% area changed OR 1–2 flood anomaly months |
+| RED | >15% area changed OR ≥3 flood anomaly months |
+
+### Trend
+
+- IMPROVING: Significant change area decreasing over analysis period
+- STABLE: No clear directional trend
+- DETERIORATING: Significant change area increasing over analysis period
+
+### Map Output
+
+- Raster: VV change (analysis mean - baseline mean, dB) overlaid on true-color
+- Colormap: `RdBu_r` (red = decrease / potential flood, blue = increase / potential construction)
+- `vmin=-6`, `vmax=6`
+- Label: "SAR VV Change (dB)"
+
+### Graceful Degradation
+
+- **No Sentinel-1 scenes available:** Return `IndicatorResult` with `status=None`, `confidence=LOW`, headline "Insufficient SAR data for this area and time period", methodology explaining the data gap. Do not fail the job.
+- **<3 months of data:** Proceed but set `confidence=LOW` and note in limitations.
+
+### Headline Examples
+
+- "SAR detects 12% ground surface change, 2 potential flood events"
+- "Stable backscatter conditions — no significant ground change detected"
+- "Insufficient SAR data for this area and time period"
+
+---
+
+## Indicator 2: Built-up / Settlement Extent (`buildup`)
+
+### Data Source
+
+**Sentinel-2 L2A** via CDSE openEO. Bands B04 (Red), B08 (NIR), B11 (SWIR), SCL (cloud mask). Same source as NDVI and MNDWI indicators, different band combination.
+
+### Graph Builder: `build_buildup_graph(bbox, temporal_extent, resolution)`
+
+- Load `SENTINEL2_L2A`, bands `B04`, `B08`, `B11`, `SCL`
+- Cloud mask using SCL classes 4, 5, 6 (vegetation, bare soil, water — same as existing graphs)
+- Compute per pixel:
+  - **NDBI** = (B11 - B08) / (B11 + B08)
+  - **NDVI** = (B08 - B04) / (B08 + B04)
+- Derive **built-up mask**: NDBI > 0 AND NDVI < 0.2
+  - Separates impervious surfaces from bare soil (high NDBI + moderate NDVI)
+- Aggregate: monthly median for NDBI continuous values, monthly built-up fraction from binary mask
+- Output: multi-band GeoTIFF with monthly NDBI values (one band per month). The binary built-up mask and NDVI are computed in the indicator's `process()` method from the downloaded NDBI + source bands, not in the openEO graph — this keeps the graph builder simple and consistent with the NDVI/MNDWI pattern.
+
+### Analysis
+
+The indicator splits monthly data into baseline (first half of time range) and analysis (second half) periods, consistent with all other indicators.
+
+**1. Settlement extent**
+- Built-up area (hectares) per month from binary mask
+- Baseline mean area vs analysis mean area
+
+**2. Change detection**
+- Percentage change in built-up fraction between baseline and analysis periods
+- Monthly time series with baseline band + mean line (same chart pattern)
+
+**3. Expansion mapping**
+- Pixels built-up in analysis but not baseline = new settlement
+- Pixels built-up in baseline but not analysis = destruction / abandonment
+- Report: net change in hectares, expansion %, contraction %
+
+### Status Classification
+
+| Status | Condition |
+|--------|-----------|
+| GREEN | Built-up area stable (< ±10% change from baseline) |
+| AMBER | 10–30% change (expansion or contraction) |
+| RED | >30% change — rapid urbanization or significant destruction |
+
+### Trend
+
+- IMPROVING: Stable or gradual growth consistent with baseline trajectory
+- STABLE: No significant change
+- DETERIORATING: Rapid expansion (potential displacement) or contraction (potential destruction)
+
+### Map Output
+
+- Raster: built-up change (analysis mask - baseline mask) overlaid on true-color
+- Colormap: `PiYG` (pink = new built-up, green = lost built-up, white = no change)
+- `vmin=-1`, `vmax=1`
+- Label: "Built-up Change"
+
+### Headline Examples
+
+- "Settlement area expanded 25% (320 → 400 ha) compared to baseline"
+- "Built-up extent stable at approximately 850 ha"
+- "Potential settlement contraction: 15% decrease in built-up area"
+
+### Limitations
+
+- 10m resolution detects settlement *extent*, not individual buildings
+- NDBI confuses bare rock/sand with built-up in arid landscapes — the NDVI < 0.2 filter mitigates but doesn't eliminate this
+- Seasonal vegetation cycles can cause false positives at settlement fringes
+- For building-level analysis, the SR4S pipeline (GPU-dependent) would be needed as a future upgrade
+
+---
+
+## Visual Overview (Post-processing Step)
+
+The visual overview is NOT an indicator. It is a post-processing step in the worker pipeline that runs after all indicators complete, alongside summary map, PDF report, and ZIP package generation.
+
+### Component A: Composite Score
+
+A single headline status (GREEN/AMBER/RED) with a numeric score (0–100) summarizing overall area conditions.
+
+**Expert weights** (normalized to 1.0):
+
+| Indicator | Weight | Rationale |
+|-----------|--------|-----------|
+| `fires` | 0.20 | Direct threat signal |
+| `sar` | 0.15 | Ground-truth change detection |
+| `buildup` | 0.15 | Settlement dynamics |
+| `ndvi` | 0.12 | Vegetation / food production |
+| `water` | 0.10 | Water availability |
+| `rainfall` | 0.10 | Climate conditions |
+| `lst` | 0.08 | Thermal stress |
+| `no2` | 0.05 | Atmospheric disruption |
+| `nightlights` | 0.05 | Economic activity proxy |
+
+**Scoring logic:**
+1. Map each completed indicator's status to a score: GREEN=100, AMBER=50, RED=0
+2. Indicators with `status=None` (skipped/degraded) are excluded
+3. Re-normalize weights across only the completed indicators
+4. Weighted average → composite score
+5. Composite thresholds: ≥70 = GREEN, 40–69 = AMBER, <40 = RED
+
+**Output file:** `results/{job_id}/overview_score.json`
+
+```json
+{
+  "score": 54,
+  "status": "AMBER",
+  "headline": "Area conditions: AMBER (score 54/100) — fires and settlement expansion drive concern",
+  "weights_used": {"fires": 0.20, "ndvi": 0.12, "buildup": 0.15},
+  "per_indicator": {"fires": {"status": "RED", "score": 0}, "ndvi": {"status": "GREEN", "score": 100}, "buildup": {"status": "AMBER", "score": 50}}
+}
+```
+
+**Headline generation:**
+- Identify the 1–2 indicators contributing most to a non-GREEN score
+- Template: "Area conditions: {STATUS} (score {N}/100) — {driver description}"
+
+### Component B: True-Color Satellite Snapshot
+
+A standalone cloud-free RGB composite of the AOI as visual context.
+
+**Implementation:**
+- Reuse the existing `build_true_color_graph()` from `openeo_client.py`
+- If any raster indicator (NDVI, water, LST, SAR, buildup) already downloaded a true-color GeoTIFF during this job, reuse it — no second download
+- If no raster indicator was selected, fetch true-color independently
+
+**Rendering:** New function `render_overview_map(true_color_path, aoi, output_path)` in `maps.py`:
+- Full-page true-color image (no indicator overlay)
+- AOI boundary rectangle
+- Title: "{AOI name} — Satellite Overview"
+- Date range annotation
+- Scale bar
+
+**Output file:** `results/{job_id}/overview_map.png`
+
+### Report Integration
+
+New first section in the PDF report, before individual indicator sections:
+
+1. **Overview page:**
+   - True-color satellite snapshot (full width)
+   - Composite score badge (large, colored: GREEN/AMBER/RED)
+   - One-line composite headline
+2. **Summary table:**
+   - All selected indicators in a compact grid: name, status badge, trend arrow, confidence, one-line headline
+3. **Individual indicator sections** follow as they do now
+
+### Worker Pipeline Changes
+
+In `worker.py`, after the indicator processing loop completes and before existing output generation:
+
+1. Compute composite score from collected `IndicatorResult` list
+2. Locate or fetch true-color GeoTIFF
+3. Render overview map via `render_overview_map()`
+4. Write `overview_score.json`
+5. Pass composite score + overview map path to `generate_pdf_report()`
+6. Include both in ZIP package
+
+---
+
+## Files Modified
+
+| File | Change |
+|------|--------|
+| `app/openeo_client.py` | Add `build_sar_graph()`, `build_buildup_graph()` |
+| `app/indicators/sar.py` | New file: SAR backscatter indicator |
+| `app/indicators/buildup.py` | New file: built-up extent indicator |
+| `app/indicators/__init__.py` | Register `sar` and `buildup` indicators |
+| `app/worker.py` | Add visual overview post-processing step |
+| `app/outputs/maps.py` | Add `render_overview_map()` |
+| `app/outputs/report.py` | Add overview page + summary table to PDF |
+| `app/outputs/package.py` | Include overview outputs in ZIP |
+| `app/config.py` | Add `OVERVIEW_WEIGHTS` dict |
+| `tests/test_indicator_sar.py` | New file: SAR indicator tests |
+| `tests/test_indicator_buildup.py` | New file: built-up indicator tests |
+| `tests/test_overview.py` | New file: composite score + overview tests |
+| `tests/test_openeo_client.py` | Add tests for new graph builders |
+
+## Dependencies
+
+No new Python packages required. All processing uses existing dependencies:
+- `openeo` — graph builders (already installed)
+- `rasterio` — GeoTIFF reading (already installed)
+- `numpy` — array math (already installed)
+- `matplotlib` / `cartopy` — map rendering (already installed)
+- `reportlab` — PDF generation (already installed)
+
+## Out of Scope
+
+- SR4S U-Net model integration (requires GPU upgrade)
+- User-configurable indicator weights (fixed expert weights for now)
+- SAR interferometry / InSAR (requires SLC data, not GRD)
+- Building footprint extraction