docs: implementation plan for batch SAR/buildup/water + NDVI fix

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-04-01-batch-sar-buildup-water.md

@@ -0,0 +1,1416 @@
+# Batch Support for SAR, Buildup, Water 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:** Add batch processing (submit_batch + harvest) to SAR, buildup, and water indicators, matching the existing NDVI batch pattern.
+
+**Architecture:** Each indicator gets `uses_batch = True`, a `submit_batch()` that submits 3 openEO batch jobs (current, baseline, true-color), and a `harvest()` that downloads results and runs full post-processing. The worker already handles batch indicators — no orchestration changes needed.
+
+**Tech Stack:** Python, openEO, rasterio, pytest, CDSE backend
+
+**Spec:** `docs/superpowers/specs/2026-04-01-batch-sar-buildup-water-design.md`
+
+---
+
+### Task 0: Fix NDVI Batch Baseline Bug + Add Debug Logging
+
+There is a bug in `app/indicators/ndvi.py` `harvest()`: after downloading the baseline job results (line 111), `baseline_path` is never assigned the actual tif path — it stays `None`. This means harvest always runs in degraded mode (no baseline comparison). This task fixes that bug and adds worker-level debug logging.
+
+**Files:**
+- Modify: `app/indicators/ndvi.py:106-113`
+- Test: `tests/test_indicator_ndvi.py` (existing tests cover this)
+
+- [ ] **Step 1: Write a failing test that exposes the baseline bug**
+
+Add to `tests/test_indicator_ndvi.py`:
+
+```python
+@pytest.mark.asyncio
+async def test_ndvi_harvest_uses_baseline_when_available(test_aoi, test_time_range):
+    """harvest() computes change vs baseline when baseline download succeeds."""
+    from app.indicators.ndvi import NdviIndicator
+
+    indicator = NdviIndicator()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Current: higher NDVI
+        current_path = os.path.join(tmpdir, "current.tif")
+        _mock_ndvi_tif(current_path, n_months=12)
+
+        # Baseline: lower NDVI (shift down by 0.1)
+        baseline_path = os.path.join(tmpdir, "baseline.tif")
+        import rasterio
+        from rasterio.transform import from_bounds
+        rng = np.random.default_rng(99)
+        data = np.zeros((12, 10, 10), dtype=np.float32)
+        for m in range(12):
+            data[m] = 0.2 + 0.1 * np.sin(np.pi * (m - 3) / 6) + rng.normal(0, 0.02, (10, 10))
+        with rasterio.open(
+            baseline_path, "w", driver="GTiff", height=10, width=10, count=12,
+            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(12):
+                dst.write(data[i], i + 1)
+
+        rgb_path = os.path.join(tmpdir, "rgb.tif")
+        _mock_true_color_tif(rgb_path)
+
+        def make_mock_job(src_path):
+            job = MagicMock()
+            job.job_id = "j-test"
+            def fake_download_results(target):
+                import shutil
+                os.makedirs(target, exist_ok=True)
+                dest = os.path.join(target, "result.tif")
+                shutil.copy(src_path, dest)
+                from pathlib import Path
+                return {Path(dest): {"type": "image/tiff"}}
+            job.download_results.side_effect = fake_download_results
+            job.status.return_value = "finished"
+            return job
+
+        current_job = make_mock_job(current_path)
+        baseline_job = make_mock_job(baseline_path)
+        true_color_job = make_mock_job(rgb_path)
+
+        result = await indicator.harvest(
+            test_aoi, test_time_range,
+            batch_jobs=[current_job, baseline_job, true_color_job],
+        )
+
+    assert result.data_source == "satellite"
+    # With distinct current vs baseline, confidence should NOT be LOW
+    # (it should be HIGH with 12 valid months)
+    assert result.confidence == ConfidenceLevel.HIGH
+    # Baseline band data should be present in chart
+    assert "baseline_mean" in result.chart_data
+    assert len(result.chart_data["baseline_mean"]) > 0
+```
+
+- [ ] **Step 2: Run the test to verify it fails**
+
+Run: `pytest tests/test_indicator_ndvi.py::test_ndvi_harvest_uses_baseline_when_available -v`
+
+Expected: FAIL — `result.confidence` is `LOW` because `baseline_path` is always `None`.
+
+- [ ] **Step 3: Fix the baseline_path assignment in harvest()**
+
+In `app/indicators/ndvi.py`, replace lines 106-113:
+
+```python
+        # Download baseline — optional (degrades gracefully)
+        baseline_path = None
+        try:
+            baseline_dir = os.path.join(results_dir, "baseline")
+            os.makedirs(baseline_dir, exist_ok=True)
+            paths = baseline_job.download_results(baseline_dir)
+        except Exception as exc:
+            logger.warning("NDVI baseline batch download failed, degrading: %s", exc)
+```
+
+With:
+
+```python
+        # Download baseline — optional (degrades gracefully)
+        baseline_path = None
+        try:
+            baseline_dir = os.path.join(results_dir, "baseline")
+            os.makedirs(baseline_dir, exist_ok=True)
+            paths = baseline_job.download_results(baseline_dir)
+            baseline_path = self._find_tif(paths, baseline_dir)
+        except Exception as exc:
+            logger.warning("NDVI baseline batch download failed, degrading: %s", exc)
+```
+
+- [ ] **Step 4: Run all NDVI tests to verify the fix**
+
+Run: `pytest tests/test_indicator_ndvi.py tests/test_ndvi_e2e.py -v`
+
+Expected: ALL PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add app/indicators/ndvi.py tests/test_indicator_ndvi.py
+git commit -m "fix: NDVI harvest baseline_path never assigned after download"
+```
+
+---
+
+### Task 1: SAR Batch — Tests
+
+**Files:**
+- Modify: `tests/test_indicator_sar.py`
+
+- [ ] **Step 1: Add submit_batch test**
+
+Append to `tests/test_indicator_sar.py`:
+
+```python
+@pytest.mark.asyncio
+async def test_sar_submit_batch_creates_three_jobs(test_aoi, test_time_range):
+    """submit_batch() creates current, baseline, and true-color batch jobs."""
+    from app.indicators.sar import SarIndicator
+
+    indicator = SarIndicator()
+
+    mock_conn = MagicMock()
+    mock_job = MagicMock()
+    mock_job.job_id = "j-test"
+    mock_conn.create_job.return_value = mock_job
+
+    with patch("app.indicators.sar.get_connection", return_value=mock_conn), \
+         patch("app.indicators.sar.build_sar_graph") as mock_sar_graph, \
+         patch("app.indicators.sar.build_true_color_graph") as mock_tc_graph:
+
+        mock_sar_graph.return_value = MagicMock()
+        mock_tc_graph.return_value = MagicMock()
+
+        jobs = await indicator.submit_batch(test_aoi, test_time_range)
+
+    assert len(jobs) == 3
+    assert mock_sar_graph.call_count == 2  # current + baseline
+    assert mock_tc_graph.call_count == 1   # true-color
+```
+
+- [ ] **Step 2: Add harvest success test**
+
+Append to `tests/test_indicator_sar.py`:
+
+```python
+@pytest.mark.asyncio
+async def test_sar_harvest_computes_result_from_batch_jobs(test_aoi, test_time_range):
+    """harvest() downloads batch results and returns 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)
+
+        def make_mock_job(src_path):
+            job = MagicMock()
+            job.job_id = "j-test"
+            def fake_download_results(target):
+                import shutil
+                os.makedirs(target, exist_ok=True)
+                dest = os.path.join(target, "result.tif")
+                shutil.copy(src_path, dest)
+                from pathlib import Path
+                return {Path(dest): {"type": "image/tiff"}}
+            job.download_results.side_effect = fake_download_results
+            job.status.return_value = "finished"
+            return job
+
+        current_job = make_mock_job(sar_path)
+        baseline_job = make_mock_job(sar_path)
+        true_color_job = make_mock_job(rgb_path)
+
+        result = await indicator.harvest(
+            test_aoi, test_time_range,
+            batch_jobs=[current_job, baseline_job, true_color_job],
+        )
+
+    assert result.indicator_id == "sar"
+    assert result.data_source == "satellite"
+    assert result.status in (StatusLevel.GREEN, StatusLevel.AMBER, StatusLevel.RED)
+    assert result.confidence in (ConfidenceLevel.HIGH, ConfidenceLevel.MODERATE, ConfidenceLevel.LOW)
+    assert len(result.chart_data.get("dates", [])) > 0
+```
+
+- [ ] **Step 3: Add harvest current-fails test**
+
+Append to `tests/test_indicator_sar.py`:
+
+```python
+@pytest.mark.asyncio
+async def test_sar_harvest_falls_back_when_current_fails(test_aoi, test_time_range):
+    """harvest() returns placeholder when current SAR job failed."""
+    from app.indicators.sar import SarIndicator
+
+    indicator = SarIndicator()
+
+    current_job = MagicMock()
+    current_job.download_results.side_effect = Exception("failed")
+    baseline_job = MagicMock()
+    true_color_job = MagicMock()
+
+    result = await indicator.harvest(
+        test_aoi, test_time_range,
+        batch_jobs=[current_job, baseline_job, true_color_job],
+    )
+
+    assert result.data_source == "placeholder"
+```
+
+- [ ] **Step 4: Add harvest baseline-fails test**
+
+Append to `tests/test_indicator_sar.py`:
+
+```python
+@pytest.mark.asyncio
+async def test_sar_harvest_degrades_when_baseline_fails(test_aoi, test_time_range):
+    """harvest() returns degraded result when baseline SAR job failed."""
+    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)
+
+        def make_mock_job(src_path, fail=False):
+            job = MagicMock()
+            job.job_id = "j-test"
+            def fake_download_results(target):
+                if fail:
+                    raise Exception("Batch job failed on CDSE")
+                import shutil
+                os.makedirs(target, exist_ok=True)
+                dest = os.path.join(target, "result.tif")
+                shutil.copy(src_path, dest)
+                from pathlib import Path
+                return {Path(dest): {"type": "image/tiff"}}
+            job.download_results.side_effect = fake_download_results
+            job.status.return_value = "finished"
+            return job
+
+        current_job = make_mock_job(sar_path)
+        baseline_job = make_mock_job(sar_path, fail=True)
+        true_color_job = make_mock_job(rgb_path)
+
+        result = await indicator.harvest(
+            test_aoi, test_time_range,
+            batch_jobs=[current_job, baseline_job, true_color_job],
+        )
+
+    assert result.indicator_id == "sar"
+    assert result.data_source == "satellite"
+    assert result.confidence == ConfidenceLevel.LOW
+```
+
+- [ ] **Step 5: Run SAR tests to verify they fail**
+
+Run: `pytest tests/test_indicator_sar.py -v -k "batch or harvest"`
+
+Expected: FAIL — `SarIndicator` doesn't have `submit_batch` or `harvest` yet.
+
+- [ ] **Step 6: Commit test file**
+
+```bash
+git add tests/test_indicator_sar.py
+git commit -m "test: add SAR batch submit and harvest tests (red)"
+```
+
+---
+
+### Task 2: SAR Batch — Implementation
+
+**Files:**
+- Modify: `app/indicators/sar.py`
+
+- [ ] **Step 1: Update imports, baseline years, and batch flag**
+
+In `app/indicators/sar.py`, change the import line:
+
+```python
+from app.openeo_client import get_connection, build_sar_graph, build_true_color_graph, _bbox_dict
+```
+
+To:
+
+```python
+from app.openeo_client import get_connection, build_sar_graph, build_true_color_graph, _bbox_dict, submit_as_batch
+```
+
+Change `BASELINE_YEARS = 3` to `BASELINE_YEARS = 5`.
+
+In the `SarIndicator` class, add after `_true_color_path: str | None = None`:
+
+```python
+    uses_batch = True
+```
+
+- [ ] **Step 2: Add _find_tif helper**
+
+Add as a static method in `SarIndicator`, after the `_fallback` method:
+
+```python
+    @staticmethod
+    def _find_tif(download_paths: dict, fallback_dir: str) -> str:
+        """Find the GeoTIFF file from batch job download results."""
+        if download_paths:
+            for p in download_paths:
+                if str(p).endswith(".tif") or str(p).endswith(".tiff"):
+                    return str(p)
+        for f in os.listdir(fallback_dir):
+            if f.endswith(".tif") or f.endswith(".tiff"):
+                return os.path.join(fallback_dir, f)
+        raise FileNotFoundError(f"No GeoTIFF found in {fallback_dir}")
+```
+
+- [ ] **Step 3: Add submit_batch method**
+
+Add after the `_true_color_path` / `uses_batch` declarations, before `process()`:
+
+```python
+    async def submit_batch(
+        self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None
+    ) -> list:
+        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()
+
+        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,
+        )
+
+        return [
+            submit_as_batch(conn, current_cube, f"sar-current-{aoi.name}"),
+            submit_as_batch(conn, baseline_cube, f"sar-baseline-{aoi.name}"),
+            submit_as_batch(conn, true_color_cube, f"sar-truecolor-{aoi.name}"),
+        ]
+```
+
+- [ ] **Step 4: Add harvest method**
+
+Add after `submit_batch()`, before `process()`:
+
+```python
+    async def harvest(
+        self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None,
+        batch_jobs: list | None = None,
+    ) -> IndicatorResult:
+        """Download completed batch job results and compute SAR statistics."""
+        current_job, baseline_job, true_color_job = batch_jobs
+
+        results_dir = tempfile.mkdtemp(prefix="aperture_sar_batch_")
+
+        # Download current SAR — required
+        try:
+            current_dir = os.path.join(results_dir, "current")
+            os.makedirs(current_dir, exist_ok=True)
+            paths = current_job.download_results(current_dir)
+            current_path = self._find_tif(paths, current_dir)
+        except Exception as exc:
+            logger.warning("SAR current batch download failed: %s", exc)
+            return self._fallback(aoi, time_range)
+
+        # Download baseline — optional
+        baseline_path = None
+        try:
+            baseline_dir = os.path.join(results_dir, "baseline")
+            os.makedirs(baseline_dir, exist_ok=True)
+            paths = baseline_job.download_results(baseline_dir)
+            baseline_path = self._find_tif(paths, baseline_dir)
+        except Exception as exc:
+            logger.warning("SAR baseline batch download failed, degrading: %s", exc)
+
+        # Download true-color — optional
+        true_color_path = None
+        try:
+            tc_dir = os.path.join(results_dir, "truecolor")
+            os.makedirs(tc_dir, exist_ok=True)
+            paths = true_color_job.download_results(tc_dir)
+            true_color_path = self._find_tif(paths, tc_dir)
+        except Exception as exc:
+            logger.warning("SAR true-color batch download failed: %s", exc)
+
+        self._true_color_path = true_color_path
+
+        current_stats = self._compute_stats(current_path)
+
+        if current_stats["valid_months"] == 0:
+            return self._insufficient_data(aoi, time_range)
+
+        if baseline_path:
+            baseline_stats = self._compute_stats(baseline_path)
+            change_db = current_stats["overall_vv_mean"] - baseline_stats["overall_vv_mean"]
+            change_pct = self._compute_change_area_pct(
+                current_path, baseline_path, current_stats, baseline_stats
+            )
+            flood_months = self._count_flood_months(
+                current_stats["monthly_vv_means"],
+                baseline_stats["overall_vv_mean"],
+                baseline_stats["vv_std"],
+            )
+            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,
+            )
+
+            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"
+
+            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
+        else:
+            change_db = 0.0
+            change_pct = 0.0
+            flood_months = 0
+            confidence = ConfidenceLevel.LOW
+            chart_data = {
+                "dates": [f"{time_range.end.year}-{m+1:02d}" for m in range(len(current_stats["monthly_vv_means"]))],
+                "values": [round(v, 2) for v in current_stats["monthly_vv_means"]],
+                "label": "VV Backscatter (dB)",
+            }
+            headline = "SAR data available \u2014 baseline unavailable for change detection"
+
+            self._spatial_data = SpatialData(
+                map_type="raster",
+                label="SAR VV (dB)",
+                colormap="gray",
+                vmin=-25, vmax=0,
+            )
+            self._indicator_raster_path = current_path
+            self._render_band = 1
+
+        status = self._classify(change_pct, flood_months)
+        trend = self._compute_trend(current_stats["monthly_vv_means"]) if baseline_path else TrendDirection.STABLE
+
+        return IndicatorResult(
+            indicator_id=self.id,
+            headline=headline,
+            status=status,
+            trend=trend,
+            confidence=confidence,
+            map_layer_path=self._indicator_raster_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\u00b7log\u2081\u2080). "
+                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 \u2212 {FLOOD_SIGMA}\u03c3. "
+                f"Processed via CDSE openEO batch jobs."
+            ),
+            limitations=[
+                f"Resampled to {RESOLUTION_M}m \u2014 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 \u2014 not uniquely flood.",
+            ] + (["Baseline unavailable \u2014 change detection and flood analysis not computed."] if not baseline_path else []),
+        )
+```
+
+- [ ] **Step 5: Run SAR tests**
+
+Run: `pytest tests/test_indicator_sar.py -v`
+
+Expected: ALL PASS
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add app/indicators/sar.py tests/test_indicator_sar.py
+git commit -m "feat: add batch support to SAR indicator"
+```
+
+---
+
+### Task 3: Buildup Batch — Tests
+
+**Files:**
+- Modify: `tests/test_indicator_buildup.py`
+
+- [ ] **Step 1: Add submit_batch test**
+
+Append to `tests/test_indicator_buildup.py`:
+
+```python
+@pytest.mark.asyncio
+async def test_buildup_submit_batch_creates_three_jobs(test_aoi, test_time_range):
+    """submit_batch() creates current, baseline, and true-color batch jobs."""
+    from app.indicators.buildup import BuiltupIndicator
+
+    indicator = BuiltupIndicator()
+
+    mock_conn = MagicMock()
+    mock_job = MagicMock()
+    mock_job.job_id = "j-test"
+    mock_conn.create_job.return_value = mock_job
+
+    with patch("app.indicators.buildup.get_connection", return_value=mock_conn), \
+         patch("app.indicators.buildup.build_buildup_graph") as mock_bu_graph, \
+         patch("app.indicators.buildup.build_true_color_graph") as mock_tc_graph:
+
+        mock_bu_graph.return_value = MagicMock()
+        mock_tc_graph.return_value = MagicMock()
+
+        jobs = await indicator.submit_batch(test_aoi, test_time_range)
+
+    assert len(jobs) == 3
+    assert mock_bu_graph.call_count == 2  # current + baseline
+    assert mock_tc_graph.call_count == 1
+```
+
+- [ ] **Step 2: Add harvest success test**
+
+Append to `tests/test_indicator_buildup.py`:
+
+```python
+@pytest.mark.asyncio
+async def test_buildup_harvest_computes_result_from_batch_jobs(test_aoi, test_time_range):
+    """harvest() downloads batch results and returns 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)
+
+        def make_mock_job(src_path):
+            job = MagicMock()
+            job.job_id = "j-test"
+            def fake_download_results(target):
+                import shutil
+                os.makedirs(target, exist_ok=True)
+                dest = os.path.join(target, "result.tif")
+                shutil.copy(src_path, dest)
+                from pathlib import Path
+                return {Path(dest): {"type": "image/tiff"}}
+            job.download_results.side_effect = fake_download_results
+            job.status.return_value = "finished"
+            return job
+
+        current_job = make_mock_job(ndbi_path)
+        baseline_job = make_mock_job(ndbi_path)
+        true_color_job = make_mock_job(rgb_path)
+
+        result = await indicator.harvest(
+            test_aoi, test_time_range,
+            batch_jobs=[current_job, baseline_job, true_color_job],
+        )
+
+    assert result.indicator_id == "buildup"
+    assert result.data_source == "satellite"
+    assert result.status in (StatusLevel.GREEN, StatusLevel.AMBER, StatusLevel.RED)
+    assert result.confidence in (ConfidenceLevel.HIGH, ConfidenceLevel.MODERATE, ConfidenceLevel.LOW)
+    assert len(result.chart_data.get("dates", [])) > 0
+```
+
+- [ ] **Step 3: Add harvest current-fails test**
+
+Append to `tests/test_indicator_buildup.py`:
+
+```python
+@pytest.mark.asyncio
+async def test_buildup_harvest_falls_back_when_current_fails(test_aoi, test_time_range):
+    """harvest() returns placeholder when current NDBI job failed."""
+    from app.indicators.buildup import BuiltupIndicator
+
+    indicator = BuiltupIndicator()
+
+    current_job = MagicMock()
+    current_job.download_results.side_effect = Exception("failed")
+    baseline_job = MagicMock()
+    true_color_job = MagicMock()
+
+    result = await indicator.harvest(
+        test_aoi, test_time_range,
+        batch_jobs=[current_job, baseline_job, true_color_job],
+    )
+
+    assert result.data_source == "placeholder"
+```
+
+- [ ] **Step 4: Add harvest baseline-fails test**
+
+Append to `tests/test_indicator_buildup.py`:
+
+```python
+@pytest.mark.asyncio
+async def test_buildup_harvest_degrades_when_baseline_fails(test_aoi, test_time_range):
+    """harvest() returns degraded result when baseline NDBI job failed."""
+    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)
+
+        def make_mock_job(src_path, fail=False):
+            job = MagicMock()
+            job.job_id = "j-test"
+            def fake_download_results(target):
+                if fail:
+                    raise Exception("Batch job failed on CDSE")
+                import shutil
+                os.makedirs(target, exist_ok=True)
+                dest = os.path.join(target, "result.tif")
+                shutil.copy(src_path, dest)
+                from pathlib import Path
+                return {Path(dest): {"type": "image/tiff"}}
+            job.download_results.side_effect = fake_download_results
+            job.status.return_value = "finished"
+            return job
+
+        current_job = make_mock_job(ndbi_path)
+        baseline_job = make_mock_job(ndbi_path, fail=True)
+        true_color_job = make_mock_job(rgb_path)
+
+        result = await indicator.harvest(
+            test_aoi, test_time_range,
+            batch_jobs=[current_job, baseline_job, true_color_job],
+        )
+
+    assert result.indicator_id == "buildup"
+    assert result.data_source == "satellite"
+    assert result.confidence == ConfidenceLevel.LOW
+```
+
+- [ ] **Step 5: Run buildup batch tests to verify they fail**
+
+Run: `pytest tests/test_indicator_buildup.py -v -k "batch or harvest"`
+
+Expected: FAIL — `BuiltupIndicator` doesn't have `submit_batch` or `harvest` yet.
+
+- [ ] **Step 6: Commit test file**
+
+```bash
+git add tests/test_indicator_buildup.py
+git commit -m "test: add buildup batch submit and harvest tests (red)"
+```
+
+---
+
+### Task 4: Buildup Batch — Implementation
+
+**Files:**
+- Modify: `app/indicators/buildup.py`
+
+- [ ] **Step 1: Update imports, baseline years, and batch flag**
+
+In `app/indicators/buildup.py`, change the import line:
+
+```python
+from app.openeo_client import get_connection, build_buildup_graph, build_true_color_graph, _bbox_dict
+```
+
+To:
+
+```python
+from app.openeo_client import get_connection, build_buildup_graph, build_true_color_graph, _bbox_dict, submit_as_batch
+```
+
+Change `BASELINE_YEARS = 3` to `BASELINE_YEARS = 5`.
+
+In the `BuiltupIndicator` class, add after `_true_color_path: str | None = None`:
+
+```python
+    uses_batch = True
+```
+
+- [ ] **Step 2: Add _find_tif helper**
+
+Add as a static method in `BuiltupIndicator`, after the `_fallback` method:
+
+```python
+    @staticmethod
+    def _find_tif(download_paths: dict, fallback_dir: str) -> str:
+        """Find the GeoTIFF file from batch job download results."""
+        if download_paths:
+            for p in download_paths:
+                if str(p).endswith(".tif") or str(p).endswith(".tiff"):
+                    return str(p)
+        for f in os.listdir(fallback_dir):
+            if f.endswith(".tif") or f.endswith(".tiff"):
+                return os.path.join(fallback_dir, f)
+        raise FileNotFoundError(f"No GeoTIFF found in {fallback_dir}")
+```
+
+- [ ] **Step 3: Add submit_batch method**
+
+Add after the `uses_batch` declaration, before `process()`:
+
+```python
+    async def submit_batch(
+        self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None
+    ) -> list:
+        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()
+
+        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,
+        )
+
+        return [
+            submit_as_batch(conn, current_cube, f"buildup-current-{aoi.name}"),
+            submit_as_batch(conn, baseline_cube, f"buildup-baseline-{aoi.name}"),
+            submit_as_batch(conn, true_color_cube, f"buildup-truecolor-{aoi.name}"),
+        ]
+```
+
+- [ ] **Step 4: Add harvest method**
+
+Add after `submit_batch()`, before `process()`:
+
+```python
+    async def harvest(
+        self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None,
+        batch_jobs: list | None = None,
+    ) -> IndicatorResult:
+        """Download completed batch job results and compute buildup statistics."""
+        current_job, baseline_job, true_color_job = batch_jobs
+
+        results_dir = tempfile.mkdtemp(prefix="aperture_buildup_batch_")
+
+        # Download current NDBI — required
+        try:
+            current_dir = os.path.join(results_dir, "current")
+            os.makedirs(current_dir, exist_ok=True)
+            paths = current_job.download_results(current_dir)
+            current_path = self._find_tif(paths, current_dir)
+        except Exception as exc:
+            logger.warning("Buildup current batch download failed: %s", exc)
+            return self._fallback(aoi, time_range)
+
+        # Download baseline — optional
+        baseline_path = None
+        try:
+            baseline_dir = os.path.join(results_dir, "baseline")
+            os.makedirs(baseline_dir, exist_ok=True)
+            paths = baseline_job.download_results(baseline_dir)
+            baseline_path = self._find_tif(paths, baseline_dir)
+        except Exception as exc:
+            logger.warning("Buildup baseline batch download failed, degrading: %s", exc)
+
+        # Download true-color — optional
+        true_color_path = None
+        try:
+            tc_dir = os.path.join(results_dir, "truecolor")
+            os.makedirs(tc_dir, exist_ok=True)
+            paths = true_color_job.download_results(tc_dir)
+            true_color_path = self._find_tif(paths, tc_dir)
+        except Exception as exc:
+            logger.warning("Buildup true-color batch download failed: %s", exc)
+
+        self._true_color_path = true_color_path
+
+        current_stats = self._compute_stats(current_path)
+        current_frac = current_stats["overall_buildup_fraction"]
+        aoi_ha = aoi.area_km2 * 100
+
+        if baseline_path:
+            baseline_stats = self._compute_stats(baseline_path)
+            baseline_frac = baseline_stats["overall_buildup_fraction"]
+            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
+
+            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,
+            )
+
+            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} \u2192 {current_ha:.0f} ha) compared to baseline"
+            else:
+                headline = f"Potential settlement contraction: {abs(change_pct):.0f}% decrease in built-up area"
+
+            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
+        else:
+            baseline_frac = current_frac
+            change_pct = 0.0
+            current_ha = current_frac * aoi_ha
+            baseline_ha = current_ha
+            confidence = ConfidenceLevel.LOW
+            chart_data = {
+                "dates": [f"{time_range.end.year}-{m+1:02d}" for m in range(len(current_stats["monthly_buildup_fractions"]))],
+                "values": [round(v * aoi_ha, 1) for v in current_stats["monthly_buildup_fractions"]],
+                "label": "Built-up area (ha)",
+            }
+            headline = f"Built-up extent: {current_frac*100:.1f}% \u2014 baseline unavailable"
+
+            self._spatial_data = SpatialData(
+                map_type="raster",
+                label="NDBI",
+                colormap="PiYG",
+                vmin=-0.5, vmax=0.5,
+            )
+            self._indicator_raster_path = current_path
+            self._render_band = current_stats["peak_buildup_band"]
+
+        status = self._classify(change_pct)
+        trend = self._compute_trend(change_pct) if baseline_path else TrendDirection.STABLE
+
+        return IndicatorResult(
+            indicator_id=self.id,
+            headline=headline,
+            status=status,
+            trend=trend,
+            confidence=confidence,
+            map_layer_path=self._indicator_raster_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 \u2212 B08) / (B11 + B08). "
+                f"Built-up classified as NDBI > {NDBI_THRESHOLD}. "
+                f"Cloud-masked using SCL band. "
+                f"Monthly median composites at {RESOLUTION_M}m. "
+                f"Baseline: {BASELINE_YEARS}-year built-up extent. "
+                f"Processed via CDSE openEO batch jobs."
+            ),
+            limitations=[
+                f"Resampled to {RESOLUTION_M}m \u2014 detects settlement extent, not individual buildings.",
+                "NDBI may confuse bare rock/sand with built-up in arid landscapes.",
+                "Seasonal vegetation cycles can cause false positives at settlement fringes.",
+                "For building-level analysis, the SR4S pipeline (GPU-dependent) would be needed.",
+            ] + (["Baseline unavailable \u2014 change detection not computed."] if not baseline_path else []),
+        )
+```
+
+- [ ] **Step 5: Run buildup tests**
+
+Run: `pytest tests/test_indicator_buildup.py -v`
+
+Expected: ALL PASS
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add app/indicators/buildup.py tests/test_indicator_buildup.py
+git commit -m "feat: add batch support to buildup indicator"
+```
+
+---
+
+### Task 5: Water Batch — Tests
+
+**Files:**
+- Modify: `tests/test_indicator_water.py`
+
+- [ ] **Step 1: Add submit_batch test**
+
+Append to `tests/test_indicator_water.py`:
+
+```python
+@pytest.mark.asyncio
+async def test_water_submit_batch_creates_three_jobs(test_aoi, test_time_range):
+    """submit_batch() creates current, baseline, and true-color batch jobs."""
+    from app.indicators.water import WaterIndicator
+
+    indicator = WaterIndicator()
+
+    mock_conn = MagicMock()
+    mock_job = MagicMock()
+    mock_job.job_id = "j-test"
+    mock_conn.create_job.return_value = mock_job
+
+    with patch("app.indicators.water.get_connection", return_value=mock_conn), \
+         patch("app.indicators.water.build_mndwi_graph") as mock_water_graph, \
+         patch("app.indicators.water.build_true_color_graph") as mock_tc_graph:
+
+        mock_water_graph.return_value = MagicMock()
+        mock_tc_graph.return_value = MagicMock()
+
+        jobs = await indicator.submit_batch(test_aoi, test_time_range)
+
+    assert len(jobs) == 3
+    assert mock_water_graph.call_count == 2  # current + baseline
+    assert mock_tc_graph.call_count == 1
+```
+
+- [ ] **Step 2: Add harvest success test**
+
+Append to `tests/test_indicator_water.py`:
+
+```python
+@pytest.mark.asyncio
+async def test_water_harvest_computes_result_from_batch_jobs(test_aoi, test_time_range):
+    """harvest() downloads batch results and returns IndicatorResult."""
+    from app.indicators.water import WaterIndicator
+
+    indicator = WaterIndicator()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        mndwi_path = os.path.join(tmpdir, "mndwi.tif")
+        rgb_path = os.path.join(tmpdir, "rgb.tif")
+        _mock_mndwi_tif(mndwi_path)
+        _mock_rgb_tif(rgb_path)
+
+        def make_mock_job(src_path):
+            job = MagicMock()
+            job.job_id = "j-test"
+            def fake_download_results(target):
+                import shutil
+                os.makedirs(target, exist_ok=True)
+                dest = os.path.join(target, "result.tif")
+                shutil.copy(src_path, dest)
+                from pathlib import Path
+                return {Path(dest): {"type": "image/tiff"}}
+            job.download_results.side_effect = fake_download_results
+            job.status.return_value = "finished"
+            return job
+
+        current_job = make_mock_job(mndwi_path)
+        baseline_job = make_mock_job(mndwi_path)
+        true_color_job = make_mock_job(rgb_path)
+
+        result = await indicator.harvest(
+            test_aoi, test_time_range,
+            batch_jobs=[current_job, baseline_job, true_color_job],
+        )
+
+    assert result.indicator_id == "water"
+    assert result.data_source == "satellite"
+    assert result.status in (StatusLevel.GREEN, StatusLevel.AMBER, StatusLevel.RED)
+    assert result.confidence in (ConfidenceLevel.HIGH, ConfidenceLevel.MODERATE, ConfidenceLevel.LOW)
+    assert len(result.chart_data.get("dates", [])) > 0
+```
+
+- [ ] **Step 3: Add harvest current-fails test**
+
+Append to `tests/test_indicator_water.py`:
+
+```python
+@pytest.mark.asyncio
+async def test_water_harvest_falls_back_when_current_fails(test_aoi, test_time_range):
+    """harvest() returns placeholder when current MNDWI job failed."""
+    from app.indicators.water import WaterIndicator
+
+    indicator = WaterIndicator()
+
+    current_job = MagicMock()
+    current_job.download_results.side_effect = Exception("failed")
+    baseline_job = MagicMock()
+    true_color_job = MagicMock()
+
+    result = await indicator.harvest(
+        test_aoi, test_time_range,
+        batch_jobs=[current_job, baseline_job, true_color_job],
+    )
+
+    assert result.data_source == "placeholder"
+```
+
+- [ ] **Step 4: Add harvest baseline-fails test**
+
+Append to `tests/test_indicator_water.py`:
+
+```python
+@pytest.mark.asyncio
+async def test_water_harvest_degrades_when_baseline_fails(test_aoi, test_time_range):
+    """harvest() returns degraded result when baseline MNDWI job failed."""
+    from app.indicators.water import WaterIndicator
+
+    indicator = WaterIndicator()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        mndwi_path = os.path.join(tmpdir, "mndwi.tif")
+        rgb_path = os.path.join(tmpdir, "rgb.tif")
+        _mock_mndwi_tif(mndwi_path)
+        _mock_rgb_tif(rgb_path)
+
+        def make_mock_job(src_path, fail=False):
+            job = MagicMock()
+            job.job_id = "j-test"
+            def fake_download_results(target):
+                if fail:
+                    raise Exception("Batch job failed on CDSE")
+                import shutil
+                os.makedirs(target, exist_ok=True)
+                dest = os.path.join(target, "result.tif")
+                shutil.copy(src_path, dest)
+                from pathlib import Path
+                return {Path(dest): {"type": "image/tiff"}}
+            job.download_results.side_effect = fake_download_results
+            job.status.return_value = "finished"
+            return job
+
+        current_job = make_mock_job(mndwi_path)
+        baseline_job = make_mock_job(mndwi_path, fail=True)
+        true_color_job = make_mock_job(rgb_path)
+
+        result = await indicator.harvest(
+            test_aoi, test_time_range,
+            batch_jobs=[current_job, baseline_job, true_color_job],
+        )
+
+    assert result.indicator_id == "water"
+    assert result.data_source == "satellite"
+    assert result.confidence == ConfidenceLevel.LOW
+```
+
+- [ ] **Step 5: Run water batch tests to verify they fail**
+
+Run: `pytest tests/test_indicator_water.py -v -k "batch or harvest"`
+
+Expected: FAIL — `WaterIndicator` doesn't have `submit_batch` or `harvest` yet.
+
+- [ ] **Step 6: Commit test file**
+
+```bash
+git add tests/test_indicator_water.py
+git commit -m "test: add water batch submit and harvest tests (red)"
+```
+
+---
+
+### Task 6: Water Batch — Implementation
+
+**Files:**
+- Modify: `app/indicators/water.py`
+
+- [ ] **Step 1: Update imports, baseline years, and batch flag**
+
+In `app/indicators/water.py`, change the import line:
+
+```python
+from app.openeo_client import get_connection, build_mndwi_graph, build_true_color_graph, _bbox_dict
+```
+
+To:
+
+```python
+from app.openeo_client import get_connection, build_mndwi_graph, build_true_color_graph, _bbox_dict, submit_as_batch
+```
+
+Change `BASELINE_YEARS = 3` to `BASELINE_YEARS = 5`.
+
+In the `WaterIndicator` class, add after `_true_color_path: str | None = None`:
+
+```python
+    uses_batch = True
+```
+
+- [ ] **Step 2: Add _find_tif helper**
+
+Add as a static method in `WaterIndicator`, after the `_fallback` method:
+
+```python
+    @staticmethod
+    def _find_tif(download_paths: dict, fallback_dir: str) -> str:
+        """Find the GeoTIFF file from batch job download results."""
+        if download_paths:
+            for p in download_paths:
+                if str(p).endswith(".tif") or str(p).endswith(".tiff"):
+                    return str(p)
+        for f in os.listdir(fallback_dir):
+            if f.endswith(".tif") or f.endswith(".tiff"):
+                return os.path.join(fallback_dir, f)
+        raise FileNotFoundError(f"No GeoTIFF found in {fallback_dir}")
+```
+
+- [ ] **Step 3: Add submit_batch method**
+
+Add after the `uses_batch` declaration, before `process()`:
+
+```python
+    async def submit_batch(
+        self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None
+    ) -> list:
+        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()
+
+        current_cube = build_mndwi_graph(
+            conn=conn, bbox=bbox,
+            temporal_extent=[current_start, current_end],
+            resolution_m=RESOLUTION_M,
+        )
+        baseline_cube = build_mndwi_graph(
+            conn=conn, bbox=bbox,
+            temporal_extent=[baseline_start, baseline_end],
+            resolution_m=RESOLUTION_M,
+        )
+        true_color_cube = build_true_color_graph(
+            conn=conn, bbox=bbox,
+            temporal_extent=[current_start, current_end],
+            resolution_m=RESOLUTION_M,
+        )
+
+        return [
+            submit_as_batch(conn, current_cube, f"water-current-{aoi.name}"),
+            submit_as_batch(conn, baseline_cube, f"water-baseline-{aoi.name}"),
+            submit_as_batch(conn, true_color_cube, f"water-truecolor-{aoi.name}"),
+        ]
+```
+
+- [ ] **Step 4: Add harvest method**
+
+Add after `submit_batch()`, before `process()`:
+
+```python
+    async def harvest(
+        self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None,
+        batch_jobs: list | None = None,
+    ) -> IndicatorResult:
+        """Download completed batch job results and compute water statistics."""
+        current_job, baseline_job, true_color_job = batch_jobs
+
+        results_dir = tempfile.mkdtemp(prefix="aperture_water_batch_")
+
+        # Download current MNDWI — required
+        try:
+            current_dir = os.path.join(results_dir, "current")
+            os.makedirs(current_dir, exist_ok=True)
+            paths = current_job.download_results(current_dir)
+            current_path = self._find_tif(paths, current_dir)
+        except Exception as exc:
+            logger.warning("Water current batch download failed: %s", exc)
+            return self._fallback(aoi, time_range)
+
+        # Download baseline — optional
+        baseline_path = None
+        try:
+            baseline_dir = os.path.join(results_dir, "baseline")
+            os.makedirs(baseline_dir, exist_ok=True)
+            paths = baseline_job.download_results(baseline_dir)
+            baseline_path = self._find_tif(paths, baseline_dir)
+        except Exception as exc:
+            logger.warning("Water baseline batch download failed, degrading: %s", exc)
+
+        # Download true-color — optional
+        true_color_path = None
+        try:
+            tc_dir = os.path.join(results_dir, "truecolor")
+            os.makedirs(tc_dir, exist_ok=True)
+            paths = true_color_job.download_results(tc_dir)
+            true_color_path = self._find_tif(paths, tc_dir)
+        except Exception as exc:
+            logger.warning("Water true-color batch download failed: %s", exc)
+
+        self._true_color_path = true_color_path
+
+        current_stats = self._compute_stats(current_path)
+        current_frac = current_stats["overall_water_fraction"]
+
+        if baseline_path:
+            baseline_stats = self._compute_stats(baseline_path)
+            baseline_frac = baseline_stats["overall_water_fraction"]
+            change_pp = (current_frac - baseline_frac) * 100
+
+            confidence = (
+                ConfidenceLevel.HIGH if current_stats["valid_months"] >= 6
+                else ConfidenceLevel.MODERATE if current_stats["valid_months"] >= 3
+                else ConfidenceLevel.LOW
+            )
+            chart_data = self._build_chart_data(
+                current_stats["monthly_water_fractions"],
+                baseline_stats["monthly_water_fractions"],
+                time_range,
+            )
+
+            direction = "increase" if change_pp > 0 else "decrease"
+            if abs(change_pp) <= 5:
+                headline = f"Water extent stable ({current_frac*100:.1f}%, \u0394{change_pp:+.1f}pp)"
+            else:
+                headline = f"Water extent {direction} ({change_pp:+.1f}pp vs baseline)"
+        else:
+            baseline_frac = current_frac
+            change_pp = 0.0
+            confidence = ConfidenceLevel.LOW
+            chart_data = {
+                "dates": [f"{time_range.end.year}-{m+1:02d}" for m in range(len(current_stats["monthly_water_fractions"]))],
+                "values": [round(v * 100, 1) for v in current_stats["monthly_water_fractions"]],
+                "label": "Water extent (%)",
+            }
+            headline = f"Water extent: {current_frac*100:.1f}% \u2014 baseline unavailable"
+
+        status = self._classify(abs(change_pp))
+        trend = self._compute_trend(change_pp) if baseline_path else TrendDirection.STABLE
+
+        self._spatial_data = SpatialData(
+            map_type="raster",
+            label="MNDWI",
+            colormap="Blues",
+            vmin=-0.5, vmax=0.5,
+        )
+        self._indicator_raster_path = current_path
+        self._render_band = current_stats["peak_water_band"]
+
+        return IndicatorResult(
+            indicator_id=self.id,
+            headline=headline,
+            status=status,
+            trend=trend,
+            confidence=confidence,
+            map_layer_path=current_path,
+            chart_data=chart_data,
+            data_source="satellite",
+            summary=(
+                f"Water covers {current_frac*100:.1f}% of the AOI compared to "
+                f"{baseline_frac*100:.1f}% baseline ({change_pp:+.1f}pp). "
+                f"Pixel-level MNDWI analysis at {RESOLUTION_M}m resolution."
+            ),
+            methodology=(
+                f"Sentinel-2 L2A pixel-level MNDWI = (B03 \u2212 B11) / (B03 + B11). "
+                f"Cloud-masked using SCL band. Water classified as MNDWI > {WATER_THRESHOLD}. "
+                f"Monthly median composites at {RESOLUTION_M}m. "
+                f"Baseline: {BASELINE_YEARS}-year water extent frequency. "
+                f"Processed via CDSE openEO batch jobs."
+            ),
+            limitations=[
+                f"Resampled to {RESOLUTION_M}m \u2014 small water bodies may be missed.",
+                "Cloud/shadow contamination can cause false water detections.",
+                "Seasonal flooding may appear as change if analysis windows differ.",
+                "MNDWI threshold is fixed; turbid water may be misclassified.",
+            ] + (["Baseline unavailable \u2014 change detection not computed."] if not baseline_path else []),
+        )
+```
+
+- [ ] **Step 5: Run water tests**
+
+Run: `pytest tests/test_indicator_water.py -v`
+
+Expected: ALL PASS
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add app/indicators/water.py tests/test_indicator_water.py
+git commit -m "feat: add batch support to water indicator"
+```
+
+---
+
+### Task 7: Full Test Suite + Final Verification
+
+- [ ] **Step 1: Run the complete test suite**
+
+Run: `pytest tests/ -v`
+
+Expected: ALL PASS — no regressions in existing tests, all new batch tests pass.
+
+- [ ] **Step 2: Verify batch flags are set correctly**
+
+Run: `python -c "from app.indicators.sar import SarIndicator; from app.indicators.buildup import BuiltupIndicator; from app.indicators.water import WaterIndicator; print('SAR:', SarIndicator().uses_batch); print('Buildup:', BuiltupIndicator().uses_batch); print('Water:', WaterIndicator().uses_batch)"`
+
+Expected:
+```
+SAR: True
+Buildup: True
+Water: True
+```
+
+- [ ] **Step 3: Verify baseline years are standardized**
+
+Run: `python -c "from app.indicators.sar import BASELINE_YEARS as s; from app.indicators.buildup import BASELINE_YEARS as b; from app.indicators.water import BASELINE_YEARS as w; from app.indicators.ndvi import BASELINE_YEARS as n; print(f'NDVI={n}, SAR={s}, Buildup={b}, Water={w}')"`
+
+Expected: `NDVI=5, SAR=5, Buildup=5, Water=5`
+
+- [ ] **Step 4: Commit any remaining changes**
+
+If all tests pass and no changes remain, this step is a no-op.