docs: add Phase 2 implementation plan for analysis window and monthly refactor

11 tasks: data model season fields, frontend month picker, worker
plumbing, 6 indicator refactors to monthly chart data, fires season
filter, full verification.

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-analysis-window-monthly-refactor.md

@@ -0,0 +1,1236 @@
+# Phase 2: Analysis Window & Monthly Indicator Refactor — 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:** Let users select an analysis season (start/end month with year-boundary wrap), refactor all indicators to output monthly chart data within that window, and upgrade baseline overlays to full monthly band+line.
+
+**Architecture:** Add `season_start`/`season_end` to `JobRequest` (flows through `TimeRange`), add month picker dropdowns to the frontend's "Define Area" page, refactor each indicator's data-fetching and chart-building to produce monthly `chart_data` aligned to the user's season. The Phase 1 chart renderer already handles monthly baseline arrays — no chart renderer changes needed.
+
+**Tech Stack:** Python 3.11 (Pydantic models, FastAPI), vanilla JS frontend, Open-Meteo API, STAC/pystac-client, matplotlib
+
+---
+
+## File Map
+
+| File | Action | Responsibility |
+|------|--------|----------------|
+| `app/models.py` | Modify | Add `season_start`, `season_end` to `JobRequest` + `season_months()` helper |
+| `tests/test_models.py` | Modify | Test season fields, wrap logic, defaults |
+| `frontend/index.html` | Modify | Add month picker dropdowns to "Define Area" page |
+| `frontend/js/app.js` | Modify | Capture season values in state, include in POST payload, show in confirm |
+| `app/indicators/vegetation.py` | Modify | Output monthly chart data, accept season_months |
+| `app/indicators/cropland.py` | Modify | Remove `GROWING_SEASON`, use season_months, output monthly |
+| `app/indicators/water.py` | Modify | Output monthly chart data, accept season_months |
+| `app/indicators/rainfall.py` | Modify | Filter to season_months, pass monthly baseline arrays |
+| `app/indicators/lst.py` | Modify | Aggregate daily→monthly, output monthly chart data |
+| `app/indicators/no2.py` | Modify | Aggregate hourly→monthly, output monthly chart data |
+| `app/indicators/fires.py` | Modify | Filter chart output to season_months |
+| `app/indicators/base.py` | Modify | Update `process()` signature to accept season_months |
+| `app/worker.py` | Modify | Pass season_months from job request to indicator.process() |
+| `tests/test_indicator_vegetation.py` | Modify | Test monthly chart output |
+| `tests/test_indicator_cropland.py` | Modify | Test monthly chart output, no more GROWING_SEASON |
+| `tests/test_indicator_water.py` | Modify | Test monthly chart output |
+| `tests/test_indicator_rainfall.py` | Modify | Test season filtering |
+| `tests/test_indicator_lst.py` | Modify | Test monthly chart output |
+| `tests/test_indicator_no2.py` | Modify | Test monthly chart output |
+
+---
+
+### Task 1: Add Season Fields to Data Model
+
+**Files:**
+- Modify: `app/models.py:91-96` (JobRequest)
+- Modify: `tests/test_models.py`
+
+- [ ] **Step 1: Write tests for season fields**
+
+Add to `tests/test_models.py`:
+
+```python
+from app.models import JobRequest, AOI, TimeRange
+from datetime import date
+
+
+def test_job_request_season_defaults():
+    """Default season is full year (1-12)."""
+    req = JobRequest(
+        aoi=AOI(name="Test", bbox=[36.75, -1.35, 36.95, -1.20]),
+        indicator_ids=["fires"],
+        email="t@t.com",
+    )
+    assert req.season_start == 1
+    assert req.season_end == 12
+
+
+def test_job_request_season_months_normal():
+    """Non-wrapping season: Apr-Sep."""
+    req = JobRequest(
+        aoi=AOI(name="Test", bbox=[36.75, -1.35, 36.95, -1.20]),
+        indicator_ids=["fires"],
+        email="t@t.com",
+        season_start=4,
+        season_end=9,
+    )
+    assert req.season_months() == [4, 5, 6, 7, 8, 9]
+
+
+def test_job_request_season_months_wrapping():
+    """Wrapping season: Oct-Mar (Southern Hemisphere)."""
+    req = JobRequest(
+        aoi=AOI(name="Test", bbox=[36.75, -1.35, 36.95, -1.20]),
+        indicator_ids=["fires"],
+        email="t@t.com",
+        season_start=10,
+        season_end=3,
+    )
+    assert req.season_months() == [10, 11, 12, 1, 2, 3]
+
+
+def test_job_request_season_months_full_year():
+    """Full year default."""
+    req = JobRequest(
+        aoi=AOI(name="Test", bbox=[36.75, -1.35, 36.95, -1.20]),
+        indicator_ids=["fires"],
+        email="t@t.com",
+    )
+    assert req.season_months() == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+
+
+def test_job_request_season_validation():
+    """Season months must be 1-12."""
+    import pytest
+    with pytest.raises(Exception):
+        JobRequest(
+            aoi=AOI(name="Test", bbox=[36.75, -1.35, 36.95, -1.20]),
+            indicator_ids=["fires"],
+            email="t@t.com",
+            season_start=0,
+        )
+    with pytest.raises(Exception):
+        JobRequest(
+            aoi=AOI(name="Test", bbox=[36.75, -1.35, 36.95, -1.20]),
+            indicator_ids=["fires"],
+            email="t@t.com",
+            season_end=13,
+        )
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_models.py -v -k season`
+
+Expected: FAIL — `JobRequest` doesn't have `season_start`/`season_end` fields.
+
+- [ ] **Step 3: Add season fields to JobRequest**
+
+In `app/models.py`, modify the `JobRequest` class (lines 91-96):
+
+```python
+class JobRequest(BaseModel):
+    aoi: AOI
+    time_range: TimeRange = Field(default_factory=TimeRange)
+    indicator_ids: list[str]
+    email: str
+    season_start: int = Field(default=1, ge=1, le=12)
+    season_end: int = Field(default=12, ge=1, le=12)
+
+    def season_months(self) -> list[int]:
+        """Return ordered list of month numbers in the analysis season.
+
+        Supports year-boundary wrapping: season_start=10, season_end=3
+        yields [10, 11, 12, 1, 2, 3].
+        """
+        if self.season_start <= self.season_end:
+            return list(range(self.season_start, self.season_end + 1))
+        else:
+            return list(range(self.season_start, 13)) + list(range(1, self.season_end + 1))
+
+    @field_validator("indicator_ids")
+    @classmethod
+    def require_at_least_one_indicator(cls, v: list[str]) -> list[str]:
+        if len(v) == 0:
+            raise ValueError("At least one indicator must be selected")
+        return v
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_models.py -v`
+
+Expected: All PASS (both old and new tests).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add app/models.py tests/test_models.py
+git commit -m "feat: add season_start/season_end to JobRequest with wrap support"
+```
+
+---
+
+### Task 2: Add Month Picker to Frontend
+
+**Files:**
+- Modify: `frontend/index.html:229-242` (date range section in "Define Area" sidebar)
+- Modify: `frontend/js/app.js:248` (state capture), `frontend/js/app.js:307-318` (payload), `frontend/js/app.js:280-286` (confirm summary)
+
+- [ ] **Step 1: Add month picker HTML to the "Define Area" sidebar**
+
+In `frontend/index.html`, after the date range section (after line 242 — the closing `</div>` of the date-row form-group), add:
+
+```html
+      <!-- Analysis season -->
+      <div class="form-group">
+        <label class="label">Analysis season</label>
+        <p style="font-size: var(--text-xxs); color: var(--ink-muted); margin-bottom: var(--space-3);">
+          Select the months relevant to your analysis. For year-round monitoring, leave as January–December.
+        </p>
+        <div class="date-row">
+          <div>
+            <label class="label" for="season-start" style="font-size: var(--text-xxs);">Start month</label>
+            <select id="season-start" class="input">
+              <option value="1" selected>January</option>
+              <option value="2">February</option>
+              <option value="3">March</option>
+              <option value="4">April</option>
+              <option value="5">May</option>
+              <option value="6">June</option>
+              <option value="7">July</option>
+              <option value="8">August</option>
+              <option value="9">September</option>
+              <option value="10">October</option>
+              <option value="11">November</option>
+              <option value="12">December</option>
+            </select>
+          </div>
+          <div>
+            <label class="label" for="season-end" style="font-size: var(--text-xxs);">End month</label>
+            <select id="season-end" class="input">
+              <option value="1">January</option>
+              <option value="2">February</option>
+              <option value="3">March</option>
+              <option value="4">April</option>
+              <option value="5">May</option>
+              <option value="6">June</option>
+              <option value="7">July</option>
+              <option value="8">August</option>
+              <option value="9">September</option>
+              <option value="10">October</option>
+              <option value="11">November</option>
+              <option value="12" selected>December</option>
+            </select>
+          </div>
+        </div>
+        <p id="season-wrap-hint" style="font-size: var(--text-xxs); color: var(--iris); margin-top: var(--space-2); display: none;">
+          ↻ Season crosses year boundary
+        </p>
+      </div>
+```
+
+- [ ] **Step 2: Add wrap-hint logic and capture season in state**
+
+In `frontend/js/app.js`, inside `setupDefineArea()` function, after the date default lines (after line 239), add:
+
+```javascript
+  // Season wrap hint
+  const seasonStart = document.getElementById('season-start');
+  const seasonEnd = document.getElementById('season-end');
+  const wrapHint = document.getElementById('season-wrap-hint');
+
+  function updateWrapHint() {
+    const s = parseInt(seasonStart.value);
+    const e = parseInt(seasonEnd.value);
+    wrapHint.style.display = (s > e) ? '' : 'none';
+  }
+  seasonStart.addEventListener('change', updateWrapHint);
+  seasonEnd.addEventListener('change', updateWrapHint);
+```
+
+Then in the continue button click handler (around line 248 `state.timeRange = ...`), add after that line:
+
+```javascript
+    state.seasonStart = parseInt(document.getElementById('season-start').value);
+    state.seasonEnd = parseInt(document.getElementById('season-end').value);
+```
+
+- [ ] **Step 3: Add season to state object**
+
+In `frontend/js/app.js`, update the state object (line 13-20) to include season:
+
+```javascript
+const state = {
+  session: null,    // { email, token }
+  aoi: null,        // { name, bbox }
+  timeRange: null,  // { start, end }
+  seasonStart: 1,   // 1-12
+  seasonEnd: 12,    // 1-12
+  indicators: [],   // string[]
+  jobId: null,      // string
+  jobData: null,    // full job response
+};
+```
+
+- [ ] **Step 4: Include season in POST payload**
+
+In `frontend/js/app.js`, update the submit payload (around line 307-318):
+
+```javascript
+    const payload = {
+      aoi: {
+        name: state.aoi.name,
+        bbox: state.aoi.bbox,
+      },
+      time_range: {
+        start: state.timeRange.start,
+        end:   state.timeRange.end,
+      },
+      indicator_ids: state.indicators,
+      email,
+      season_start: state.seasonStart,
+      season_end: state.seasonEnd,
+    };
+```
+
+- [ ] **Step 5: Show season in confirm summary**
+
+In `frontend/index.html`, inside the confirm summary div (after the "Period" confirm-row, around line 345), add:
+
+```html
+      <div class="confirm-row">
+        <span class="confirm-row-label">Season</span>
+        <span id="confirm-season" class="confirm-row-value">January – December</span>
+      </div>
+```
+
+In `frontend/js/app.js`, inside `setupConfirm()` (around line 286), add:
+
+```javascript
+  const monthNames = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'];
+  const seasonText = `${monthNames[state.seasonStart - 1]} – ${monthNames[state.seasonEnd - 1]}`;
+  document.getElementById('confirm-season').textContent = seasonText;
+```
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add frontend/index.html frontend/js/app.js
+git commit -m "feat: add analysis season month picker to frontend"
+```
+
+---
+
+### Task 3: Update Worker to Pass Season Months to Indicators
+
+**Files:**
+- Modify: `app/indicators/base.py:42-44` (process signature)
+- Modify: `app/worker.py:58` (process call)
+- Modify: `tests/test_worker.py`
+
+- [ ] **Step 1: Write test for worker passing season_months**
+
+Add to `tests/test_worker.py`:
+
+```python
+@pytest.mark.asyncio
+async def test_process_job_passes_season_months(temp_db_path):
+    """Worker should pass season_months from job request to indicator.process()."""
+    from unittest.mock import AsyncMock, MagicMock, patch
+    from app.database import Database
+    from app.indicators.base import IndicatorRegistry
+    from app.models import JobRequest, AOI, TimeRange, IndicatorResult, StatusLevel, TrendDirection, ConfidenceLevel
+    from app.worker import process_job
+    from datetime import date
+
+    db = Database(temp_db_path)
+    await db.init()
+
+    req = JobRequest(
+        aoi=AOI(name="Test", bbox=[36.75, -1.35, 36.95, -1.20]),
+        time_range=TimeRange(start=date(2025, 3, 1), end=date(2026, 3, 1)),
+        indicator_ids=["fires"],
+        email="test@example.com",
+        season_start=4,
+        season_end=9,
+    )
+    job_id = await db.create_job(req)
+
+    mock_indicator = MagicMock()
+    mock_result = IndicatorResult(
+        indicator_id="fires",
+        headline="test",
+        status=StatusLevel.GREEN,
+        trend=TrendDirection.STABLE,
+        confidence=ConfidenceLevel.MODERATE,
+        map_layer_path="",
+        chart_data={"dates": [], "values": []},
+        summary="test",
+        methodology="test",
+        limitations=[],
+    )
+    mock_indicator.process = AsyncMock(return_value=mock_result)
+    mock_indicator.get_spatial_data = MagicMock(return_value=None)
+
+    mock_registry = MagicMock(spec=IndicatorRegistry)
+    mock_registry.get.return_value = mock_indicator
+
+    with patch("app.worker.render_timeseries_chart"), \
+         patch("app.worker.render_status_map"), \
+         patch("app.worker.generate_pdf_report"), \
+         patch("app.worker.create_data_package"), \
+         patch("app.worker.send_completion_email", new_callable=AsyncMock):
+        await process_job(job_id, db, mock_registry)
+
+    # Verify season_months was passed
+    mock_indicator.process.assert_called_once()
+    call_kwargs = mock_indicator.process.call_args
+    assert call_kwargs[1].get("season_months") == [4, 5, 6, 7, 8, 9] or \
+           (len(call_kwargs[0]) >= 3 and call_kwargs[0][2] == [4, 5, 6, 7, 8, 9])
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_worker.py::test_process_job_passes_season_months -v`
+
+Expected: FAIL.
+
+- [ ] **Step 3: Update BaseIndicator.process() signature**
+
+In `app/indicators/base.py`, change the abstract method (line 42-44):
+
+```python
+    @abc.abstractmethod
+    async def process(self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None) -> IndicatorResult:
+        ...
+```
+
+- [ ] **Step 4: Update worker to pass season_months**
+
+In `app/worker.py`, update line 58:
+
+```python
+            result = await indicator.process(
+                job.request.aoi,
+                job.request.time_range,
+                season_months=job.request.season_months(),
+            )
+```
+
+- [ ] **Step 5: Update all indicator process() signatures to accept season_months**
+
+In each indicator file, update the `process` method signature to accept the new parameter. This is a mechanical change — add `season_months: list[int] | None = None` to each `async def process(self, aoi, time_range, ...)`:
+
+- `app/indicators/vegetation.py`: `async def process(self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None)`
+- `app/indicators/cropland.py`: same
+- `app/indicators/water.py`: same
+- `app/indicators/rainfall.py`: same
+- `app/indicators/lst.py`: same
+- `app/indicators/no2.py`: same
+- `app/indicators/nightlights.py`: same
+- `app/indicators/fires.py`: same
+- `app/indicators/food_security.py`: same
+
+For now, all indicators just accept the parameter and ignore it. Later tasks will make them use it.
+
+- [ ] **Step 6: Run tests**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_worker.py -v`
+
+Expected: All PASS.
+
+- [ ] **Step 7: Run full test suite to verify no regressions**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/ -v`
+
+Expected: All 109+ tests PASS.
+
+- [ ] **Step 8: Commit**
+
+```bash
+git add app/indicators/base.py app/worker.py app/indicators/*.py tests/test_worker.py
+git commit -m "feat: pass season_months from job request to indicator.process()"
+```
+
+---
+
+### Task 4: Refactor Vegetation to Monthly Chart Data
+
+**Files:**
+- Modify: `app/indicators/vegetation.py`
+- Modify: `tests/test_indicator_vegetation.py`
+
+- [ ] **Step 1: Write test for monthly chart output**
+
+Add to `tests/test_indicator_vegetation.py`:
+
+```python
+def test_build_monthly_chart_data():
+    """When monthly data is available, chart_data should have per-month arrays."""
+    from app.indicators.vegetation import VegetationIndicator
+    from datetime import date
+    from app.models import TimeRange
+
+    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
+    current_monthly = {1: 30.0, 2: 32.0, 3: 35.0, 4: 38.0, 5: 40.0, 6: 42.0}
+    baseline_pool = {
+        1: {"medians": [28.0, 30.0, 32.0], "min": 28.0, "max": 32.0, "mean": 30.0},
+        2: {"medians": [30.0, 32.0, 34.0], "min": 30.0, "max": 34.0, "mean": 32.0},
+        3: {"medians": [33.0, 35.0, 37.0], "min": 33.0, "max": 37.0, "mean": 35.0},
+        4: {"medians": [36.0, 38.0, 40.0], "min": 36.0, "max": 40.0, "mean": 38.0},
+        5: {"medians": [38.0, 40.0, 42.0], "min": 38.0, "max": 42.0, "mean": 40.0},
+        6: {"medians": [40.0, 42.0, 44.0], "min": 40.0, "max": 44.0, "mean": 42.0},
+    }
+    season_months = [1, 2, 3, 4, 5, 6]
+    result = VegetationIndicator._build_monthly_chart_data(
+        current_monthly=current_monthly,
+        baseline_stats=baseline_pool,
+        time_range=tr,
+        season_months=season_months,
+    )
+    assert len(result["dates"]) == 6
+    assert all(d.startswith("2025-") for d in result["dates"])
+    assert len(result["values"]) == 6
+    assert "baseline_mean" in result
+    assert "baseline_min" in result
+    assert "baseline_max" in result
+    assert len(result["baseline_mean"]) == 6
+    for i in range(6):
+        assert result["baseline_min"][i] <= result["baseline_mean"][i] <= result["baseline_max"][i]
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_indicator_vegetation.py::test_build_monthly_chart_data -v`
+
+Expected: FAIL — `_build_monthly_chart_data` doesn't exist yet.
+
+- [ ] **Step 3: Add `_build_monthly_chart_data` and refactor `_stac_comparison` to expose monthly data**
+
+In `app/indicators/vegetation.py`, the `_stac_comparison` method currently computes monthly medians but collapses them. Refactor to preserve per-month data for the chart.
+
+Change `_stac_comparison` to also store `self._current_monthly` and `self._baseline_stats` before collapsing:
+
+After building `baseline_pool` and computing `baseline_medians`/`current_medians` (lines 202-221), add before the return:
+
+```python
+        # Store monthly data for chart rendering
+        self._current_monthly = {}
+        for month in range(1, 13):
+            c_vals = current_monthly.get(month, [])
+            if c_vals:
+                self._current_monthly[month] = float(np.median(c_vals))
+
+        self._baseline_stats = {}
+        for month in range(1, 13):
+            b_vals = baseline_pool.get(month, [])
+            if b_vals:
+                # Group by year to get per-year medians, then compute stats
+                self._baseline_stats[month] = {
+                    "mean": float(np.mean([np.median(b_vals)])),
+                    "min": float(np.min(b_vals)),
+                    "max": float(np.max(b_vals)),
+                }
+```
+
+Wait — `baseline_pool[month]` is a flat list of all scene values across years, not grouped by year. We need per-year stats. Refactor to track per-year medians:
+
+Replace the baseline loop (lines 202-212) with:
+
+```python
+        baseline_pool: dict[int, list[float]] = defaultdict(list)
+        baseline_yearly_means: list[float] = []
+        baseline_per_year_monthly: dict[int, list[float]] = defaultdict(list)  # month -> [yr1_median, yr2_median, ...]
+        for yr in range(baseline_start_year, current_year):
+            yr_monthly = await loop.run_in_executor(None, _query_monthly, yr)
+            yr_medians = []
+            for month, vals in yr_monthly.items():
+                baseline_pool[month].extend(vals)
+                if vals:
+                    med = float(np.median(vals))
+                    yr_medians.append(med)
+                    baseline_per_year_monthly[month].append(med)
+            if yr_medians:
+                baseline_yearly_means.append(float(np.mean(yr_medians)))
+```
+
+Then store monthly chart data before the return:
+
+```python
+        # Store monthly data for chart building
+        self._current_monthly_medians = {}
+        for month in range(1, 13):
+            c_vals = current_monthly.get(month, [])
+            if c_vals:
+                self._current_monthly_medians[month] = float(np.median(c_vals))
+
+        self._baseline_per_year_monthly = dict(baseline_per_year_monthly)
+```
+
+Add the new static method:
+
+```python
+    @staticmethod
+    def _build_monthly_chart_data(
+        current_monthly: dict[int, float],
+        baseline_stats: dict[int, list[float]],
+        time_range: TimeRange,
+        season_months: list[int],
+    ) -> dict[str, Any]:
+        """Build monthly chart data with baseline arrays for the given season."""
+        year = time_range.end.year
+        dates = []
+        values = []
+        b_mean = []
+        b_min = []
+        b_max = []
+        for m in season_months:
+            dates.append(f"{year}-{m:02d}")
+            values.append(round(current_monthly.get(m, 0.0), 1))
+            yr_medians = baseline_stats.get(m, [])
+            if yr_medians:
+                b_mean.append(round(float(np.mean(yr_medians)), 1))
+                b_min.append(round(float(min(yr_medians)), 1))
+                b_max.append(round(float(max(yr_medians)), 1))
+            else:
+                b_mean.append(0.0)
+                b_min.append(0.0)
+                b_max.append(0.0)
+        result: dict[str, Any] = {
+            "dates": dates,
+            "values": values,
+            "label": "Vegetation cover (%)",
+        }
+        if any(v > 0 for v in b_mean):
+            result["baseline_mean"] = b_mean
+            result["baseline_min"] = b_min
+            result["baseline_max"] = b_max
+        return result
+```
+
+- [ ] **Step 4: Update process() to use monthly chart data when season_months is provided**
+
+In `app/indicators/vegetation.py`, update the `process()` method. After `_fetch_comparison` returns (line 31-43), change the chart_data building:
+
+```python
+        # Build chart data — monthly if season provided, 2-point fallback otherwise
+        if season_months and hasattr(self, '_current_monthly_medians') and hasattr(self, '_baseline_per_year_monthly'):
+            chart_data = self._build_monthly_chart_data(
+                self._current_monthly_medians,
+                self._baseline_per_year_monthly,
+                time_range,
+                season_months,
+            )
+        else:
+            chart_data = self._build_chart_data(
+                baseline_mean, current_mean, time_range,
+                getattr(self, '_baseline_yearly_means', None),
+            )
+```
+
+- [ ] **Step 5: Run vegetation tests**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_indicator_vegetation.py -v`
+
+Expected: All PASS.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add app/indicators/vegetation.py tests/test_indicator_vegetation.py
+git commit -m "feat: vegetation outputs monthly chart data with baseline arrays"
+```
+
+---
+
+### Task 5: Refactor Cropland to Monthly Chart Data (Remove GROWING_SEASON)
+
+**Files:**
+- Modify: `app/indicators/cropland.py`
+- Modify: `tests/test_indicator_cropland.py`
+
+- [ ] **Step 1: Write test for monthly chart output**
+
+Add to `tests/test_indicator_cropland.py`:
+
+```python
+def test_build_monthly_chart_data():
+    """Cropland monthly chart data should respect season_months."""
+    from app.indicators.cropland import CroplandIndicator
+    from datetime import date
+    from app.models import TimeRange
+
+    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
+    current_monthly = {4: 35.0, 5: 40.0, 6: 42.0, 7: 41.0, 8: 38.0, 9: 34.0}
+    baseline_stats = {
+        4: [33.0, 35.0, 37.0],
+        5: [38.0, 40.0, 42.0],
+        6: [40.0, 42.0, 44.0],
+        7: [39.0, 41.0, 43.0],
+        8: [36.0, 38.0, 40.0],
+        9: [32.0, 34.0, 36.0],
+    }
+    season_months = [4, 5, 6, 7, 8, 9]
+    result = CroplandIndicator._build_monthly_chart_data(
+        current_monthly=current_monthly,
+        baseline_stats=baseline_stats,
+        time_range=tr,
+        season_months=season_months,
+    )
+    assert len(result["dates"]) == 6
+    assert result["dates"][0] == "2025-04"
+    assert result["dates"][-1] == "2025-09"
+    assert "baseline_mean" in result
+    assert len(result["baseline_mean"]) == 6
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_indicator_cropland.py::test_build_monthly_chart_data -v`
+
+Expected: FAIL.
+
+- [ ] **Step 3: Refactor cropland — same pattern as vegetation**
+
+In `app/indicators/cropland.py`:
+
+1. Remove the `GROWING_SEASON` constant (line 22). The season filtering is now done by `season_months` passed in.
+
+2. Update `_stac_comparison` — currently uses `_query_growing_season` which hardcodes Apr-Sep. Change to `_query_monthly` that accepts season_months:
+
+Replace `_query_growing_season` (lines 195-213) with a general `_query_months`:
+
+```python
+        def _query_months(year: int, months: list[int]) -> dict[int, list[float]]:
+            """Return {month: [vegetation_pct, ...]} for specified months only."""
+            min_month = min(months)
+            max_month = max(months)
+            start = date(year, min_month, 1)
+            # Handle last day of month
+            if max_month == 12:
+                end = date(year, 12, 31)
+            else:
+                end = date(year, max_month + 1, 1) - timedelta(days=1)
+            items = catalog.search(
+                collections=["sentinel-2-l2a"],
+                bbox=aoi.bbox,
+                datetime=f"{start.isoformat()}/{end.isoformat()}",
+                query={"eo:cloud_cover": {"lt": 30}},
+                max_items=MAX_ITEMS,
+            ).item_collection()
+            by_month: dict[int, list[float]] = defaultdict(list)
+            for item in items:
+                veg = item.properties.get("s2:vegetation_percentage")
+                if veg is not None and item.datetime:
+                    month = item.datetime.month
+                    if month in months:
+                        by_month[month].append(float(veg))
+            return dict(by_month)
+```
+
+Add `from datetime import date, timedelta` at the top if not already imported.
+
+3. Update `_stac_comparison` to accept and use `season_months`:
+
+```python
+    async def _stac_comparison(
+        self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None
+    ) -> tuple[float, float, int]:
+```
+
+Use `season_months or list(range(1, 13))` as the months to query. Track per-year monthly medians same as vegetation.
+
+4. Add `_build_monthly_chart_data` — identical logic to vegetation but with label `"Vegetation cover (%)"` (cropland uses same unit).
+
+5. Update `process()` to pass `season_months` through to `_stac_comparison` and use `_build_monthly_chart_data`.
+
+6. Also update `_fetch_tile_footprints` to respect season_months (query only the selected months for the current year).
+
+- [ ] **Step 4: Run cropland tests**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_indicator_cropland.py -v`
+
+Expected: All PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add app/indicators/cropland.py tests/test_indicator_cropland.py
+git commit -m "feat: cropland uses season_months instead of hardcoded GROWING_SEASON, outputs monthly chart data"
+```
+
+---
+
+### Task 6: Refactor Water to Monthly Chart Data
+
+**Files:**
+- Modify: `app/indicators/water.py`
+- Modify: `tests/test_indicator_water.py`
+
+Same pattern as vegetation. The `_stac_comparison` method is nearly identical to vegetation's.
+
+- [ ] **Step 1: Write test for monthly chart output**
+
+Add to `tests/test_indicator_water.py`:
+
+```python
+def test_build_monthly_chart_data():
+    from app.indicators.water import WaterIndicator
+    from datetime import date
+    from app.models import TimeRange
+
+    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
+    current_monthly = {1: 5.0, 2: 5.2, 3: 4.8}
+    baseline_stats = {1: [4.5, 5.0, 5.5], 2: [4.8, 5.2, 5.6], 3: [4.3, 4.8, 5.3]}
+    season_months = [1, 2, 3]
+    result = WaterIndicator._build_monthly_chart_data(
+        current_monthly=current_monthly,
+        baseline_stats=baseline_stats,
+        time_range=tr,
+        season_months=season_months,
+    )
+    assert len(result["dates"]) == 3
+    assert "baseline_mean" in result
+    assert len(result["baseline_mean"]) == 3
+```
+
+- [ ] **Step 2: Implement — same pattern as vegetation Task 4**
+
+Refactor `_stac_comparison` to track `_baseline_per_year_monthly` and `_current_monthly_medians`. Add `_build_monthly_chart_data`. Update `process()` to use monthly chart data when `season_months` is provided. Water uses 2 decimal places for rounding.
+
+- [ ] **Step 3: Run water tests**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_indicator_water.py -v`
+
+Expected: All PASS.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add app/indicators/water.py tests/test_indicator_water.py
+git commit -m "feat: water outputs monthly chart data with baseline arrays"
+```
+
+---
+
+### Task 7: Refactor Rainfall to Filter by Season Months
+
+**Files:**
+- Modify: `app/indicators/rainfall.py`
+- Modify: `tests/test_indicator_rainfall.py`
+
+Rainfall already outputs monthly chart data. The change is to filter to `season_months` only.
+
+- [ ] **Step 1: Write test for season filtering**
+
+Add to `tests/test_indicator_rainfall.py`:
+
+```python
+def test_build_chart_data_filters_by_season():
+    """Chart data should only include months in the season."""
+    from app.indicators.rainfall import RainfallIndicator
+
+    current = {f"2025-{m:02d}": float(m * 10) for m in range(1, 13)}
+    baseline = {f"2025-{m:02d}": float(m * 9) for m in range(1, 13)}
+    baseline_per_year = {f"{m:02d}": [float(m * 8), float(m * 9), float(m * 10)] for m in range(1, 13)}
+    season_months = [4, 5, 6, 7, 8, 9]
+    result = RainfallIndicator._build_chart_data(current, baseline, baseline_per_year, season_months)
+    assert len(result["dates"]) == 6
+    assert result["dates"][0] == "2025-04"
+    assert result["dates"][-1] == "2025-09"
+    assert len(result["baseline_mean"]) == 6
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_indicator_rainfall.py::test_build_chart_data_filters_by_season -v`
+
+Expected: FAIL — `_build_chart_data` doesn't accept `season_months`.
+
+- [ ] **Step 3: Update `_build_chart_data` to accept and filter by season_months**
+
+In `app/indicators/rainfall.py`, update `_build_chart_data`:
+
+```python
+    @staticmethod
+    def _build_chart_data(
+        current: dict[str, float],
+        baseline: dict[str, float],
+        baseline_per_year: dict[str, list[float]] | None = None,
+        season_months: list[int] | None = None,
+    ) -> dict[str, Any]:
+        all_keys = sorted(set(list(current.keys()) + list(baseline.keys())))
+        # Filter to season months if provided
+        if season_months:
+            all_keys = [k for k in all_keys if int(k.split("-")[1]) in season_months]
+        result: dict[str, Any] = {
+            "dates": all_keys,
+            "values": [current.get(k, baseline.get(k, 0.0)) for k in all_keys],
+            "baseline_values": [baseline.get(k, 0.0) for k in all_keys],
+            "label": "Monthly rainfall (mm)",
+        }
+        if baseline_per_year:
+            b_mean: list[float] = []
+            b_min: list[float] = []
+            b_max: list[float] = []
+            for k in all_keys:
+                month_num = k.split("-")[1]
+                year_vals = baseline_per_year.get(month_num, [])
+                if year_vals:
+                    b_mean.append(float(np.mean(year_vals)))
+                    b_min.append(float(min(year_vals)))
+                    b_max.append(float(max(year_vals)))
+                else:
+                    fallback = baseline.get(k, 0.0)
+                    b_mean.append(fallback)
+                    b_min.append(fallback)
+                    b_max.append(fallback)
+            result["baseline_mean"] = b_mean
+            result["baseline_min"] = b_min
+            result["baseline_max"] = b_max
+        return result
+```
+
+- [ ] **Step 4: Update caller in process() to pass season_months**
+
+```python
+        chart_data = self._build_chart_data(
+            current_monthly, baseline_monthly,
+            getattr(self, '_baseline_per_year', None),
+            season_months,
+        )
+```
+
+- [ ] **Step 5: Run rainfall tests**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_indicator_rainfall.py -v`
+
+Expected: All PASS.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add app/indicators/rainfall.py tests/test_indicator_rainfall.py
+git commit -m "feat: rainfall filters chart data to season_months"
+```
+
+---
+
+### Task 8: Refactor LST to Monthly Chart Data
+
+**Files:**
+- Modify: `app/indicators/lst.py`
+- Modify: `tests/test_indicator_lst.py`
+
+LST currently queries daily data from Open-Meteo but collapses to a single annual mean. Refactor to aggregate daily→monthly and output per-month chart data.
+
+- [ ] **Step 1: Write test for monthly chart output**
+
+Add to `tests/test_indicator_lst.py`:
+
+```python
+def test_build_monthly_chart_data():
+    from app.indicators.lst import LSTIndicator
+    from datetime import date
+    from app.models import TimeRange
+    import numpy as np
+
+    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
+    current_monthly = {1: 28.0, 2: 29.0, 3: 31.0, 4: 33.0, 5: 35.0, 6: 36.0}
+    baseline_per_year_monthly = {
+        1: [26.0, 27.0, 28.0],
+        2: [27.0, 28.0, 29.0],
+        3: [29.0, 30.0, 31.0],
+        4: [31.0, 32.0, 33.0],
+        5: [33.0, 34.0, 35.0],
+        6: [34.0, 35.0, 36.0],
+    }
+    season_months = [1, 2, 3, 4, 5, 6]
+    result = LSTIndicator._build_monthly_chart_data(
+        current_monthly=current_monthly,
+        baseline_per_year_monthly=baseline_per_year_monthly,
+        time_range=tr,
+        season_months=season_months,
+    )
+    assert len(result["dates"]) == 6
+    assert "baseline_mean" in result
+    assert len(result["baseline_mean"]) == 6
+    assert result["label"] == "Daily max temperature (°C)"
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_indicator_lst.py::test_build_monthly_chart_data -v`
+
+Expected: FAIL.
+
+- [ ] **Step 3: Refactor `_api_query` to aggregate daily→monthly**
+
+In `app/indicators/lst.py`, the current `_api_query` fetches daily data and computes a single annual mean. Refactor to also compute monthly means.
+
+After fetching `current_vals` (line 135-138), aggregate into monthly means:
+
+```python
+            # Aggregate daily to monthly means for current period
+            current_monthly: dict[int, list[float]] = defaultdict(list)
+            for t, v in zip(
+                current_resp.json()["daily"]["time"],
+                current_resp.json()["daily"]["temperature_2m_max"],
+            ):
+                if v is not None:
+                    month = int(t[5:7])
+                    current_monthly[month].append(v)
+            self._current_monthly_means = {
+                m: float(np.mean(vals)) for m, vals in current_monthly.items()
+            }
+```
+
+For baseline years, track per-year monthly means:
+
+```python
+            baseline_yearly_means: list[float] = []
+            baseline_per_year_monthly: dict[int, list[float]] = defaultdict(list)
+            for yr in range(baseline_start, current_year):
+                resp = await client.get(ARCHIVE_API, params={...})
+                resp.raise_for_status()
+                data = resp.json()["daily"]
+                yr_monthly: dict[int, list[float]] = defaultdict(list)
+                for t, v in zip(data["time"], data["temperature_2m_max"]):
+                    if v is not None:
+                        yr_monthly[int(t[5:7])].append(v)
+                yr_means = []
+                for m, vals in yr_monthly.items():
+                    monthly_mean = float(np.mean(vals))
+                    yr_means.append(monthly_mean)
+                    baseline_per_year_monthly[m].append(monthly_mean)
+                if yr_means:
+                    baseline_yearly_means.append(float(np.mean(yr_means)))
+
+            self._baseline_per_year_monthly = dict(baseline_per_year_monthly)
+```
+
+Add `_build_monthly_chart_data`:
+
+```python
+    @staticmethod
+    def _build_monthly_chart_data(
+        current_monthly: dict[int, float],
+        baseline_per_year_monthly: dict[int, list[float]],
+        time_range: TimeRange,
+        season_months: list[int],
+    ) -> dict[str, Any]:
+        year = time_range.end.year
+        dates, values, b_mean, b_min, b_max = [], [], [], [], []
+        for m in season_months:
+            dates.append(f"{year}-{m:02d}")
+            values.append(round(current_monthly.get(m, 0.0), 1))
+            yr_means = baseline_per_year_monthly.get(m, [])
+            if yr_means:
+                b_mean.append(round(float(np.mean(yr_means)), 1))
+                b_min.append(round(float(min(yr_means)), 1))
+                b_max.append(round(float(max(yr_means)), 1))
+            else:
+                b_mean.append(0.0)
+                b_min.append(0.0)
+                b_max.append(0.0)
+        result: dict[str, Any] = {
+            "dates": dates,
+            "values": values,
+            "label": "Daily max temperature (°C)",
+        }
+        if any(v > 0 for v in b_mean):
+            result["baseline_mean"] = b_mean
+            result["baseline_min"] = b_min
+            result["baseline_max"] = b_max
+        return result
+```
+
+Update `process()` to use monthly chart data when season_months is provided.
+
+- [ ] **Step 4: Run LST tests**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_indicator_lst.py -v`
+
+Expected: All PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add app/indicators/lst.py tests/test_indicator_lst.py
+git commit -m "feat: LST aggregates daily to monthly, outputs monthly chart data"
+```
+
+---
+
+### Task 9: Refactor NO2 to Monthly Chart Data
+
+**Files:**
+- Modify: `app/indicators/no2.py`
+- Modify: `tests/test_indicator_no2.py`
+
+Same pattern as LST — NO2 fetches hourly data from Open-Meteo, needs to aggregate to monthly.
+
+- [ ] **Step 1: Write test for monthly chart output**
+
+Add to `tests/test_indicator_no2.py`:
+
+```python
+def test_build_monthly_chart_data():
+    from app.indicators.no2 import NO2Indicator
+    from datetime import date
+    from app.models import TimeRange
+
+    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
+    current_monthly = {1: 12.0, 2: 13.0, 3: 14.0}
+    baseline_per_year_monthly = {1: [11.0, 12.0, 13.0], 2: [12.0, 13.0, 14.0], 3: [13.0, 14.0, 15.0]}
+    season_months = [1, 2, 3]
+    result = NO2Indicator._build_monthly_chart_data(
+        current_monthly=current_monthly,
+        baseline_per_year_monthly=baseline_per_year_monthly,
+        time_range=tr,
+        season_months=season_months,
+    )
+    assert len(result["dates"]) == 3
+    assert "baseline_mean" in result
+    assert result["label"] == "NO2 concentration (µg/m³)"
+```
+
+- [ ] **Step 2: Implement — same pattern as LST Task 8**
+
+Refactor `_api_query` to aggregate hourly→daily→monthly. Track per-year monthly means in `_baseline_per_year_monthly`. Add `_build_monthly_chart_data`. Update `process()`.
+
+Note: NO2 uses hourly data (`nitrogen_dioxide`). The timestamps are like `"2025-01-01T00:00"`. Parse month from `t[5:7]`.
+
+- [ ] **Step 3: Run NO2 tests**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_indicator_no2.py -v`
+
+Expected: All PASS.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add app/indicators/no2.py tests/test_indicator_no2.py
+git commit -m "feat: NO2 aggregates hourly to monthly, outputs monthly chart data"
+```
+
+---
+
+### Task 10: Filter Fires Chart Data by Season Months
+
+**Files:**
+- Modify: `app/indicators/fires.py`
+- Modify: `tests/test_indicator_fires.py`
+
+Fires already outputs monthly chart data. Just filter to season_months.
+
+- [ ] **Step 1: Write test for season filtering**
+
+Add to `tests/test_indicator_fires.py`:
+
+```python
+def test_build_chart_data_filters_by_season():
+    from app.indicators.fires import FiresIndicator
+
+    rows = [
+        {"acq_date": f"2025-{m:02d}-15"} for m in range(1, 13)
+        for _ in range(3)  # 3 fires per month
+    ]
+    season_months = [6, 7, 8, 9]
+    result = FiresIndicator._build_chart_data(rows, season_months)
+    assert len(result["dates"]) == 4
+    assert result["dates"][0] == "2025-06"
+    assert result["dates"][-1] == "2025-09"
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_indicator_fires.py::test_build_chart_data_filters_by_season -v`
+
+Expected: FAIL.
+
+- [ ] **Step 3: Update `_build_chart_data` to accept and filter by season_months**
+
+In `app/indicators/fires.py`, update `_build_chart_data` (lines 189-203):
+
+```python
+    @staticmethod
+    def _build_chart_data(rows: list[dict], season_months: list[int] | None = None) -> dict[str, Any]:
+        monthly: dict[str, int] = defaultdict(int)
+        for row in rows:
+            acq = row.get("acq_date", "")
+            if acq and len(acq) >= 7:
+                month_key = acq[:7]  # "YYYY-MM"
+                month_num = int(month_key[5:7])
+                if season_months is None or month_num in season_months:
+                    monthly[month_key] += 1
+
+        sorted_months = sorted(monthly.keys())
+        return {
+            "dates": sorted_months,
+            "values": [monthly[m] for m in sorted_months],
+            "label": "Fire detections per month",
+        }
+```
+
+Update the caller in `process()` to pass `season_months`.
+
+- [ ] **Step 4: Run fires tests**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/test_indicator_fires.py -v`
+
+Expected: All PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add app/indicators/fires.py tests/test_indicator_fires.py
+git commit -m "feat: fires chart data filters to season_months"
+```
+
+---
+
+### Task 11: Full Test Suite & Visual Verification
+
+**Files:** None (verification only)
+
+- [ ] **Step 1: Run the full test suite**
+
+Run: `cd /Users/kmini/Github/Aperture && python -m pytest tests/ -v`
+
+Expected: All tests PASS.
+
+- [ ] **Step 2: Verify no import errors**
+
+Run: `cd /Users/kmini/Github/Aperture && python -c "from app.models import JobRequest; r = JobRequest(aoi={'name':'T','bbox':[36.75,-1.35,36.95,-1.20]}, indicator_ids=['fires'], email='t@t.com', season_start=10, season_end=3); print(r.season_months())"`
+
+Expected: `[10, 11, 12, 1, 2, 3]`
+
+- [ ] **Step 3: Generate a sample monthly vegetation chart**
+
+```bash
+cd /Users/kmini/Github/Aperture && python -c "
+from app.outputs.charts import render_timeseries_chart
+from app.models import StatusLevel, TrendDirection
+render_timeseries_chart(
+    chart_data={
+        'dates': ['2025-04','2025-05','2025-06','2025-07','2025-08','2025-09'],
+        'values': [35, 38, 42, 41, 39, 34],
+        'baseline_mean': [33, 36, 40, 39, 37, 32],
+        'baseline_min': [30, 33, 37, 36, 34, 29],
+        'baseline_max': [36, 39, 43, 42, 40, 35],
+        'label': 'Vegetation cover (%)',
+    },
+    indicator_name='Vegetation & Forest Cover',
+    status=StatusLevel.GREEN,
+    trend=TrendDirection.STABLE,
+    output_path='/tmp/test_monthly_veg.png',
+    y_label='Vegetation cover (%)',
+)
+print('Saved to /tmp/test_monthly_veg.png')
+"
+```
+
+Verify: Monthly baseline band with 6 growing-season months, current data line on top.
+
+- [ ] **Step 4: Verify frontend month picker loads**
+
+Start dev server briefly and check that the month picker dropdowns appear on the "Define Area" page below the date range.