fix: aspect ratio, confidence factors, GREEN trend alignment, compound signal gating

- maps: geographic aspect (cos-lat) replaces aspect="auto" that caused skewed rendering
- report: PIL-based _fit_image preserves PNG aspect ratio in PDF layout
- report: coordinate-derived AOI display name when name is missing
- report: drop headline truncation in summary table
- report: 4-factor confidence breakdown incl. anomaly consistency
- narrative: drift/gating-aware interpretations via get_interpretation_for_result
- confidence: continuous scoring, new anomaly_consistency factor, expected_months
- base: status-aware trend (GREEN -> STABLE), evidence-gated classification
- worker: skip GREEN and baseline-drift indicators before compound signal detection

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

app/analysis/confidence.py

@@ -1,8 +1,16 @@
-"""Three-factor confidence scoring for EO products.
+"""Continuous four-factor confidence scoring for EO indicators.
 
-Factors: temporal coverage, baseline depth, spatial completeness.
-Observation density was removed — without per-scene metadata from
-openEO, a hardcoded value adds false precision.
+Factors:
+    - **temporal**: fraction of the analysis period with valid monthly data
+    - **baseline_depth**: fraction of the expected baseline with valid data
+    - **spatial_completeness**: fraction of AOI pixels that are not nodata
+    - **anomaly_consistency**: penalty when anomaly months ≈ total months
+      (high anomaly fraction signals baseline drift, not per-month signal)
+
+All factors are continuous 0..1 — the previous stepped version saturated
+at 1.0 for realistic analyses, producing "1.00 / 1.00 / 1.00 High" on
+every indicator. The new version returns finer-grained values so readers
+can compare relative reliability across indicators.
 """
 from __future__ import annotations
 
@@ -11,46 +19,98 @@ from typing import Any
 from app.models import ConfidenceLevel
 
 
-def score_temporal_coverage(valid_months: int) -> float:
-    if valid_months >= 10:
-        return 1.0
-    if valid_months >= 7:
-        return 0.75
-    if valid_months >= 4:
-        return 0.5
-    return 0.25
+def _clamp(v: float, lo: float = 0.0, hi: float = 1.0) -> float:
+    """Clamp a float into a range."""
+    if v < lo:
+        return lo
+    if v > hi:
+        return hi
+    return v
 
 
-def score_baseline_depth(years_with_data: int) -> float:
-    if years_with_data >= 5:
-        return 1.0
-    if years_with_data >= 4:
-        return 0.75
-    if years_with_data >= 2:
-        return 0.5
-    return 0.25
+def score_temporal_coverage(valid_months: int, expected_months: int | None = None) -> float:
+    """Fraction of analysis months with valid observations.
+
+    If ``expected_months`` is not provided, assume 12 months (legacy calls).
+    Returns a continuous value in [0, 1].
+    """
+    if expected_months is None or expected_months <= 0:
+        expected_months = 12
+    return _clamp(valid_months / expected_months)
+
+
+def score_baseline_depth(
+    baseline_valid_months: int,
+    baseline_years: int = 5,
+) -> float:
+    """Fraction of the expected baseline that has valid monthly data.
+
+    For a 5-year baseline we expect 60 monthly composites. Missing data
+    (cloud cover, sensor gaps) reduces this score proportionally.
+    """
+    expected = max(1, baseline_years * 12)
+    return _clamp(baseline_valid_months / expected)
 
 
 def score_spatial_completeness(fraction: float) -> float:
-    if fraction > 0.9:
+    """Fraction of AOI pixels that are valid (non-nodata).
+
+    Returned unchanged — already continuous.
+    """
+    return _clamp(fraction)
+
+
+def score_anomaly_consistency(anomaly_months: int, total_months: int) -> float:
+    """Penalty when anomaly months approach the total.
+
+    When ~everything is flagged anomalous, that indicates baseline drift or
+    regime shift rather than meaningful per-month signal — so our confidence
+    in the *per-month* reading drops. Returns 1.0 when anomaly fraction is
+    near zero, drops linearly, reaching 0 when 100% of months are anomalous.
+    """
+    if total_months <= 0:
         return 1.0
-    if fraction > 0.75:
-        return 0.75
-    if fraction >= 0.5:
-        return 0.5
-    return 0.25
+    frac = anomaly_months / total_months
+    return _clamp(1.0 - frac)
 
 
 def compute_confidence(
     valid_months: int,
-    baseline_years_with_data: int,
-    spatial_completeness: float,
+    baseline_years_with_data: int = 5,
+    spatial_completeness: float = 1.0,
+    *,
+    expected_months: int | None = None,
+    baseline_valid_months: int | None = None,
+    anomaly_months: int = 0,
 ) -> dict[str, Any]:
-    temporal = score_temporal_coverage(valid_months)
-    baseline = score_baseline_depth(baseline_years_with_data)
+    """Return a four-factor confidence dict for an indicator.
+
+    Backwards-compatible: old callers passing (valid_months,
+    baseline_years_with_data, spatial_completeness) still work. New callers
+    should also pass ``expected_months`` and ``baseline_valid_months`` for
+    better differentiation.
+    """
+    temporal = score_temporal_coverage(valid_months, expected_months)
+
+    # Prefer the more accurate baseline_valid_months when provided; fall
+    # back to years × 12 for legacy call sites.
+    if baseline_valid_months is None:
+        baseline_valid_months = baseline_years_with_data * 12
+    baseline = score_baseline_depth(baseline_valid_months, baseline_years=5)
+
     spatial = score_spatial_completeness(spatial_completeness)
 
-    score = temporal * 0.35 + baseline * 0.35 + spatial * 0.3
+    total_anom_months = expected_months if expected_months else valid_months
+    consistency = score_anomaly_consistency(anomaly_months, total_anom_months)
+
+    # Weighted composite — temporal and baseline dominate; consistency and
+    # spatial are secondary.
+    score = (
+        temporal * 0.30
+        + baseline * 0.30
+        + spatial * 0.20
+        + consistency * 0.20
+    )
 
     if score > 0.7:
         level = ConfidenceLevel.HIGH
@@ -63,8 +123,9 @@ def compute_confidence(
         "level": level,
         "score": round(score, 3),
         "factors": {
-            "temporal": temporal,
-            "baseline_depth": baseline,
-            "spatial_completeness": spatial,
+            "temporal": round(temporal, 2),
+            "baseline_depth": round(baseline, 2),
+            "spatial_completeness": round(spatial, 2),
+            "anomaly_consistency": round(consistency, 2),
         },
     }

app/eo_products/base.py

@@ -224,9 +224,23 @@ class BaseProduct(abc.ABC):
         return dates
 
     @staticmethod
-    def _compute_trend_zscore(monthly_zscores: list[float]) -> "TrendDirection":
-        """Compute trend from direction of monthly z-scores."""
-        from app.models import TrendDirection
+    def _compute_trend_zscore(
+        monthly_zscores: list[float],
+        *,
+        status: "StatusLevel | None" = None,
+    ) -> "TrendDirection":
+        """Compute trend from the direction of monthly z-scores.
+
+        If ``status`` is provided and is GREEN, the trend is forced to
+        STABLE — we do not describe within-normal variation as
+        "improving" or "deteriorating" because it creates contradictory
+        narratives (e.g. "within normal range, trend improving").
+        """
+        from app.models import TrendDirection, StatusLevel
+
+        if status is not None and status == StatusLevel.GREEN:
+            return TrendDirection.STABLE
+
         valid = [z for z in monthly_zscores if z != 0.0]
         if len(valid) < 2:
             return TrendDirection.STABLE

app/eo_products/buildup.py

@@ -353,10 +353,14 @@ class BuiltupProduct(BaseProduct):
         self._zscore_raster = change_raster.astype(np.float32) * 3.0
         self._hotspot_mask = np.abs(change_raster) > 0.5
 
+        expected_months = max(1, n_current_months)
         conf = compute_confidence(
             valid_months=n_current_months,
             baseline_years_with_data=max(1, n_baseline_months // 12),
             spatial_completeness=spatial_completeness,
+            expected_months=expected_months,
+            baseline_valid_months=n_baseline_months,
+            anomaly_months=0,
         )
 
         chart_data = {

app/eo_products/ndvi.py

@@ -192,20 +192,26 @@ class NdviProduct(BaseProduct):
                                  if m in seasonal_stats and seasonal_stats[m]["n_years"] > 0)
             mean_baseline_years = (sum(seasonal_stats[m]["n_years"] for m in range(1, 13)
                                        if m in seasonal_stats) / max(baseline_depth, 1))
+            expected_months = max(
+                1, ((time_range.end - time_range.start).days // 30) + 1
+            )
             conf = compute_confidence(
                 valid_months=n_current_bands,
                 baseline_years_with_data=int(mean_baseline_years),
                 spatial_completeness=spatial_completeness,
+                expected_months=expected_months,
+                baseline_valid_months=baseline_stats.get("valid_months", 0),
+                anomaly_months=anomaly_months,
             )
             confidence = conf["level"]
             confidence_factors = conf["factors"]
 
             status = self._classify_zscore(
-            z_current, hotspot_pct,
-            anomaly_months=anomaly_months,
-            total_months=n_current_bands,
-        )
-            trend = self._compute_trend_zscore(monthly_zscores)
+                z_current, hotspot_pct,
+                anomaly_months=anomaly_months,
+                total_months=n_current_bands,
+            )
+            trend = self._compute_trend_zscore(monthly_zscores, status=status)
 
             chart_data = self._build_seasonal_chart_data(
                 current_stats["monthly_means"], seasonal_stats, time_range, monthly_zscores,
@@ -393,10 +399,16 @@ class NdviProduct(BaseProduct):
                              if m in seasonal_stats and seasonal_stats[m]["n_years"] > 0)
         mean_baseline_years = (sum(seasonal_stats[m]["n_years"] for m in range(1, 13)
                                    if m in seasonal_stats) / max(baseline_depth, 1))
+        expected_months = max(
+            1, ((time_range.end - time_range.start).days // 30) + 1
+        )
         conf = compute_confidence(
             valid_months=n_current_bands,
             baseline_years_with_data=int(mean_baseline_years),
             spatial_completeness=spatial_completeness,
+            expected_months=expected_months,
+            baseline_valid_months=baseline_stats.get("valid_months", 0),
+            anomaly_months=anomaly_months,
         )
         confidence = conf["level"]
         confidence_factors = conf["factors"]
@@ -406,7 +418,7 @@ class NdviProduct(BaseProduct):
             anomaly_months=anomaly_months,
             total_months=n_current_bands,
         )
-        trend = self._compute_trend_zscore(monthly_zscores)
+        trend = self._compute_trend_zscore(monthly_zscores, status=status)
         chart_data = self._build_seasonal_chart_data(
             current_stats["monthly_means"], seasonal_stats, time_range, monthly_zscores,
         )

app/eo_products/sar.py

@@ -205,11 +205,16 @@ class SarProduct(BaseProduct):
                                  if m in seasonal_stats and seasonal_stats[m]["n_years"] > 0)
             mean_baseline_years = (sum(seasonal_stats[m]["n_years"] for m in range(1, 13)
                                        if m in seasonal_stats) / max(baseline_depth, 1))
+            expected_months = max(
+                1, ((time_range.end - time_range.start).days // 30) + 1
+            )
             conf = compute_confidence(
                 valid_months=n_current_bands,
-
                 baseline_years_with_data=int(mean_baseline_years),
                 spatial_completeness=spatial_completeness,
+                expected_months=expected_months,
+                baseline_valid_months=baseline_stats.get("valid_months", 0),
+                anomaly_months=anomaly_months,
             )
             confidence = conf["level"]
             confidence_factors = conf["factors"]
@@ -249,7 +254,7 @@ class SarProduct(BaseProduct):
                     anomaly_months=anomaly_months,
                     total_months=n_current_bands,
                 )
-                trend = self._compute_trend_zscore(monthly_zscores)
+                trend = self._compute_trend_zscore(monthly_zscores, status=status)
                 headline = self._generate_headline(
                     status=status,
                     z_current=z_current,
@@ -510,10 +515,16 @@ class SarProduct(BaseProduct):
                              if m in seasonal_stats and seasonal_stats[m]["n_years"] > 0)
         mean_baseline_years = (sum(seasonal_stats[m]["n_years"] for m in range(1, 13)
                                    if m in seasonal_stats) / max(baseline_depth, 1))
+        expected_months = max(
+            1, ((time_range.end - time_range.start).days // 30) + 1
+        )
         conf = compute_confidence(
             valid_months=n_current_bands,
             baseline_years_with_data=int(mean_baseline_years),
             spatial_completeness=spatial_completeness,
+            expected_months=expected_months,
+            baseline_valid_months=baseline_stats.get("valid_months", 0),
+            anomaly_months=anomaly_months,
         )
         confidence = conf["level"]
         confidence_factors = conf["factors"]
@@ -549,7 +560,7 @@ class SarProduct(BaseProduct):
                 anomaly_months=anomaly_months,
                 total_months=n_current_bands,
             )
-            trend = self._compute_trend_zscore(monthly_zscores)
+            trend = self._compute_trend_zscore(monthly_zscores, status=status)
             headline = self._generate_headline(
                 status=status,
                 z_current=z_current,

app/eo_products/water.py

@@ -196,11 +196,16 @@ class WaterProduct(BaseProduct):
                                  if m in seasonal_stats and seasonal_stats[m]["n_years"] > 0)
             mean_baseline_years = (sum(seasonal_stats[m]["n_years"] for m in range(1, 13)
                                        if m in seasonal_stats) / max(baseline_depth, 1))
+            expected_months = max(
+                1, ((time_range.end - time_range.start).days // 30) + 1
+            )
             conf = compute_confidence(
                 valid_months=n_current_bands,
-
                 baseline_years_with_data=int(mean_baseline_years),
                 spatial_completeness=spatial_completeness,
+                expected_months=expected_months,
+                baseline_valid_months=baseline_stats.get("valid_months", 0),
+                anomaly_months=anomaly_months,
             )
             confidence = conf["level"]
             confidence_factors = conf["factors"]
@@ -211,7 +216,7 @@ class WaterProduct(BaseProduct):
             total_months=n_current_bands,
             min_coverage_pct=current_frac * 100.0,
         )
-            trend = self._compute_trend_zscore(monthly_zscores)
+            trend = self._compute_trend_zscore(monthly_zscores, status=status)
 
             baseline_seasonal_fractions = self._build_seasonal_water_fractions(
                 baseline_stats["monthly_water_fractions"], BASELINE_YEARS,
@@ -275,11 +280,21 @@ class WaterProduct(BaseProduct):
             hotspot_pct=round(hotspot_pct, 1),
             confidence_factors=confidence_factors,
             summary=(
-                f"Water covers {current_frac*100:.1f}% of the AOI (mean MNDWI {current_mean:.3f}, "
-                f"z-score {z_current:+.1f} vs seasonal baseline). "
-                f"{anomaly_months} of {n_current_bands} months show significant anomalies. "
-                f"{hotspot_pct:.0f}% of AOI has statistically significant change. "
-                f"Pixel-level MNDWI analysis at {WATER_RESOLUTION_M}m resolution."
+                (
+                    f"Water covers only {current_frac*100:.1f}% of the AOI — too small to interpret "
+                    f"per-pixel anomalies. The raw z-score ({z_current:+.1f}) and the "
+                    f"{hotspot_pct:.0f}% pixel-level change are dominated by noise (shadows, "
+                    f"dark surfaces, wet soil) rather than real water bodies. Pixel-level "
+                    f"MNDWI analysis at {WATER_RESOLUTION_M}m resolution."
+                )
+                if current_frac * 100.0 < 0.5
+                else (
+                    f"Water covers {current_frac*100:.1f}% of the AOI (mean MNDWI {current_mean:.3f}, "
+                    f"z-score {z_current:+.1f} vs seasonal baseline). "
+                    f"{anomaly_months} of {n_current_bands} months show significant anomalies. "
+                    f"{hotspot_pct:.0f}% of AOI has statistically significant change. "
+                    f"Pixel-level MNDWI analysis at {WATER_RESOLUTION_M}m resolution."
+                )
             ),
             methodology=(
                 f"Sentinel-2 L2A pixel-level MNDWI = (B03 \u2212 B11) / (B03 + B11). "
@@ -287,6 +302,8 @@ class WaterProduct(BaseProduct):
                 f"Monthly median composites at {WATER_RESOLUTION_M}m native resolution. "
                 f"Baseline: {BASELINE_YEARS}-year seasonal baselines (per calendar month). "
                 f"Anomaly detection via z-scores (threshold: \u00b1{ZSCORE_THRESHOLD}). "
+                f"Coverage gate: indicators with <0.5% water area are forced to GREEN — "
+                f"pixel-level z-scores are dominated by noise in near-dry landscapes. "
                 f"Processed server-side via CDSE openEO batch jobs."
             ),
             limitations=[
@@ -407,10 +424,16 @@ class WaterProduct(BaseProduct):
                              if m in seasonal_stats and seasonal_stats[m]["n_years"] > 0)
         mean_baseline_years = (sum(seasonal_stats[m]["n_years"] for m in range(1, 13)
                                    if m in seasonal_stats) / max(baseline_depth, 1))
+        expected_months = max(
+            1, ((time_range.end - time_range.start).days // 30) + 1
+        )
         conf = compute_confidence(
             valid_months=n_current_bands,
             baseline_years_with_data=int(mean_baseline_years),
             spatial_completeness=spatial_completeness,
+            expected_months=expected_months,
+            baseline_valid_months=baseline_stats.get("valid_months", 0),
+            anomaly_months=anomaly_months,
         )
         confidence = conf["level"]
         confidence_factors = conf["factors"]
@@ -421,7 +444,7 @@ class WaterProduct(BaseProduct):
             total_months=n_current_bands,
             min_coverage_pct=current_frac * 100.0,
         )
-        trend = self._compute_trend_zscore(monthly_zscores)
+        trend = self._compute_trend_zscore(monthly_zscores, status=status)
         baseline_seasonal_fractions = self._build_seasonal_water_fractions(
             baseline_stats["monthly_water_fractions"], BASELINE_YEARS,
         )
@@ -467,11 +490,21 @@ class WaterProduct(BaseProduct):
             hotspot_pct=round(hotspot_pct, 1),
             confidence_factors=confidence_factors,
             summary=(
-                f"Water covers {current_frac*100:.1f}% of the AOI (mean MNDWI {current_mean:.3f}, "
-                f"z-score {z_current:+.1f} vs seasonal baseline). "
-                f"{anomaly_months} of {n_current_bands} months show significant anomalies. "
-                f"{hotspot_pct:.0f}% of AOI has statistically significant change. "
-                f"Pixel-level MNDWI analysis at {WATER_RESOLUTION_M}m resolution."
+                (
+                    f"Water covers only {current_frac*100:.1f}% of the AOI — too small to interpret "
+                    f"per-pixel anomalies. The raw z-score ({z_current:+.1f}) and the "
+                    f"{hotspot_pct:.0f}% pixel-level change are dominated by noise (shadows, "
+                    f"dark surfaces, wet soil) rather than real water bodies. Pixel-level "
+                    f"MNDWI analysis at {WATER_RESOLUTION_M}m resolution."
+                )
+                if current_frac * 100.0 < 0.5
+                else (
+                    f"Water covers {current_frac*100:.1f}% of the AOI (mean MNDWI {current_mean:.3f}, "
+                    f"z-score {z_current:+.1f} vs seasonal baseline). "
+                    f"{anomaly_months} of {n_current_bands} months show significant anomalies. "
+                    f"{hotspot_pct:.0f}% of AOI has statistically significant change. "
+                    f"Pixel-level MNDWI analysis at {WATER_RESOLUTION_M}m resolution."
+                )
             ),
             methodology=(
                 f"Sentinel-2 L2A pixel-level MNDWI = (B03 \u2212 B11) / (B03 + B11). "

app/outputs/maps.py

@@ -257,7 +257,8 @@ def render_raster_map(
         rgb_max = max(rgb.max(), 1.0)
         scale = 3000.0 if rgb_max > 255 else 255.0
         rgb_normalized = np.clip(rgb / scale, 0, 1).transpose(1, 2, 0)
-        ax.imshow(rgb_normalized, extent=extent, aspect="auto", zorder=0)
+        geo_aspect = _geographic_aspect(extent)
+        ax.imshow(rgb_normalized, extent=extent, aspect=geo_aspect, zorder=0)
 
     # Render indicator raster overlay
     if indicator_path is not None:
@@ -267,13 +268,14 @@ def render_raster_map(
             ind_extent = [src.bounds.left, src.bounds.right, src.bounds.bottom, src.bounds.top]
         if extent is None:
             extent = ind_extent
+        geo_aspect = _geographic_aspect(extent)
         masked = np.ma.masked_where(
             (data == nodata) if nodata is not None else np.zeros_like(data, dtype=bool),
             data,
         )
         im = ax.imshow(
             masked, extent=ind_extent, cmap=cmap, alpha=alpha,
-            vmin=vmin, vmax=vmax, aspect="auto", zorder=1,
+            vmin=vmin, vmax=vmax, aspect=geo_aspect, zorder=1,
         )
         cbar = fig.colorbar(im, ax=ax, fraction=0.03, pad=0.04, shrink=0.85)
         cbar.set_label(label, fontsize=7, color=INK_MUTED)
@@ -283,6 +285,7 @@ def render_raster_map(
     if extent is not None:
         ax.set_xlim(extent[0], extent[1])
         ax.set_ylim(extent[2], extent[3])
+        ax.set_aspect(_geographic_aspect(extent))
     color = STATUS_COLORS[status]
     _draw_aoi_rect(ax, aoi, color)
 
@@ -301,6 +304,21 @@ def render_raster_map(
     plt.close(fig)
 
 
+def _geographic_aspect(extent: list[float]) -> float:
+    """Return matplotlib aspect ratio that preserves geographic scale.
+
+    For an extent [west, east, south, north] at mid-latitude, 1° of
+    longitude is shorter than 1° of latitude by cos(lat). Setting the
+    axis aspect to 1/cos(lat) makes equal degrees display as equal
+    kilometres.
+    """
+    west, east, south, north = extent
+    mid_lat = (south + north) / 2.0
+    # Guard against division by zero at poles
+    cos_lat = max(np.cos(np.radians(mid_lat)), 1e-3)
+    return 1.0 / cos_lat
+
+
 def render_hotspot_map(
     *,
     true_color_path: str | None,
@@ -316,12 +334,17 @@ def render_hotspot_map(
 
     Only pixels where |z-score| > threshold are shown; non-significant
     pixels are transparent, letting the true-color base show through.
+
+    Uses a geographic (cos-lat-corrected) axis aspect so the image is
+    never stretched when it's later placed into the PDF.
     """
     import rasterio
 
     fig, ax = plt.subplots(figsize=(6, 5), dpi=200, facecolor=SHELL)
     ax.set_facecolor(SHELL)
 
+    geo_aspect = _geographic_aspect(extent)
+
     # True-color base layer
     if true_color_path is not None:
         with rasterio.open(true_color_path) as src:
@@ -330,22 +353,23 @@ def render_hotspot_map(
         rgb_max = max(rgb.max(), 1.0)
         scale = 3000.0 if rgb_max > 255 else 255.0
         rgb_normalized = np.clip(rgb / scale, 0, 1).transpose(1, 2, 0)
-        ax.imshow(rgb_normalized, extent=tc_extent, aspect="auto", zorder=0)
+        ax.imshow(rgb_normalized, extent=tc_extent, aspect=geo_aspect, zorder=0)
 
     # Hotspot overlay — only significant pixels, masked elsewhere
     masked_z = np.ma.masked_where(~hotspot_mask, zscore_raster)
     vmax = min(float(np.nanmax(np.abs(zscore_raster))), 5.0)
     im = ax.imshow(
         masked_z, extent=extent, cmap="RdBu_r", alpha=0.8,
-        vmin=-vmax, vmax=vmax, aspect="auto", zorder=1,
+        vmin=-vmax, vmax=vmax, aspect=geo_aspect, zorder=1,
     )
     cbar = fig.colorbar(im, ax=ax, fraction=0.03, pad=0.04, shrink=0.85)
     cbar.set_label(f"{label} (decline \u2190 \u2192 increase)", fontsize=7, color=INK_MUTED)
     cbar.ax.tick_params(labelsize=6, colors=INK_MUTED)
 
-    # AOI outline
+    # AOI outline and axis limits
     ax.set_xlim(extent[0], extent[1])
     ax.set_ylim(extent[2], extent[3])
+    ax.set_aspect(geo_aspect)
     color = STATUS_COLORS[status]
     _draw_aoi_rect(ax, aoi, color)
 
@@ -398,7 +422,9 @@ def render_overview_map(
     rgb_max = max(rgb.max(), 1.0)
     scale = 3000.0 if rgb_max > 255 else 255.0
     rgb_normalized = np.clip(rgb / scale, 0, 1).transpose(1, 2, 0)
-    ax.imshow(rgb_normalized, extent=extent, aspect="auto")
+    geo_aspect = _geographic_aspect(extent)
+    ax.imshow(rgb_normalized, extent=extent, aspect=geo_aspect)
+    ax.set_aspect(geo_aspect)
 
     # AOI outline
     _draw_aoi_rect(ax, aoi, INK)

app/outputs/narrative.py

@@ -42,6 +42,47 @@ def get_verify_suggestion(product_id: str, status: StatusLevel) -> str:
         return ""
     return _VERIFY_SUGGESTIONS.get((product_id, status), "")
 
+
+def get_interpretation_for_result(result: "ProductResult") -> str:
+    """Return an interpretation that knows about drift/gating diagnostics.
+
+    The plain status-based templates aren't enough for two cases:
+    - SAR baseline-drift flag: status is AMBER but the headline says
+      "baseline may be unreliable". We must not say "Radar signal shows
+      moderate ground-surface changes" — that contradicts the drift call.
+    - Water coverage gate: status is GREEN-by-gate but the underlying
+      z-score is large; we want to acknowledge that the indicator is
+      not actionable in a near-dry landscape rather than just "within
+      seasonal range".
+    """
+    pid = result.product_id
+    headline_lower = (result.headline or "").lower()
+
+    # SAR drift detection — keyed off the headline phrase set by sar.py
+    if pid == "sar" and "baseline may be unreliable" in headline_lower:
+        return (
+            "The radar baseline does not appear stable for this period — "
+            "most months diverge from the 5-year reference. This is more "
+            "consistent with sensor calibration changes, orbit-geometry "
+            "shifts, or a regional regime shift than a real per-month "
+            "anomaly pattern. Treat per-month z-scores as unreliable and "
+            "re-check with a shorter baseline window."
+        )
+
+    # Water coverage gate — keyed off the "0.0% of area" or "covered by water" phrase
+    if pid == "water" and result.status == StatusLevel.GREEN and "0.0%" in (result.headline or ""):
+        return (
+            "The area is essentially dry: the indicator is not meaningful "
+            "below ~0.5% water coverage. Pixel-level z-scores can still "
+            "fluctuate due to shadows, dark surfaces, or wet soil — but "
+            "they don't represent real water bodies."
+        )
+
+    return _INTERPRETATIONS.get(
+        (pid, result.status),
+        f"{pid.replace('_', ' ').title()} status is {result.status.value}.",
+    )
+
 # --- Direction-aware cross-indicator pattern rules ---
 #
 # Each rule describes a pattern of (indicator_id, required_direction) pairs.

app/outputs/report.py

@@ -24,6 +24,59 @@ from reportlab.platypus.flowables import KeepTogether
 
 from app.models import AOI, TimeRange, ProductResult, StatusLevel
 
+
+def _display_aoi_name(aoi: AOI) -> str:
+    """Return a human-readable name for the AOI, or derive one from coordinates.
+
+    If the user didn't set a name (or passed "Unnamed area"), generate a
+    coordinate-anchored label from the bbox centroid, e.g.:
+        "AOI near 12.0°N 24.9°E"
+    The label is deterministic and self-documenting — no reverse geocoding.
+    """
+    raw = (aoi.name or "").strip()
+    if raw and raw.lower() not in ("unnamed area", "unnamed", "none"):
+        return raw
+    west, south, east, north = aoi.bbox
+    lat = (south + north) / 2.0
+    lon = (west + east) / 2.0
+    ns = "N" if lat >= 0 else "S"
+    ew = "E" if lon >= 0 else "W"
+    return f"AOI near {abs(lat):.1f}°{ns} {abs(lon):.1f}°{ew}"
+
+
+def _image_aspect(path: str) -> float:
+    """Return PNG aspect ratio (width / height) using PIL, or 1.33 fallback."""
+    try:
+        from PIL import Image as PILImage
+        with PILImage.open(path) as im:
+            w, h = im.size
+        if h > 0:
+            return float(w) / float(h)
+    except Exception:
+        pass
+    return 4.0 / 3.0
+
+
+def _fit_image(path: str, max_width_cm: float, max_height_cm: float):
+    """Return a ReportLab Image sized to fit within a box preserving aspect.
+
+    Without this, ReportLab forces whatever (width, height) you pass and
+    stretches the PNG — which is exactly the "skewed" bug users noticed
+    where the hotspot map was stretched horizontally in the PDF layout.
+    """
+    from reportlab.platypus import Image as RLImage
+    aspect = _image_aspect(path)  # width / height
+    box_aspect = max_width_cm / max_height_cm
+    if aspect >= box_aspect:
+        # Image is wider than box — constrain to width
+        w = max_width_cm * cm
+        h = w / aspect
+    else:
+        # Image is taller than box — constrain to height
+        h = max_height_cm * cm
+        w = h * aspect
+    return RLImage(path, width=w, height=h)
+
 # Plain-language display names — non-tech readers see these, not the raw IDs.
 _DISPLAY_NAMES: dict[str, str] = {
     "ndvi": "Vegetation health",
@@ -195,8 +248,8 @@ def _product_block(
     chart_exists = chart_path and os.path.exists(chart_path)
 
     if map_exists and chart_exists:
-        map_img = Image(map_path, width=8 * cm, height=6 * cm)
-        chart_img = Image(chart_path, width=8 * cm, height=6 * cm)
+        map_img = _fit_image(map_path, max_width_cm=8, max_height_cm=6)
+        chart_img = _fit_image(chart_path, max_width_cm=8, max_height_cm=6)
         img_table = Table(
             [[map_img, chart_img]],
             colWidths=[8.5 * cm, 8.5 * cm],
@@ -210,12 +263,12 @@ def _product_block(
         elements.append(img_table)
         elements.append(Spacer(1, 2 * mm))
     elif map_exists:
-        img = Image(map_path, width=12 * cm, height=9 * cm)
+        img = _fit_image(map_path, max_width_cm=12, max_height_cm=9)
         img.hAlign = "CENTER"
         elements.append(img)
         elements.append(Spacer(1, 2 * mm))
     elif chart_exists:
-        img = Image(chart_path, width=12 * cm, height=9 * cm)
+        img = _fit_image(chart_path, max_width_cm=12, max_height_cm=9)
         img.hAlign = "CENTER"
         elements.append(img)
         elements.append(Spacer(1, 2 * mm))
@@ -223,8 +276,7 @@ def _product_block(
     # Hotspot change map (if available)
     hotspot_exists = hotspot_path and os.path.exists(hotspot_path)
     if hotspot_exists:
-        from reportlab.platypus import Image as RLImage
-        hotspot_img = RLImage(hotspot_path, width=14 * cm, height=5.5 * cm)
+        hotspot_img = _fit_image(hotspot_path, max_width_cm=14, max_height_cm=7)
         hotspot_img.hAlign = "CENTER"
         elements.append(hotspot_img)
         elements.append(Spacer(1, 2 * mm))
@@ -233,8 +285,11 @@ def _product_block(
     elements.append(Paragraph("<b>What the data shows</b>", styles["body_muted"]))
     elements.append(Paragraph(result.summary, styles["body"]))
 
-    # What this means
-    interpretation = get_interpretation(result.product_id, result.status)
+    # What this means — use the result-aware interpretation so SAR drift
+    # and water coverage gating produce honest narratives instead of the
+    # generic per-status templates.
+    from app.outputs.narrative import get_interpretation_for_result
+    interpretation = get_interpretation_for_result(result)
     elements.append(Paragraph("<b>What this means</b>", styles["body_muted"]))
     elements.append(Paragraph(interpretation, styles["body"]))
 
@@ -309,6 +364,8 @@ def generate_pdf_report(
     PAGE_W, PAGE_H = A4
     MARGIN = 2 * cm
 
+    display_name = _display_aoi_name(aoi)
+
     # ------------------------------------------------------------------ #
     #  Page template with header rule and footer                          #
     # ------------------------------------------------------------------ #
@@ -322,7 +379,7 @@ def generate_pdf_report(
         canvas.setFont("Helvetica", 7)
         canvas.setFillColor(INK_MUTED)
         footer_text = (
-            f"MERLx Aperture \u2014 Situation Report \u2014 {aoi.name} \u2014 "
+            f"MERLx Aperture \u2014 Situation Report \u2014 {display_name} \u2014 "
             f"{time_range.start} to {time_range.end} \u2014 "
             f"Page {doc.page}"
         )
@@ -335,7 +392,7 @@ def generate_pdf_report(
         output_path,
         pagesize=A4,
         pageTemplates=[template],
-        title=f"MERLx Aperture — Situation Report — {aoi.name}",
+        title=f"MERLx Aperture — Situation Report — {display_name}",
         author="MERLx Aperture",
     )
     doc.pageBackgrounds = [colors.white]
@@ -352,13 +409,12 @@ def generate_pdf_report(
     #  SECTION 1: The Place                                               #
     # ================================================================== #
     story.append(Paragraph("MERLx Aperture — Situation Report", styles["title"]))
-    story.append(Paragraph(aoi.name, styles["subtitle"]))
+    story.append(Paragraph(display_name, styles["subtitle"]))
     story.append(Spacer(1, 2 * mm))
 
-    # Overview map (full width)
+    # Overview map (full width) — aspect-preserving
     if overview_map_path and os.path.exists(overview_map_path):
-        from reportlab.platypus import Image
-        img = Image(overview_map_path, width=14 * cm, height=10.5 * cm)
+        img = _fit_image(overview_map_path, max_width_cm=14, max_height_cm=10.5)
         img.hAlign = "CENTER"
         story.append(img)
         story.append(Spacer(1, 3 * mm))
@@ -430,7 +486,7 @@ def generate_pdf_report(
     green_count = sum(1 for r in results if r.status == StatusLevel.GREEN)
     total = len(results)
     count_line = (
-        f"This report covers <b>{total}</b> indicator(s) for <b>{aoi.name}</b> "
+        f"This report covers <b>{total}</b> indicator(s) for <b>{display_name}</b> "
         f"over the period {time_range.start} to {time_range.end}. "
         f"<b><font color='{_RED_HEX}'>{red_count}</font></b> at RED (action recommended), "
         f"<b><font color='{_AMBER_HEX}'>{amber_count}</font></b> at AMBER (worth monitoring), "
@@ -472,7 +528,7 @@ def generate_pdf_report(
             Paragraph(result.trend.value.capitalize(), styles["body_muted"]),
             Paragraph(result.confidence.value.capitalize(), styles["body_muted"]),
             Paragraph(f"{result.anomaly_months}/{total_months}", styles["body_muted"]),
-            Paragraph(result.headline[:90], styles["body_muted"]),
+            Paragraph(result.headline, styles["body_muted"]),
         ])
 
     ov_col_w = PAGE_W - 2 * MARGIN
@@ -573,8 +629,9 @@ def generate_pdf_report(
     conf_header = [
         Paragraph("<b>Indicator</b>", styles["body"]),
         Paragraph("<b>Temporal</b>", styles["body"]),
-        Paragraph("<b>Baseline Depth</b>", styles["body"]),
-        Paragraph("<b>Spatial Compl.</b>", styles["body"]),
+        Paragraph("<b>Baseline</b>", styles["body"]),
+        Paragraph("<b>Spatial</b>", styles["body"]),
+        Paragraph("<b>Consistency</b>", styles["body"]),
         Paragraph("<b>Overall</b>", styles["body"]),
     ]
     conf_rows = [conf_header]
@@ -586,6 +643,7 @@ def generate_pdf_report(
                 Paragraph(f"{f.get('temporal', 0):.2f}", styles["body_muted"]),
                 Paragraph(f"{f.get('baseline_depth', 0):.2f}", styles["body_muted"]),
                 Paragraph(f"{f.get('spatial_completeness', 0):.2f}", styles["body_muted"]),
+                Paragraph(f"{f.get('anomaly_consistency', 1.0):.2f}", styles["body_muted"]),
                 Paragraph(result.confidence.value.capitalize(), styles["body_muted"]),
             ])
 
@@ -593,7 +651,7 @@ def generate_pdf_report(
         conf_col_w = PAGE_W - 2 * MARGIN
         conf_table = Table(
             conf_rows,
-            colWidths=[conf_col_w * 0.20] + [conf_col_w * 0.20] * 4,
+            colWidths=[conf_col_w * 0.25] + [conf_col_w * 0.15] * 5,
         )
         conf_table.setStyle(TableStyle([
             ("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#E8E6E0")),

app/worker.py

@@ -262,17 +262,40 @@ async def process_job(job_id: str, db: Database, registry: ProductRegistry) -> N
                 product_hotspot_paths[result.product_id] = hotspot_path
                 output_files.append(hotspot_path)
 
-        # Cross-indicator compound signal detection
+        # Cross-indicator compound signal detection.
+        # Skip indicators that cannot contribute reliably:
+        #   - GREEN status (no signal, including coverage-gated water)
+        #   - Headlines flagged as baseline drift
+        # This prevents false-positive compound signals fired off pixel-level
+        # noise from indicators we already deemed unreliable at the AOI level.
         from app.analysis.compound import detect_compound_signals
         import numpy as np
+        from app.models import StatusLevel
+
+        unreliable_pids: set[str] = set()
+        for result in job.results:
+            if result.status == StatusLevel.GREEN:
+                unreliable_pids.add(result.product_id)
+                continue
+            headline_lower = (result.headline or "").lower()
+            if "baseline may be unreliable" in headline_lower:
+                unreliable_pids.add(result.product_id)
 
         zscore_rasters = {}
         for result in job.results:
+            if result.product_id in unreliable_pids:
+                continue
             product_obj = registry.get(result.product_id)
             z = getattr(product_obj, '_zscore_raster', None)
             if z is not None:
                 zscore_rasters[result.product_id] = z
 
+        if unreliable_pids:
+            logger.info(
+                "Compound signal detection skipping unreliable indicators: %s",
+                sorted(unreliable_pids),
+            )
+
         compound_signals = []
         if len(zscore_rasters) >= 2:
             # Upsample to finest resolution for best spatial overlap detection