docs: add Phase A implementation plan — openEO NDVI pipeline

9-task plan covering: openeo dependency, config module, openEO client,
test fixtures, raster map renderer, NDVI indicator, worker integration,
and end-to-end smoke test. All tasks are TDD with exact code and commands.

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-a-openeo-ndvi-pipeline.md

@@ -0,0 +1,1564 @@
+# Phase A: openEO Client + NDVI Indicator + Raster Map Renderer — 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:** Prove the full CDSE openEO pipeline end-to-end — from processing graph submission through GeoTIFF download to raster-on-satellite-imagery map rendering in the PDF report — by implementing the NDVI vegetation indicator as the first openEO-powered indicator.
+
+**Architecture:** A new `app/openeo_client.py` manages CDSE authentication and exposes graph-builder functions that return GeoTIFFs. A new `app/indicators/ndvi.py` replaces the old scene-metadata vegetation indicator with pixel-level NDVI composites. The map renderer (`app/outputs/maps.py`) gains a new `render_raster_map()` function that overlays indicator rasters on a true-color Sentinel-2 composite. Resolution is configurable via `app/config.py`.
+
+**Tech Stack:** Python 3.11, openeo ≥0.28.0, rasterio, rioxarray, matplotlib, numpy
+
+**Spec:** `docs/superpowers/specs/2026-03-31-openeo-eo-upgrade-design.md`
+
+---
+
+## File Map
+
+| File | Action | Responsibility |
+|------|--------|----------------|
+| `app/config.py` | Create | Centralized configuration constants (resolution, AOI limits, openEO backend URL) |
+| `app/openeo_client.py` | Create | openEO connection management, authentication, generic graph execution |
+| `app/indicators/ndvi.py` | Create | NDVI vegetation indicator using openEO (replaces `vegetation.py`) |
+| `app/indicators/__init__.py` | Modify | Register `NdviIndicator`, keep `VegetationIndicator` as fallback |
+| `app/outputs/maps.py` | Modify | Add `render_raster_map()` for raster-on-true-color rendering |
+| `app/worker.py` | Modify | Pass true-color composite path to map renderer |
+| `Dockerfile` | Modify | Add `openeo` dependency, keep cartopy for now (Phase D removal) |
+| `pyproject.toml` | Modify | Add `openeo>=0.28.0` to dependencies |
+| `tests/test_config.py` | Create | Test configuration defaults and env overrides |
+| `tests/test_openeo_client.py` | Create | Test openEO graph builders with mocked connection |
+| `tests/test_indicator_ndvi.py` | Create | Test NDVI indicator processing with mocked openEO |
+| `tests/test_raster_maps.py` | Create | Test raster map rendering with sample GeoTIFFs |
+| `tests/fixtures/` | Create | Sample GeoTIFF files for unit tests |
+
+---
+
+### Task 1: Add `openeo` Dependency
+
+**Files:**
+- Modify: `pyproject.toml:6-26`
+- Modify: `Dockerfile:25-35`
+
+- [ ] **Step 1: Add openeo to pyproject.toml**
+
+In `pyproject.toml`, add `"openeo>=0.28.0"` to the dependencies list. In the dependencies array, after the `"planetary-computer>=1.0.0"` line, add:
+
+```toml
+    "openeo>=0.28.0",
+```
+
+- [ ] **Step 2: Add openeo to Dockerfile builder stage**
+
+In `Dockerfile`, in the second `RUN pip install` block (line 25-35), add `"openeo>=0.28.0"` after `"planetary-computer>=1.0.0"`:
+
+```dockerfile
+RUN pip install --no-cache-dir --prefer-binary \
+    "fastapi>=0.110.0" \
+    "uvicorn[standard]>=0.27.0" \
+    "aiosqlite>=0.20.0" \
+    "pydantic>=2.6.0" \
+    "httpx>=0.27.0" \
+    "pystac-client>=0.7.0" \
+    "stackstac>=0.5.0" \
+    "reportlab>=4.1.0" \
+    "tqdm>=4.66.0" \
+    "planetary-computer>=1.0.0" \
+    "openeo>=0.28.0"
+```
+
+- [ ] **Step 3: Install openeo locally**
+
+Run: `cd /Users/kmini/Github/Aperture && pip install "openeo>=0.28.0"`
+
+Expected: Installs successfully. The `openeo` package is pure Python with minimal native deps.
+
+- [ ] **Step 4: Verify import**
+
+Run: `cd /Users/kmini/Github/Aperture && python -c "import openeo; print(openeo.__version__)"`
+
+Expected: Prints version number (0.28.x or higher).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add pyproject.toml Dockerfile
+git commit -m "build: add openeo dependency for CDSE processing"
+```
+
+---
+
+### Task 2: Create Configuration Module
+
+**Files:**
+- Create: `app/config.py`
+- Create: `tests/test_config.py`
+
+- [ ] **Step 1: Write tests for config**
+
+Create `tests/test_config.py`:
+
+```python
+"""Tests for app.config — centralized configuration."""
+import os
+import pytest
+
+
+def test_default_resolution():
+    """Default resolution is 100m (free-tier HF Space)."""
+    from app.config import RESOLUTION_M
+    assert RESOLUTION_M == 100
+
+
+def test_default_max_aoi():
+    """Default max AOI is 500 km²."""
+    from app.config import MAX_AOI_KM2
+    assert MAX_AOI_KM2 == 500
+
+
+def test_default_openeo_backend():
+    """Default openEO backend is CDSE."""
+    from app.config import OPENEO_BACKEND
+    assert OPENEO_BACKEND == "openeo.dataspace.copernicus.eu"
+
+
+def test_resolution_env_override(monkeypatch):
+    """APERTURE_RESOLUTION_M env var overrides the default."""
+    monkeypatch.setenv("APERTURE_RESOLUTION_M", "20")
+    # Force reimport to pick up env var
+    import importlib
+    import app.config
+    importlib.reload(app.config)
+    assert app.config.RESOLUTION_M == 20
+    # Reset
+    monkeypatch.delenv("APERTURE_RESOLUTION_M", raising=False)
+    importlib.reload(app.config)
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_config.py -v`
+
+Expected: FAIL — `ModuleNotFoundError: No module named 'app.config'`
+
+- [ ] **Step 3: Create config module**
+
+Create `app/config.py`:
+
+```python
+"""Centralized configuration for Aperture."""
+from __future__ import annotations
+
+import os
+
+# Spatial resolution in meters for openEO processing.
+# 100m for free-tier HF Space (2GB RAM). Set to 10 or 20 for upgraded hardware.
+RESOLUTION_M: int = int(os.environ.get("APERTURE_RESOLUTION_M", "100"))
+
+# Maximum AOI size in km². Soft limit to prevent excessive processing.
+MAX_AOI_KM2: int = int(os.environ.get("APERTURE_MAX_AOI_KM2", "500"))
+
+# openEO backend URL.
+OPENEO_BACKEND: str = os.environ.get(
+    "OPENEO_BACKEND", "openeo.dataspace.copernicus.eu"
+)
+
+# CDSE OAuth2 credentials (set as secrets in HF Spaces).
+OPENEO_CLIENT_ID: str | None = os.environ.get("OPENEO_CLIENT_ID")
+OPENEO_CLIENT_SECRET: str | None = os.environ.get("OPENEO_CLIENT_SECRET")
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_config.py -v`
+
+Expected: All PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add app/config.py tests/test_config.py
+git commit -m "feat: add centralized config module with resolution and openEO settings"
+```
+
+---
+
+### Task 3: Create openEO Client Module
+
+**Files:**
+- Create: `app/openeo_client.py`
+- Create: `tests/test_openeo_client.py`
+
+- [ ] **Step 1: Write test for connection factory**
+
+Create `tests/test_openeo_client.py`:
+
+```python
+"""Tests for app.openeo_client — openEO connection and graph builders."""
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+import pytest
+
+
+def test_get_connection_creates_authenticated_connection():
+    """get_connection() connects to CDSE and authenticates."""
+    mock_conn = MagicMock()
+    with patch("openeo.connect", return_value=mock_conn) as mock_connect:
+        from app.openeo_client import get_connection
+        conn = get_connection()
+
+        mock_connect.assert_called_once_with("openeo.dataspace.copernicus.eu")
+        mock_conn.authenticate_oidc.assert_called_once()
+        assert conn is mock_conn
+
+
+def test_get_connection_reuses_cached():
+    """Subsequent calls return the same connection object."""
+    mock_conn = MagicMock()
+    with patch("openeo.connect", return_value=mock_conn):
+        from app.openeo_client import get_connection, _reset_connection
+        _reset_connection()  # Clear any cached connection
+        conn1 = get_connection()
+        conn2 = get_connection()
+        assert conn1 is conn2
+        _reset_connection()
+```
+
+- [ ] **Step 2: Write test for NDVI graph builder**
+
+Append to `tests/test_openeo_client.py`:
+
+```python
+def test_build_ndvi_graph():
+    """build_ndvi_graph() returns a datacube with NDVI computation."""
+    mock_conn = MagicMock()
+    mock_cube = MagicMock()
+    mock_conn.load_collection.return_value = mock_cube
+
+    # Mock the band operations
+    mock_b08 = MagicMock()
+    mock_b04 = MagicMock()
+    mock_cube.band.side_effect = lambda b: mock_b08 if b == "B08" else mock_b04
+    mock_ndvi = MagicMock()
+    mock_b08.__sub__ = MagicMock(return_value=MagicMock())
+    mock_b08.__add__ = MagicMock(return_value=MagicMock())
+    (mock_b08 - mock_b04).__truediv__ = MagicMock(return_value=mock_ndvi)
+
+    from app.openeo_client import build_ndvi_graph
+
+    bbox = {"west": 32.45, "south": 15.65, "east": 32.65, "north": 15.8}
+    result = build_ndvi_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 call_kwargs[1]["spatial_extent"] == bbox
+    assert "B04" in call_kwargs[1]["bands"]
+    assert "B08" in call_kwargs[1]["bands"]
+    assert "SCL" in call_kwargs[1]["bands"]
+
+
+def test_build_true_color_graph():
+    """build_true_color_graph() returns a datacube with RGB bands."""
+    mock_conn = MagicMock()
+    mock_cube = MagicMock()
+    mock_conn.load_collection.return_value = mock_cube
+
+    from app.openeo_client import build_true_color_graph
+
+    bbox = {"west": 32.45, "south": 15.65, "east": 32.65, "north": 15.8}
+    result = build_true_color_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
+    bands = call_kwargs[1]["bands"]
+    assert "B04" in bands
+    assert "B03" in bands
+    assert "B02" in bands
+```
+
+- [ ] **Step 3: Run tests to verify they fail**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_openeo_client.py -v`
+
+Expected: FAIL — `ModuleNotFoundError: No module named 'app.openeo_client'`
+
+- [ ] **Step 4: Implement openeo_client module**
+
+Create `app/openeo_client.py`:
+
+```python
+"""openEO connection management and processing graph builders.
+
+All heavy raster processing happens server-side on CDSE. This module
+defines the processing graphs and handles authentication. The returned
+datacubes are downloaded as GeoTIFFs by indicator code.
+"""
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import openeo
+
+from app.config import OPENEO_BACKEND, OPENEO_CLIENT_ID, OPENEO_CLIENT_SECRET
+
+logger = logging.getLogger(__name__)
+
+_connection: openeo.Connection | None = None
+
+
+def get_connection() -> openeo.Connection:
+    """Get or create an authenticated openEO connection to CDSE.
+
+    The connection is cached for reuse across indicator calls within a job.
+    """
+    global _connection
+    if _connection is not None:
+        return _connection
+
+    logger.info("Connecting to openEO backend: %s", OPENEO_BACKEND)
+    conn = openeo.connect(OPENEO_BACKEND)
+
+    if OPENEO_CLIENT_ID and OPENEO_CLIENT_SECRET:
+        conn.authenticate_oidc(
+            client_id=OPENEO_CLIENT_ID,
+            client_secret=OPENEO_CLIENT_SECRET,
+        )
+    else:
+        conn.authenticate_oidc()
+
+    _connection = conn
+    return conn
+
+
+def _reset_connection() -> None:
+    """Reset the cached connection (for testing)."""
+    global _connection
+    _connection = None
+
+
+def _bbox_dict(bbox: list[float]) -> dict[str, float]:
+    """Convert [min_lon, min_lat, max_lon, max_lat] to openEO spatial_extent."""
+    return {
+        "west": bbox[0],
+        "south": bbox[1],
+        "east": bbox[2],
+        "north": bbox[3],
+    }
+
+
+def build_ndvi_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 median NDVI composites.
+
+    Loads Sentinel-2 L2A, masks clouds using the SCL band, computes
+    NDVI = (B08 - B04) / (B08 + B04), and aggregates to monthly medians.
+
+    Returns an openEO DataCube (not yet executed).
+    """
+    cube = conn.load_collection(
+        collection_id="SENTINEL2_L2A",
+        spatial_extent=bbox,
+        temporal_extent=temporal_extent,
+        bands=["B04", "B08", "SCL"],
+    )
+
+    # Cloud mask: keep only vegetation, bare soil, water (SCL classes 4,5,6)
+    scl = cube.band("SCL")
+    cloud_mask = (scl == 4) | (scl == 5) | (scl == 6)
+    cube = cube.mask(~cloud_mask)
+
+    # NDVI
+    b08 = cube.band("B08")
+    b04 = cube.band("B04")
+    ndvi = (b08 - b04) / (b08 + b04)
+
+    # Monthly median composite
+    monthly = ndvi.aggregate_temporal_period("month", reducer="median")
+
+    # Resample to target resolution
+    if resolution_m > 10:
+        monthly = monthly.resample_spatial(resolution=resolution_m / 111320)
+
+    return monthly
+
+
+def build_true_color_graph(
+    *,
+    conn: openeo.Connection,
+    bbox: dict[str, float],
+    temporal_extent: list[str],
+    resolution_m: int = 100,
+) -> openeo.DataCube:
+    """Build an openEO process graph for a true-color Sentinel-2 composite.
+
+    Loads B04 (Red), B03 (Green), B02 (Blue), masks clouds,
+    and creates a median composite over the temporal extent.
+
+    Returns an openEO DataCube (not yet executed).
+    """
+    cube = conn.load_collection(
+        collection_id="SENTINEL2_L2A",
+        spatial_extent=bbox,
+        temporal_extent=temporal_extent,
+        bands=["B02", "B03", "B04", "SCL"],
+    )
+
+    # Cloud mask
+    scl = cube.band("SCL")
+    cloud_mask = (scl == 4) | (scl == 5) | (scl == 6)
+    cube = cube.mask(~cloud_mask)
+
+    # Drop SCL, keep RGB
+    rgb = cube.filter_bands(["B02", "B03", "B04"])
+
+    # Temporal median composite
+    composite = rgb.reduce_dimension(dimension="t", reducer="median")
+
+    # Resample
+    if resolution_m > 10:
+        composite = composite.resample_spatial(resolution=resolution_m / 111320)
+
+    return composite
+```
+
+- [ ] **Step 5: Run tests**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_openeo_client.py -v`
+
+Expected: All PASS.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add app/openeo_client.py tests/test_openeo_client.py
+git commit -m "feat: add openEO client with NDVI and true-color graph builders"
+```
+
+---
+
+### Task 4: Create Test GeoTIFF Fixtures
+
+**Files:**
+- Create: `tests/fixtures/create_fixtures.py` (generator script)
+- Create: `tests/fixtures/ndvi_monthly.tif` (generated)
+- Create: `tests/fixtures/true_color.tif` (generated)
+- Create: `tests/conftest.py` (modify — add fixture paths)
+
+- [ ] **Step 1: Create fixtures directory**
+
+Run: `mkdir -p /Users/kmini/Github/Aperture/tests/fixtures`
+
+- [ ] **Step 2: Create fixture generator script**
+
+Create `tests/fixtures/create_fixtures.py`:
+
+```python
+"""Generate small synthetic GeoTIFFs for unit tests.
+
+Run this script once to create the test fixtures:
+    python tests/fixtures/create_fixtures.py
+"""
+from __future__ import annotations
+
+import os
+import numpy as np
+import rasterio
+from rasterio.transform import from_bounds
+
+FIXTURES_DIR = os.path.dirname(__file__)
+
+# AOI: small region near Khartoum (~20x15 pixels at 100m = 2km x 1.5km)
+WEST, SOUTH, EAST, NORTH = 32.45, 15.65, 32.65, 15.8
+WIDTH, HEIGHT = 22, 17  # ~100m pixels
+
+
+def _transform():
+    return from_bounds(WEST, SOUTH, EAST, NORTH, WIDTH, HEIGHT)
+
+
+def create_ndvi_monthly():
+    """12-band GeoTIFF: monthly median NDVI (Jan-Dec), float32, range -0.2 to 0.9."""
+    rng = np.random.default_rng(42)
+    path = os.path.join(FIXTURES_DIR, "ndvi_monthly.tif")
+    data = np.zeros((12, HEIGHT, WIDTH), dtype=np.float32)
+    for month in range(12):
+        # Seasonal NDVI pattern: peak in rainy season (Jul-Sep)
+        base = 0.25 + 0.35 * np.sin(np.pi * (month - 3) / 6)
+        data[month] = base + rng.normal(0, 0.05, (HEIGHT, WIDTH))
+    data = np.clip(data, -0.2, 0.9)
+
+    with rasterio.open(
+        path, "w", driver="GTiff",
+        height=HEIGHT, width=WIDTH, count=12,
+        dtype="float32", crs="EPSG:4326",
+        transform=_transform(), nodata=-9999.0,
+    ) as dst:
+        for i in range(12):
+            dst.write(data[i], i + 1)
+    print(f"Created {path} ({os.path.getsize(path)} bytes)")
+
+
+def create_true_color():
+    """3-band GeoTIFF: RGB (B04, B03, B02) reflectance, uint16, range 0-10000."""
+    rng = np.random.default_rng(43)
+    path = os.path.join(FIXTURES_DIR, "true_color.tif")
+    data = np.zeros((3, HEIGHT, WIDTH), dtype=np.uint16)
+    # Semi-arid landscape: brownish-green
+    data[0] = rng.integers(800, 1500, (HEIGHT, WIDTH))   # Red
+    data[1] = rng.integers(700, 1300, (HEIGHT, WIDTH))   # Green
+    data[2] = rng.integers(500, 1000, (HEIGHT, WIDTH))   # Blue
+
+    with rasterio.open(
+        path, "w", driver="GTiff",
+        height=HEIGHT, width=WIDTH, count=3,
+        dtype="uint16", crs="EPSG:4326",
+        transform=_transform(), nodata=0,
+    ) as dst:
+        for i in range(3):
+            dst.write(data[i], i + 1)
+    print(f"Created {path} ({os.path.getsize(path)} bytes)")
+
+
+if __name__ == "__main__":
+    create_ndvi_monthly()
+    create_true_color()
+    print("Done.")
+```
+
+- [ ] **Step 3: Generate the fixtures**
+
+Run: `cd /Users/kmini/Github/Aperture && python tests/fixtures/create_fixtures.py`
+
+Expected: Two files created in `tests/fixtures/` (~5-15KB each).
+
+- [ ] **Step 4: Add fixture paths to conftest**
+
+Read the current `tests/conftest.py` first, then append the fixture paths. Add to `tests/conftest.py`:
+
+```python
+import os
+import pytest
+
+FIXTURES_DIR = os.path.join(os.path.dirname(__file__), "fixtures")
+
+
+@pytest.fixture
+def ndvi_monthly_tif():
+    """Path to a 12-band synthetic NDVI monthly GeoTIFF."""
+    path = os.path.join(FIXTURES_DIR, "ndvi_monthly.tif")
+    if not os.path.exists(path):
+        pytest.skip("Test fixtures not generated. Run: python tests/fixtures/create_fixtures.py")
+    return path
+
+
+@pytest.fixture
+def true_color_tif():
+    """Path to a 3-band synthetic true-color GeoTIFF."""
+    path = os.path.join(FIXTURES_DIR, "true_color.tif")
+    if not os.path.exists(path):
+        pytest.skip("Test fixtures not generated. Run: python tests/fixtures/create_fixtures.py")
+    return path
+```
+
+- [ ] **Step 5: Verify fixtures load**
+
+Run: `cd /Users/kmini/Github/Aperture && python -c "import rasterio; ds = rasterio.open('tests/fixtures/ndvi_monthly.tif'); print(f'NDVI: {ds.count} bands, {ds.width}x{ds.height}'); ds = rasterio.open('tests/fixtures/true_color.tif'); print(f'RGB: {ds.count} bands, {ds.width}x{ds.height}')"`
+
+Expected:
+```
+NDVI: 12 bands, 22x17
+RGB: 3 bands, 22x17
+```
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add tests/fixtures/ tests/conftest.py
+git commit -m "test: add synthetic GeoTIFF fixtures for raster map tests"
+```
+
+---
+
+### Task 5: Add Raster Map Renderer
+
+**Files:**
+- Modify: `app/outputs/maps.py:1-202`
+- Create: `tests/test_raster_maps.py`
+
+- [ ] **Step 1: Write test for raster-on-true-color map rendering**
+
+Create `tests/test_raster_maps.py`:
+
+```python
+"""Tests for raster map rendering — indicator overlaid on true-color composite."""
+from __future__ import annotations
+
+import os
+import tempfile
+import pytest
+
+from app.models import AOI, StatusLevel
+
+
+@pytest.fixture
+def test_aoi():
+    return AOI(name="Test", bbox=[32.45, 15.65, 32.65, 15.8])
+
+
+def test_render_raster_map_produces_png(test_aoi, ndvi_monthly_tif, true_color_tif):
+    """render_raster_map() produces a valid PNG from GeoTIFFs."""
+    from app.outputs.maps import render_raster_map
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        out = os.path.join(tmpdir, "ndvi_map.png")
+        render_raster_map(
+            true_color_path=true_color_tif,
+            indicator_path=ndvi_monthly_tif,
+            indicator_band=7,  # July (peak NDVI)
+            aoi=test_aoi,
+            status=StatusLevel.GREEN,
+            output_path=out,
+            cmap="RdYlGn",
+            vmin=-0.2,
+            vmax=0.9,
+            label="NDVI",
+        )
+        assert os.path.exists(out)
+        assert os.path.getsize(out) > 5000  # Reasonable PNG size
+
+
+def test_render_raster_map_without_true_color(test_aoi, ndvi_monthly_tif):
+    """render_raster_map() works without a true-color base (just indicator)."""
+    from app.outputs.maps import render_raster_map
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        out = os.path.join(tmpdir, "ndvi_no_base.png")
+        render_raster_map(
+            true_color_path=None,
+            indicator_path=ndvi_monthly_tif,
+            indicator_band=7,
+            aoi=test_aoi,
+            status=StatusLevel.AMBER,
+            output_path=out,
+            cmap="RdYlGn",
+            vmin=-0.2,
+            vmax=0.9,
+            label="NDVI",
+        )
+        assert os.path.exists(out)
+        assert os.path.getsize(out) > 3000
+
+
+def test_render_true_color_standalone(test_aoi, true_color_tif):
+    """render_raster_map() renders just the true-color composite when no indicator."""
+    from app.outputs.maps import render_raster_map
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        out = os.path.join(tmpdir, "rgb_only.png")
+        render_raster_map(
+            true_color_path=true_color_tif,
+            indicator_path=None,
+            indicator_band=1,
+            aoi=test_aoi,
+            status=StatusLevel.GREEN,
+            output_path=out,
+            label="True Color",
+        )
+        assert os.path.exists(out)
+        assert os.path.getsize(out) > 3000
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_raster_maps.py -v`
+
+Expected: FAIL — `ImportError: cannot import name 'render_raster_map' from 'app.outputs.maps'`
+
+- [ ] **Step 3: Implement render_raster_map()**
+
+Add to the bottom of `app/outputs/maps.py` (after the existing `_render_grid` function, line 201):
+
+```python
+def render_raster_map(
+    *,
+    true_color_path: str | None,
+    indicator_path: str | None,
+    indicator_band: int = 1,
+    aoi: AOI,
+    status: StatusLevel,
+    output_path: str,
+    cmap: str = "RdYlGn",
+    vmin: float | None = None,
+    vmax: float | None = None,
+    alpha: float = 0.6,
+    label: str = "",
+) -> None:
+    """Render an indicator raster overlaid on a true-color Sentinel-2 composite.
+
+    Parameters
+    ----------
+    true_color_path:
+        Path to a 3-band (R,G,B) GeoTIFF. If None, renders on plain background.
+    indicator_path:
+        Path to indicator GeoTIFF. Reads band `indicator_band`. If None,
+        renders only the true-color composite.
+    indicator_band:
+        1-based band index to read from the indicator GeoTIFF.
+    aoi:
+        AOI for bounding box overlay.
+    status:
+        Traffic-light status — used for AOI outline color.
+    output_path:
+        Path to write the output PNG.
+    cmap:
+        Matplotlib colormap name for the indicator overlay.
+    vmin, vmax:
+        Value range for the indicator colormap.
+    alpha:
+        Transparency of the indicator overlay (0=transparent, 1=opaque).
+    label:
+        Colorbar label string.
+    """
+    import rasterio
+
+    fig, ax = plt.subplots(figsize=(6, 5), dpi=200, facecolor=SHELL)
+    ax.set_facecolor(SHELL)
+
+    extent = None
+
+    # Render true-color base layer
+    if true_color_path is not None:
+        with rasterio.open(true_color_path) as src:
+            rgb = src.read([1, 2, 3]).astype(np.float32)
+            extent = [src.bounds.left, src.bounds.right, src.bounds.bottom, src.bounds.top]
+        # Sentinel-2 reflectance scaling (values typically 0-10000)
+        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", zorder=0)
+
+    # Render indicator raster overlay
+    if indicator_path is not None:
+        with rasterio.open(indicator_path) as src:
+            data = src.read(indicator_band).astype(np.float32)
+            nodata = src.nodata
+            ind_extent = [src.bounds.left, src.bounds.right, src.bounds.bottom, src.bounds.top]
+        if extent is None:
+            extent = ind_extent
+        masked = np.ma.masked_where(
+            (data == nodata) if nodata is not None else np.zeros_like(data, dtype=bool),
+            data,
+        )
+        im = ax.imshow(
+            masked, extent=ind_extent, cmap=cmap, alpha=alpha,
+            vmin=vmin, vmax=vmax, aspect="auto", zorder=1,
+        )
+        cbar = fig.colorbar(im, ax=ax, fraction=0.03, pad=0.04, shrink=0.85)
+        cbar.set_label(label, fontsize=7, color=INK_MUTED)
+        cbar.ax.tick_params(labelsize=6, colors=INK_MUTED)
+
+    # AOI outline
+    if extent is not None:
+        ax.set_xlim(extent[0], extent[1])
+        ax.set_ylim(extent[2], extent[3])
+    color = STATUS_COLORS[status]
+    _draw_aoi_rect(ax, aoi, color)
+
+    # Axis labels
+    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)
+
+    # Clean spines
+    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)
+```
+
+Also add `import rasterio` check at the top of the file won't be needed — we import inside the function to keep the module loadable even if rasterio isn't installed (existing pattern in this file with cartopy).
+
+- [ ] **Step 4: Run tests**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_raster_maps.py -v`
+
+Expected: All PASS.
+
+- [ ] **Step 5: Run existing map tests to verify no regressions**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_maps.py -v`
+
+Expected: All existing tests still PASS.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add app/outputs/maps.py tests/test_raster_maps.py
+git commit -m "feat: add raster-on-true-color map renderer (render_raster_map)"
+```
+
+---
+
+### Task 6: Create NDVI Indicator
+
+**Files:**
+- Create: `app/indicators/ndvi.py`
+- Create: `tests/test_indicator_ndvi.py`
+
+- [ ] **Step 1: Write test for NDVI indicator with mocked openEO**
+
+Create `tests/test_indicator_ndvi.py`:
+
+```python
+"""Tests for app.indicators.ndvi — pixel-level NDVI via openEO."""
+from __future__ import annotations
+
+import os
+import tempfile
+from unittest.mock import MagicMock, patch, AsyncMock
+from datetime import date
+
+import numpy as np
+import pytest
+
+from app.models import AOI, TimeRange, StatusLevel, TrendDirection, ConfidenceLevel
+
+
+@pytest.fixture
+def test_aoi():
+    return AOI(name="Test Khartoum", bbox=[32.45, 15.65, 32.65, 15.8])
+
+
+@pytest.fixture
+def test_time_range():
+    return TimeRange(start=date(2025, 3, 1), end=date(2026, 3, 1))
+
+
+def _mock_ndvi_tif(path: str, n_months: int = 12):
+    """Create a small synthetic NDVI GeoTIFF at the given path."""
+    import rasterio
+    from rasterio.transform import from_bounds
+    rng = np.random.default_rng(42)
+    data = np.zeros((n_months, 10, 10), dtype=np.float32)
+    for m in range(n_months):
+        data[m] = 0.3 + 0.2 * np.sin(np.pi * (m - 3) / 6) + rng.normal(0, 0.02, (10, 10))
+    with rasterio.open(
+        path, "w", driver="GTiff", height=10, width=10, count=n_months,
+        dtype="float32", crs="EPSG:4326",
+        transform=from_bounds(32.45, 15.65, 32.65, 15.8, 10, 10),
+        nodata=-9999.0,
+    ) as dst:
+        for i in range(n_months):
+            dst.write(data[i], i + 1)
+
+
+def _mock_true_color_tif(path: str):
+    """Create a small synthetic true-color GeoTIFF."""
+    import rasterio
+    from rasterio.transform import from_bounds
+    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(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)
+
+
+@pytest.mark.asyncio
+async def test_ndvi_process_returns_indicator_result(test_aoi, test_time_range):
+    """NdviIndicator.process() returns a valid IndicatorResult."""
+    from app.indicators.ndvi import NdviIndicator
+
+    indicator = NdviIndicator()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        ndvi_path = os.path.join(tmpdir, "ndvi.tif")
+        rgb_path = os.path.join(tmpdir, "rgb.tif")
+        _mock_ndvi_tif(ndvi_path)
+        _mock_true_color_tif(rgb_path)
+
+        # Mock the openEO download to write our test files
+        mock_cube = MagicMock()
+        mock_cube.download = MagicMock()
+
+        with patch("app.indicators.ndvi.get_connection") as mock_get_conn, \
+             patch("app.indicators.ndvi.build_ndvi_graph", return_value=mock_cube) as mock_ndvi, \
+             patch("app.indicators.ndvi.build_true_color_graph", return_value=mock_cube) as mock_rgb:
+
+            # When download() is called, copy our fixture to the target path
+            def fake_download(path, **kwargs):
+                import shutil
+                if "ndvi" in path:
+                    shutil.copy(ndvi_path, path)
+                else:
+                    shutil.copy(rgb_path, path)
+
+            mock_cube.download.side_effect = fake_download
+
+            result = await indicator.process(test_aoi, test_time_range)
+
+    assert result.indicator_id == "ndvi"
+    assert result.status in (StatusLevel.GREEN, StatusLevel.AMBER, StatusLevel.RED)
+    assert result.trend in (TrendDirection.IMPROVING, TrendDirection.STABLE, TrendDirection.DETERIORATING)
+    assert result.confidence in (ConfidenceLevel.HIGH, ConfidenceLevel.MODERATE, ConfidenceLevel.LOW)
+    assert "NDVI" in result.methodology or "ndvi" in result.methodology.lower()
+    assert len(result.chart_data.get("dates", [])) > 0
+    assert len(result.chart_data.get("values", [])) > 0
+
+
+@pytest.mark.asyncio
+async def test_ndvi_falls_back_to_vegetation_on_failure(test_aoi, test_time_range):
+    """NdviIndicator falls back gracefully when openEO fails."""
+    from app.indicators.ndvi import NdviIndicator
+
+    indicator = NdviIndicator()
+
+    with patch("app.indicators.ndvi.get_connection", side_effect=Exception("CDSE down")):
+        result = await indicator.process(test_aoi, test_time_range)
+
+    assert result.indicator_id == "ndvi"
+    assert result.data_source == "placeholder"
+
+
+def test_ndvi_compute_stats():
+    """_compute_stats() extracts correct statistics from a multi-band raster."""
+    from app.indicators.ndvi import NdviIndicator
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        path = os.path.join(tmpdir, "ndvi.tif")
+        _mock_ndvi_tif(path, n_months=12)
+
+        stats = NdviIndicator._compute_stats(path)
+
+    assert "monthly_means" in stats
+    assert len(stats["monthly_means"]) == 12
+    assert "overall_mean" in stats
+    assert 0 < stats["overall_mean"] < 1
+    assert "valid_months" in stats
+    assert stats["valid_months"] == 12
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_indicator_ndvi.py -v`
+
+Expected: FAIL — `ModuleNotFoundError: No module named 'app.indicators.ndvi'`
+
+- [ ] **Step 3: Implement NdviIndicator**
+
+Create `app/indicators/ndvi.py`:
+
+```python
+"""NDVI Vegetation Indicator — pixel-level via CDSE openEO.
+
+Computes monthly median NDVI composites from Sentinel-2 L2A, compares
+current period to a 5-year baseline, and classifies vegetation change
+using percentage-point 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_ndvi_graph, build_true_color_graph, _bbox_dict
+
+logger = logging.getLogger(__name__)
+
+BASELINE_YEARS = 5
+
+
+class NdviIndicator(BaseIndicator):
+    id = "ndvi"
+    name = "Vegetation (NDVI)"
+    category = "D2"
+    question = "Is vegetation cover declining?"
+    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("NDVI 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 period: BASELINE_YEARS before the current start
+        baseline_start = date(
+            time_range.start.year - BASELINE_YEARS,
+            time_range.start.month,
+            time_range.start.day,
+        ).isoformat()
+        baseline_end = date(
+            time_range.start.year,
+            time_range.start.month,
+            time_range.start.day,
+        ).isoformat()
+
+        results_dir = tempfile.mkdtemp(prefix="aperture_ndvi_")
+
+        # Build processing graphs
+        current_cube = build_ndvi_graph(
+            conn=conn, bbox=bbox,
+            temporal_extent=[current_start, current_end],
+            resolution_m=RESOLUTION_M,
+        )
+        baseline_cube = build_ndvi_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,
+        )
+
+        # Download results (sequential to manage memory on free tier)
+        loop = asyncio.get_event_loop()
+        current_path = os.path.join(results_dir, "ndvi_current.tif")
+        baseline_path = os.path.join(results_dir, "ndvi_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
+
+        # Compute statistics
+        current_stats = self._compute_stats(current_path)
+        baseline_stats = self._compute_stats(baseline_path)
+
+        current_mean = current_stats["overall_mean"]
+        baseline_mean = baseline_stats["overall_mean"]
+        change = current_mean - baseline_mean
+
+        status = self._classify(change)
+        trend = self._compute_trend(change)
+        confidence = (
+            ConfidenceLevel.HIGH if current_stats["valid_months"] >= 6
+            else ConfidenceLevel.MODERATE if current_stats["valid_months"] >= 3
+            else ConfidenceLevel.LOW
+        )
+
+        # Build chart data
+        chart_data = self._build_chart_data(
+            current_stats["monthly_means"],
+            baseline_stats["monthly_means"],
+            time_range,
+        )
+
+        # Headline
+        if abs(change) <= 0.05:
+            headline = f"Vegetation stable (NDVI {current_mean:.2f}, Δ{change:+.2f} vs baseline)"
+        elif change > 0:
+            headline = f"Vegetation greening (NDVI +{change:.2f} vs baseline)"
+        else:
+            headline = f"Vegetation decline (NDVI {change:.2f} vs baseline)"
+
+        # Spatial data — store the current NDVI path for map rendering
+        self._spatial_data = SpatialData(
+            map_type="raster",
+            label="NDVI",
+            colormap="RdYlGn",
+        )
+        # Store paths for the worker to use
+        self._indicator_raster_path = current_path
+        self._true_color_path = true_color_path
+        self._ndvi_peak_band = current_stats["peak_month_band"]
+
+        return IndicatorResult(
+            indicator_id=self.id,
+            headline=headline,
+            status=status,
+            trend=trend,
+            confidence=confidence,
+            map_layer_path=current_path,
+            chart_data=chart_data,
+            data_source="satellite",
+            summary=(
+                f"Mean NDVI is {current_mean:.3f} compared to a {BASELINE_YEARS}-year "
+                f"baseline of {baseline_mean:.3f} (Δ{change:+.3f}). "
+                f"Pixel-level analysis at {RESOLUTION_M}m resolution from "
+                f"{current_stats['valid_months']} monthly composites."
+            ),
+            methodology=(
+                f"Sentinel-2 L2A pixel-level NDVI = (B08 − B04) / (B08 + B04). "
+                f"Cloud-masked using SCL band (classes 4, 5, 6 retained). "
+                f"Monthly median composites at {RESOLUTION_M}m resolution. "
+                f"Baseline: {BASELINE_YEARS}-year monthly medians. "
+                f"Processed server-side via CDSE openEO."
+            ),
+            limitations=[
+                f"Resampled to {RESOLUTION_M}m — sub-field variability not captured at this resolution.",
+                "Cloud cover reduces observation count in rainy seasons.",
+                "NDVI does not distinguish crop from natural vegetation.",
+                "Seasonal variation may mask long-term trends if analysis windows differ.",
+            ],
+        )
+
+    @staticmethod
+    def _compute_stats(tif_path: str) -> dict[str, Any]:
+        """Extract monthly and overall NDVI statistics from a multi-band GeoTIFF."""
+        with rasterio.open(tif_path) as src:
+            n_bands = src.count
+            monthly_means = []
+            peak_val = -999.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)
+        overall_mean = float(np.mean([m for m in monthly_means if m > 0])) if valid_months > 0 else 0.0
+
+        return {
+            "monthly_means": monthly_means,
+            "overall_mean": overall_mean,
+            "valid_months": valid_months,
+            "peak_month_band": peak_band,
+        }
+
+    @staticmethod
+    def _classify(change: float) -> StatusLevel:
+        """Classify NDVI anomaly into traffic-light status."""
+        if change >= -0.05:
+            return StatusLevel.GREEN
+        if change >= -0.15:
+            return StatusLevel.AMBER
+        return StatusLevel.RED
+
+    @staticmethod
+    def _compute_trend(change: float) -> TrendDirection:
+        if abs(change) <= 0.05:
+            return TrendDirection.STABLE
+        if change > 0:
+            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]:
+        """Build chart data with monthly NDVI values and baseline band."""
+        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, 3) for v in current_monthly[:n]]
+        b_mean = [round(v, 3) for v in baseline_monthly[:n]]
+
+        # For baseline band, use mean ± 0.05 as approximate range
+        # (proper per-year min/max requires storing all baseline years)
+        b_min = [round(max(v - 0.05, -0.2), 3) for v in baseline_monthly[:n]]
+        b_max = [round(min(v + 0.05, 0.9), 3) for v in baseline_monthly[:n]]
+
+        return {
+            "dates": dates,
+            "values": values,
+            "baseline_mean": b_mean,
+            "baseline_min": b_min,
+            "baseline_max": b_max,
+            "label": "NDVI",
+        }
+
+    def _fallback(self, aoi: AOI, time_range: TimeRange) -> IndicatorResult:
+        """Return a placeholder result when openEO processing fails."""
+        rng = np.random.default_rng(7)
+        baseline = float(rng.uniform(0.25, 0.45))
+        current = baseline * float(rng.uniform(0.90, 1.02))
+        change = current - baseline
+
+        return IndicatorResult(
+            indicator_id=self.id,
+            headline=f"Vegetation data degraded (NDVI ≈{current:.2f})",
+            status=self._classify(change),
+            trend=self._compute_trend(change),
+            confidence=ConfidenceLevel.LOW,
+            map_layer_path="",
+            chart_data={
+                "dates": [str(time_range.start.year), str(time_range.end.year)],
+                "values": [round(baseline, 3), round(current, 3)],
+                "label": "NDVI",
+            },
+            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**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_indicator_ndvi.py -v`
+
+Expected: All PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add app/indicators/ndvi.py tests/test_indicator_ndvi.py
+git commit -m "feat: add pixel-level NDVI indicator via CDSE openEO"
+```
+
+---
+
+### Task 7: Register NDVI Indicator and Update Worker
+
+**Files:**
+- Modify: `app/indicators/__init__.py:1-22`
+- Modify: `app/indicators/base.py:13-22` (SpatialData — add `raster` map_type support)
+- Modify: `app/worker.py:91-106` (map rendering — handle raster type)
+
+- [ ] **Step 1: Add NDVI to indicator registry**
+
+In `app/indicators/__init__.py`, add the import and registration. Replace the full file:
+
+```python
+from app.indicators.base import IndicatorRegistry
+from app.indicators.fires import FiresIndicator
+from app.indicators.cropland import CroplandIndicator
+from app.indicators.vegetation import VegetationIndicator
+from app.indicators.rainfall import RainfallIndicator
+from app.indicators.water import WaterIndicator
+from app.indicators.no2 import NO2Indicator
+from app.indicators.lst import LSTIndicator
+from app.indicators.nightlights import NightlightsIndicator
+from app.indicators.food_security import FoodSecurityIndicator
+from app.indicators.ndvi import NdviIndicator
+
+registry = IndicatorRegistry()
+registry.register(NdviIndicator())
+registry.register(FiresIndicator())
+registry.register(CroplandIndicator())
+registry.register(VegetationIndicator())
+registry.register(RainfallIndicator())
+registry.register(WaterIndicator())
+registry.register(NO2Indicator())
+registry.register(LSTIndicator())
+registry.register(NightlightsIndicator())
+registry.register(FoodSecurityIndicator())
+```
+
+- [ ] **Step 2: Update worker to handle raster map type**
+
+In `app/worker.py`, replace lines 91-106 (the map generation block inside the `for result in job.results:` loop):
+
+```python
+            # Generate map PNG for every indicator
+            spatial = spatial_cache.get(result.indicator_id)
+            map_path = os.path.join(results_dir, f"{result.indicator_id}_map.png")
+
+            if spatial is not None and spatial.map_type == "raster":
+                # New: raster-on-true-color rendering for openEO 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)
+                peak_band = getattr(indicator_obj, '_ndvi_peak_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=peak_band,
+                    aoi=job.request.aoi,
+                    status=result.status,
+                    output_path=map_path,
+                    cmap=spatial.colormap,
+                    vmin=-0.2 if "ndvi" in result.indicator_id else None,
+                    vmax=0.9 if "ndvi" in result.indicator_id else None,
+                    label=spatial.label,
+                )
+            elif spatial is not None:
+                render_indicator_map(
+                    spatial=spatial,
+                    aoi=job.request.aoi,
+                    status=result.status,
+                    output_path=map_path,
+                )
+            else:
+                render_status_map(
+                    aoi=job.request.aoi,
+                    status=result.status,
+                    output_path=map_path,
+                )
+```
+
+- [ ] **Step 3: Run existing tests to verify no regressions**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_worker.py tests/test_indicator_base.py -v`
+
+Expected: All PASS.
+
+- [ ] **Step 4: Run the full test suite**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/ -v --timeout=60`
+
+Expected: All tests PASS. The NDVI indicator tests pass with mocked openEO, existing indicators are unaffected.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add app/indicators/__init__.py app/worker.py
+git commit -m "feat: register NDVI indicator and add raster map support to worker"
+```
+
+---
+
+### Task 8: End-to-End Smoke Test
+
+This task verifies the full pipeline works with mocked openEO — from indicator processing through map rendering to report generation.
+
+**Files:**
+- Create: `tests/test_ndvi_e2e.py`
+
+- [ ] **Step 1: Write end-to-end test**
+
+Create `tests/test_ndvi_e2e.py`:
+
+```python
+"""End-to-end test: NDVI indicator → raster map → chart → report section.
+
+Uses mocked openEO (no CDSE credentials needed) with synthetic GeoTIFFs.
+"""
+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
+from app.outputs.charts import render_timeseries_chart
+from app.outputs.maps import render_raster_map
+
+
+BBOX = [32.45, 15.65, 32.65, 15.8]
+WIDTH, HEIGHT = 15, 12
+
+
+def _write_ndvi_tif(path: str):
+    rng = np.random.default_rng(42)
+    data = np.zeros((12, HEIGHT, WIDTH), dtype=np.float32)
+    for m in range(12):
+        data[m] = 0.3 + 0.2 * np.sin(np.pi * (m - 3) / 6) + rng.normal(0, 0.03, (HEIGHT, WIDTH))
+    with rasterio.open(
+        path, "w", driver="GTiff", height=HEIGHT, width=WIDTH, count=12,
+        dtype="float32", crs="EPSG:4326",
+        transform=from_bounds(*BBOX, WIDTH, HEIGHT), nodata=-9999.0,
+    ) as dst:
+        for i in range(12):
+            dst.write(data[i], i + 1)
+
+
+def _write_rgb_tif(path: str):
+    rng = np.random.default_rng(43)
+    data = rng.integers(500, 1500, (3, HEIGHT, WIDTH), dtype=np.uint16)
+    with rasterio.open(
+        path, "w", driver="GTiff", height=HEIGHT, width=WIDTH, count=3,
+        dtype="uint16", crs="EPSG:4326",
+        transform=from_bounds(*BBOX, WIDTH, HEIGHT), nodata=0,
+    ) as dst:
+        for i in range(3):
+            dst.write(data[i], i + 1)
+
+
+@pytest.mark.asyncio
+async def test_ndvi_full_pipeline():
+    """Full pipeline: process NDVI → render raster map → render chart."""
+    from app.indicators.ndvi import NdviIndicator
+
+    aoi = AOI(name="Khartoum Test", bbox=BBOX)
+    time_range = TimeRange(start=date(2025, 3, 1), end=date(2026, 3, 1))
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        ndvi_path = os.path.join(tmpdir, "ndvi.tif")
+        rgb_path = os.path.join(tmpdir, "rgb.tif")
+        _write_ndvi_tif(ndvi_path)
+        _write_rgb_tif(rgb_path)
+
+        mock_cube = MagicMock()
+
+        def fake_download(path, **kwargs):
+            import shutil
+            if "ndvi" in path:
+                shutil.copy(ndvi_path, path)
+            else:
+                shutil.copy(rgb_path, path)
+
+        mock_cube.download = MagicMock(side_effect=fake_download)
+
+        with patch("app.indicators.ndvi.get_connection") as mock_conn, \
+             patch("app.indicators.ndvi.build_ndvi_graph", return_value=mock_cube), \
+             patch("app.indicators.ndvi.build_true_color_graph", return_value=mock_cube):
+
+            indicator = NdviIndicator()
+            result = await indicator.process(aoi, time_range)
+
+        # Verify result quality
+        assert result.indicator_id == "ndvi"
+        assert result.data_source == "satellite"
+        assert "NDVI" in result.methodology
+        assert "pixel" in result.methodology.lower()
+        assert len(result.chart_data["dates"]) >= 6
+        assert all(isinstance(v, float) for v in result.chart_data["values"])
+
+        # Render the raster map
+        map_out = os.path.join(tmpdir, "ndvi_map.png")
+        raster_path = indicator._indicator_raster_path
+        tc_path = indicator._true_color_path
+        peak = indicator._ndvi_peak_band
+
+        render_raster_map(
+            true_color_path=tc_path,
+            indicator_path=raster_path,
+            indicator_band=peak,
+            aoi=aoi,
+            status=result.status,
+            output_path=map_out,
+            cmap="RdYlGn",
+            vmin=-0.2,
+            vmax=0.9,
+            label="NDVI",
+        )
+        assert os.path.exists(map_out)
+        assert os.path.getsize(map_out) > 10000  # Real map should be >10KB
+
+        # Render the chart
+        chart_out = os.path.join(tmpdir, "ndvi_chart.png")
+        render_timeseries_chart(
+            chart_data=result.chart_data,
+            indicator_name="Vegetation (NDVI)",
+            status=result.status,
+            trend=result.trend,
+            output_path=chart_out,
+            y_label="NDVI",
+        )
+        assert os.path.exists(chart_out)
+        assert os.path.getsize(chart_out) > 5000
+```
+
+- [ ] **Step 2: Run the e2e test**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_ndvi_e2e.py -v`
+
+Expected: PASS — the full pipeline works with mocked openEO.
+
+- [ ] **Step 3: Run the complete test suite**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/ -v --timeout=120`
+
+Expected: All tests PASS, including new and existing tests.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add tests/test_ndvi_e2e.py
+git commit -m "test: add end-to-end smoke test for NDVI openEO pipeline"
+```
+
+---
+
+### Task 9: Final Verification and Cleanup
+
+- [ ] **Step 1: Run full test suite one more time**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/ -v --timeout=120 2>&1 | tail -30`
+
+Expected: All tests PASS. Note the total count — should be the existing ~121 tests plus the ~10 new tests.
+
+- [ ] **Step 2: Verify no import cycles**
+
+Run: `cd /Users/kmini/Github/Aperture && python -c "from app.indicators import registry; print('Registered:', registry.list_ids())"`
+
+Expected: Prints the list including `ndvi` alongside existing indicators.
+
+- [ ] **Step 3: Verify the config module loads cleanly**
+
+Run: `cd /Users/kmini/Github/Aperture && python -c "from app.config import RESOLUTION_M, OPENEO_BACKEND; print(f'Resolution: {RESOLUTION_M}m, Backend: {OPENEO_BACKEND}')"`
+
+Expected: `Resolution: 100m, Backend: openeo.dataspace.copernicus.eu`
+
+- [ ] **Step 4: Check git status**
+
+Run: `cd /Users/kmini/Github/Aperture && git log --oneline -8`
+
+Expected: 8 new commits from this plan:
+1. `build: add openeo dependency for CDSE processing`
+2. `feat: add centralized config module with resolution and openEO settings`
+3. `feat: add openEO client with NDVI and true-color graph builders`
+4. `test: add synthetic GeoTIFF fixtures for raster map tests`
+5. `feat: add raster-on-true-color map renderer (render_raster_map)`
+6. `feat: add pixel-level NDVI indicator via CDSE openEO`
+7. `feat: register NDVI indicator and add raster map support to worker`
+8. `test: add end-to-end smoke test for NDVI openEO pipeline`