fix(window): hard per-factor gates — wind and cold hours are never recommended

The window's floor is a normalized SUM, so strong factors buy bad ones a
pass: sun and 24C with a 10 m/s blow still scores ~81 — above the floor
and, on a uniformly windy day, above the relative bar too — while the
map is warning "viento fuerte" for that same wind. A clear calm 15C day
passed the same way; the temperature curve only rejects cold when it is
also cloudy.

Each hour now also faces hard gates on the RAW values: wind above
8 m/s (the map's own warning threshold — the window must never recommend
an hour another screen warns about) or temperature below 17C make it
unrecommendable whatever its total, exactly like the existing rain rule.
An unknown value does not condemn the hour; only a measured bad one
does. A day with every hour gated has NO best time — the field goes
null and the interface stays honestly silent, instead of dressing the
least bad hour up as advice.

Gated hours also end a stretch (naming the factor, e.g. arrecia_viento)
and count against it in the motive. Zero extra provider calls.

Tests: uniformly windy sunny day -> null; clear cold day -> null; cold
morning warming into the afternoon -> afternoon recommended with
sube_temperatura as the motive.

Claude-Session: https://claude.ai/code/session_01C4ffvC8qXXWYF9mGemXTvi

Author: oscaruiz

backend/src/__tests__/BeachWindowScorer.test.ts

@@ -160,6 +160,34 @@ describe('buildDayWindow — la mejor franja del día', () => {
     expect(señal?.mejor).toEqual({ inicio: utc(10), fin: utc(15) });
   });
 
+  it('un día entero de viento fuerte no se recomienda: la puerta gana a la nota', () => {
+    // Sol y 24° con 10 m/s normalizan a ~81: por encima del suelo y, siendo
+    // el día uniforme, del listón relativo. El mapa avisa de ese viento; la
+    // ventana no puede recomendarlo a la vez.
+    const ventoso = slots([10, 11, 12, 13, 14, 15], {
+      cloudCoverPct: 5, temperatureC: 24, windSpeedMs: 10,
+    });
+    expect(buildDayWindow(ventoso, MEDIA_MANANA)).toBeNull();
+  });
+
+  it('un día despejado pero frío tampoco: al sol con 15° no es plan de playa', () => {
+    const frio = slots([10, 11, 12, 13, 14], {
+      cloudCoverPct: 5, temperatureC: 15, windSpeedMs: 2,
+    });
+    expect(buildDayWindow(frio, MEDIA_MANANA)).toBeNull();
+  });
+
+  it('mañana fría que templa por la tarde: se recomienda la tarde, por más cálida', () => {
+    const dia = [
+      ...slots([10, 11], { cloudCoverPct: 5, temperatureC: 15, windSpeedMs: 2 }),
+      ...slots([12, 13, 14, 15], { cloudCoverPct: 5, temperatureC: 22, windSpeedMs: 2 }),
+    ];
+    const señal = buildDayWindow(dia, MEDIA_MANANA);
+
+    expect(señal?.mejor).toEqual({ inicio: utc(12), fin: utc(16) });
+    expect(señal?.motivo).toBe('sube_temperatura');
+  });
+
   it('un tramo que cubre toda la franja restante no tiene motivo: no venció a nadie', () => {
     const señal = buildDayWindow(slots([10, 11, 12, 13, 14], BUENA), MEDIA_MANANA);
 

backend/src/domain/use-cases/BeachWindowScorer.ts

@@ -45,6 +45,21 @@ const UMBRAL_CALIDAD = 60;
  */
 const MARGEN_PICO = 12;
 
+/**
+ * Hard per-factor gates: an hour can be unrecommendable even when its TOTAL
+ * clears the bar, because the other factors compensate in the sum. A sunny
+ * 24° hour with a 10 m/s blow still normalizes to ~80 — above the floor and,
+ * on a uniformly windy day, above the relative bar too — and the app's own
+ * map is warning "viento fuerte" for that same wind at the same time.
+ *
+ * The wind ceiling is the map's warning threshold on purpose: the window must
+ * never recommend an hour another screen is warning about. The temperature
+ * floor is where a beach stops being a SWIM plan even in full sun; the score
+ * curve alone only rejects cold when it is also cloudy.
+ */
+const MAX_RECOMMENDED_WIND_MS = 8;
+const MIN_RECOMMENDED_TEMP_C = 17;
+
 /**
  * Why the winning stretch beats the hours it rejected, named by the dominant
  * advantage. `sin_lluvia` wins outright whenever any rejected hour is wet —
@@ -79,6 +94,9 @@ interface SlotEvaluado {
   /** Normalized 0–100 over the factors this slot actually carries. 0 if wet. */
   calidad: number;
   mojado: boolean;
+  /** False when a hard per-factor gate rejects the hour (rain, wind, cold):
+   *  it can never be recommended, whatever its total. */
+  apto: boolean;
   cielo: number | null;
   temperatura: number | null;
   viento: number | null;
@@ -102,12 +120,20 @@ function evaluarSlot(slot: HourlyOutlookSlot): SlotEvaluado | null {
   // part of the analysis at all (and it breaks contiguity — see below).
   if (maximo === 0) return null;
 
+  // Per-factor gates on the RAW values. An unknown value does not condemn the
+  // hour — only a measured bad one does.
+  const apto =
+    !mojado
+    && !(slot.windSpeedMs != null && slot.windSpeedMs > MAX_RECOMMENDED_WIND_MS)
+    && !(slot.temperatureC != null && slot.temperatureC < MIN_RECOMMENDED_TEMP_C);
+
   return {
     timestamp: slot.timestamp,
     // Wet hours can never belong to the best time to go, whatever the sky
     // says: the same philosophy as the score's rain caps.
     calidad: mojado ? 0 : Math.round((suma / maximo) * 100),
     mojado,
+    apto,
     cielo,
     temperatura,
     viento,
@@ -168,7 +194,9 @@ export function buildDayWindow(
     .map(evaluarSlot)
     .filter((s): s is SlotEvaluado => s !== null)
     .map((s) =>
-      vetoHasta != null && s.timestamp < vetoHasta ? { ...s, mojado: true, calidad: 0 } : s,
+      vetoHasta != null && s.timestamp < vetoHasta
+        ? { ...s, mojado: true, apto: false, calidad: 0 }
+        : s,
     );
   if (evaluados.length < 2) return null;
 
@@ -184,7 +212,7 @@ export function buildDayWindow(
   for (const slot of evaluados) {
     const contiguo =
       actual.length > 0 && slot.timestamp - actual[actual.length - 1].timestamp === paso;
-    if (slot.calidad >= liston) {
+    if (slot.apto && slot.calidad >= liston) {
       if (actual.length > 0 && !contiguo) { tramos.push(actual); actual = []; }
       actual.push(slot);
     } else if (actual.length > 0) {
@@ -306,8 +334,10 @@ function buscarCambio(
   liston: number,
 ): { desde: number; causa: OutlookCausa } | null {
   const finTramo = tramo[tramo.length - 1].timestamp;
+  // "Stops being good" now means failing the bar OR a hard gate: a windy
+  // sunny hour can clear the bar on points and still end the stretch.
   const siguiente = evaluados.find(
-    (s) => s.timestamp > finTramo && s.calidad < liston,
+    (s) => s.timestamp > finTramo && (s.calidad < liston || !s.apto),
   );
   if (!siguiente) return null;